In my case:

wc -l .emacs.d/lisp/larsen-* .emacs.d/init.el | ag total
    2400 total

Also

• My Emacs configuration changes in 2025
• When did you start using Emacs?

A list of the main changes (introducing or eliminating packages, structural changes, important changes in the interface).

(⭐ marks books I particularly liked)

I will not go through the details of how to use it, but I will illustrate a couple of things I recently added to it in my configuration.

I typically use image-dired to manipulate pictures that accompany blog posts and other stuff I publish on my personal website. These pictures are often exported from Google Photos, and when that is the case their size is usually not suitable for web.

So, I want to be able to know their resolution and, when it is too high, to quickly resize them.

More details in the header line

Let's tackle the first problem first. The image-dired header line only displays the name and the size of the the image file.

Unfortunately, image-dired does not provide a direct way to customize the header line format, so I have to recur to advicing.

The general idea of function advicing is to change the behavior of an existing function without altering its original code. More specifically, it allows to provide a new function that is called :before or :after each call to the original function, or even to replace the original function into a new one that can intercept the function call and completely control what is returned (this function composition method is called :around). Refer to the manual for further options and instructions.

In general, I tend to avoid functions advicing because it creates an invisible layer of indirection between the function definition and its behaviour; in other words, it makes it impossible to know the real result of a function call by just looking at the code of its implementation.

Anyway, here my code:

(defun my/image-size (file)
  (with-temp-buffer
    (call-process "identify" nil t nil "-format" "%wx%h" file )
    (buffer-string)))

(defun my/image-dired-enrich-properties (orig-fun buf file image-count props comment)
  (let ((orig-str (apply orig-fun (list buf file image-count props comment)))
        (size (my/image-size file)))
    (concat orig-str " " size)))

(advice-add 'image-dired-format-properties-string :around #'my/image-dired-enrich-properties)

The original function is image-dired-format-properties-string. I encapsulated a call to the external tool identify (part of ImageMagick) into my/image-size, which I then call to add that particular bit of information to the header line string. In what is a typical :around composition pattern, my advice function calls the original function, then adds extra information to the original input.

Here an example of the results:

(defun my/resize-image (file size)
  "Resize the image in FILE to the specified SIZE (interpreted as a percentage). "
  (call-process "magick" nil t nil file "-resize" (format "%d%%" size) file))

(defun image-dired-thumbnail-resize-image ()
  "Resize the image at point. The size is specified at the prompt as a percentage of the original size."
  (interactive nil image-dired-thumbnail-mode)
  (if (not (image-dired-image-at-point-p))
      (message "No thumbnail at point")
    (let* ((file (image-dired-original-file-name))
           (defdir default-directory))
      (with-temp-buffer
        (setq default-directory defdir)
        (if (eq 0 (my/resize-image file (read-number "New size (%): " 50)))
            (message "Successfully resized image")
          (error "Could not resize image: %s"
                 (string-replace "\n" "" (buffer-string))))))))

(keymap-set image-dired-thumbnail-mode-map "Z" 'image-dired-thumbnail-resize-image)

This means that in my ~/bin I have a few scripts, written in Emacs Lisp, that are meant to be run from the command line, outside of an Emacs client.

With that, it comes the need to parse command line parameters.

After writing the same code a couple of times, and since back then I could not find an obvious other choice to do the same thing, I decided it was a good use case for a macro, which I called with-positional-args.

Here how it looks like in user-space. This is part of a script I use to search into annotated PDFs in a directory:

#!/usr/local/bin/emacs --script

;; ... omissis ...
;; (preparing load-path and requiring a couple
;; of features, including the one that implements
;; with-positional-args)

(defun pdf-search (pattern path)
  ;; the details are irrelevant in this context
  )

;; Here we go!
(with-positional-args ((pattern :mandatory "You must provide a PATTERN")
                       (path :default "."))
  (pdf-search pattern path))

And here the implementation:

;; Caveman args list parsing
(defun arg-resolver (arg-properties idx)
  (pcase (car arg-properties)
    (:default
     `(or (nth ,idx command-line-args)
              ,(cadr arg-properties)))
    (:mandatory
     `(or (nth ,idx command-line-args)
          (error (or ,(cadr arg-properties)
                     "Undefined error"))))
    (_ (nth idx command-line-args))))

(defmacro with-positional-args (arglist &rest body)
  "Bind command-line arguments as per ARGLIST, then evaluate BODY.

Each element of ARGLIST has the form: (VAR) for optional argument, (VAR
:default VALUE) for specifying a default value when missing, (VAR
:mandatory [MSG]) for required arguments with optional error message
MSG."
  (declare (indent 1))
  `(let ,(cl-loop for (arg-name . arg-properties) in arglist
                  for idx from 3
                  collect `(,arg-name ,(arg-resolver
                                        arg-properties idx)))
     ,@body))

It was a beautiful, quiet place, and I was assigned a wonderful spot right in front of the lake. This will most likely be my last night out this year, but it was a great one.

‹ ›

Click image to magnify

×

the appeal of this project was again the immense pain, in this case of making any sense of a text which would give me headaches even in my native language

I had it lying around for years, but about two weeks ago I finally tried Ingenious with a couple of friends.

It was very easy to learn, and enjoyable. Now I want to try and implement a program that can play a game.

You can see my old post for details about that feature, but basically, the patch allows one to use a :dbconnection header argument in a source block to reference a connection defined in sql-connection-alist.

The question in Magnus' post is a signal somebody is actually using this feature, so I am pleased. Perhaps I should also follow up, describing how I use this feature in my workflow. This will constitute another example of how to manage secrets.

I use Org, among other things, to keep work "lab notes" that usually contain SQL queries on different databases.

At work, pretty much all databases are Postgresql or Redshift, and I keep connection details in ~/.pgpass, following this format:

In other words, every DB definition is made of two lines: the first is a comment, with the name of the database (with no spaces); the second contains the actual connection details.

In my Emacs configuration, then, I have this function:

(defun get-connection-alist (filename)
  "Gets PG connections details from ~/.pgpass file (FILENAME)."
  (with-current-buffer (find-file-noselect filename)
        (let ((lines (split-string (buffer-string) "\n" t)))
          (when lines
            (cl-loop for (k v) in (seq-partition lines 2)
                  collect (cl-destructuring-bind (host port db user password)
                              (split-string v ":" nil)
                            `(,(replace-regexp-in-string "^#\s+" "" k)
                              (sql-product 'postgres)
                              (sql-port ,(string-to-number port))
                              (sql-server ,host)
                              (sql-user ,user)
                              (sql-database ,db)
                              (sql-password ,password))))))))

and

(setq sql-connection-alist (get-connection-alist "~/.pgpass"))

I use Emacs in daemon mode and it's not unusual Emacs to stay up for weeks, so I also have an automatic way to incorporate .pgpass changes, using filenotify.

(file-notify-add-watch
 "~/.pgpass" '(change)
 (lambda (evt)
   (setq sql-connection-alist
         (get-connection-alist "~/.pgpass"))))

×

Hygieia as the goddess of health and hygiene in Greek mythology and its surrounding figures represents the power and pureness of the water. It was built in remembrance of the cholera epidemic in 1892, the former technical purpose was air cooling in the city hall

According to Statshunters so far I covered a non-random number of squares in Germany.

BB(5) has been verified to be equal to \(47,176,870\).

Years ago, when I was a student, I remember finding the University of Waterloo's "Handout on The Busy Beaver Problem" the easiest and most succinct introduction to the topic. Later, I found Dewdney's piece about busy beavers in the "The new Turing omnibus", perhaps a more famous source.

Remarkably, Waterloo's handout already contained the result from Marxen and Buntrock (1990), but it was a lower bound. Removing that ">" took 34 years. Here the table as presented in the handout:

After many years since my last visit, I spent a long weekend in London. Among my various impressions, I note that I didn't touch any cash whatsoever for the entire stay. Even more: if it weren't for a guy in front of me at the cash register in a pub, who was paying with a banknote, I would've not seen any cash during my visit. I imagine this can lead to overspending, but nice.

So far the process has been manual: when I had significant updates to publish I just copied text from one org file (in org-roam) to another. But I wanted something more systematic.

I therefore added this two functions in my Emacs configuration

(defun my/remove-org-roam-links (buffer-as-string)
  (replace-regexp-in-string
   "\\[\\[id:.*\\]\\[\\(.*\\)\\]\\]" "\\1" buffer-as-string))

(defun my/paste-org-roam-node (initial-input &key no-links)
  (interactive)
  (let* ((file (org-roam-node-file (org-roam-node-read initial-input)))
         (raw-buffer (with-current-buffer (find-file-noselect file)
                       (goto-char (point-min))
                       (buffer-string))))
    (if no-links (my/remove-org-roam-links raw-buffer)
      raw-buffer)))

Then I can use a snippet like this in the destination buffer

#+begin_src emacs-lisp :results value raw append
  (my/paste-org-roam-node "through" :no-links t)
#+end_src

And this appends to the file the contents of the original org-roam note (I happen to have a note titled "Through the Language Glass", so that 'through' is enough to identify a node), after stripping, if requested, the links to other notes.

There's still some manual work to do before one can post, but this solution is already an useful improvement.

Actually, when I browse my pages myself, I use browser add-ons to apply a personalized CSS and even some JS facility. And I change the style often. Here how it currently looks like.

And the respective CSS and JS I use with User JS and CSS Chrome extension to implement it.

https://stefanorodighiero.net/misc/personal.css

https://stefanorodighiero.net/misc/personal.js

Here the code I used (I just omitted a few service functions)

(defun split-org-file (input-file output-dir)
  "Split an .org file into separate files for each top-level entry.
INPUT-FILE is the path to the .org file.
OUTPUT-DIR is the directory where the separate files will be saved."
  (with-current-buffer (find-file-noselect input-file)
    (goto-char (point-min))
    (org-map-entries
     (lambda ()
       (let* ((entry-title (nth 4 (org-heading-components)))
              (tags (parse-tags-into-filetags
                     (nth 5 (org-heading-components))))
              (ts (get-timestamp-from-title entry-title))
              (entry-title-stripped (strip-entry-title entry-title))
              (output-file (expand-file-name
                            (format "%s.org" (dirify-string entry-title-stripped))
                            output-dir)))
         (let ((body (org-copy-subtree))
               (cleaned-body (with-temp-buffer
                               (insert (car kill-ring))
                               (goto-char (point-min))
                               (when (re-search-forward "^\\*+ \\(.*\\)$" nil t)
                                 (replace-match "" nil nil))
                               (buffer-string))))
           (with-temp-file output-file
             (insert (format "#+title: %s\n" entry-title-stripped)
                     (format "#+date: %s\n" (or ts "2000-01-01"))
                     (format "#+filetags: %s\n" (or tags ""))
                     "\n\n"
                     (format "%s" cleaned-body))))))
     "LEVEL=1")))

"beach", "classic" and "lake" represent three different routes each participant could choose from, respectively ~400km (2800m total ascent), ~720km (4300m), ~400km (1800m). The editions of 2024 and 2023 presented the same choices, with the major difference that the direction of the routes was reversed. 2024's edition had also a new 200km (2800m) option which I didn't analyze.

I was interested to see if the median finisher time (indicated by the dashed line in the charts) would change, which I intended as a possible answer to the question "Would reversing the direction make the routes easier or harder?".

Data show that for "classic" and "beach" it didn't change, but the value is significantly higher for 2024 for the Lake route. (I, by the way, completed the Lake route in 53 hours and 16 minutes).

Not sure how to explain that. It's true the weather was worst in 2024, and I know several cyclists (including me) were blocked by a storm on Sunday, but that lasted only a couple of hours, not enough to explain the significant increase in median time.

Perhaps the population of cyclists that chose the Lake route was made of less experienced athletes, that had to take more time to complete it. Not sure.

classic2023 <- processfile("2023/data/classic.txt", "classic", 2023)
beach2023 <- processfile("2023/data/beach.txt", "beach", 2023)
lake2023 <- processfile("2023/data/lake.txt", "lake", 2023)

classic2024 <- processfile("2024/data/classic.txt", "classic", 2024)
beach2024 <- processfile("2024/data/beach.txt", "beach", 2024)
lake2024 <- processfile("2024/data/lake.txt", "lake", 2024)

convert_elapsed_time_to_minutes <- function(elapsed_time_str) {
  time_parts <- str_split(elapsed_time_str, ":")[[1]]
  hours <- as.integer(time_parts[1])
  minutes <- as.integer(time_parts[2])
  total_minutes <- (hours * 60) + minutes
  result <- total_minutes
}

processfile = function(filepath, track, year) {
  df <- read.table(
    text=gsub(" – ", "\t", readLines(filepath)),
    sep="\t"
  )

  names(df) <- c("country", "name", "elapsed_time")

  return(df
         %>% rowwise()
         %>% mutate(elapsed_time_minutes = convert_elapsed_time_to_minutes(elapsed_time))
         %>% mutate(track = track)
         %>% mutate(year = year)
         %>% filter(elapsed_time_minutes > 0)
         %>% filter(elapsed_time_minutes < 10000) # filter outliers
         %>% select(country, track, year, elapsed_time_minutes)
  )
}

data <- bind_rows(classic2023, beach2023, lake2023,
                  classic2024, beach2024, lake2024)

data_medians <- data %>% group_by(year, track) %>% summarize(x=median(elapsed_time_minutes))

data_count <- data %>% group_by(year, track) %>% summarize(x=n())

x_labels <- function(m) {
  res <- round(m / 60, 2)
  paste(res, 'h',sep = "")
}

ggplot(data, aes(x=elapsed_time_minutes, color=track)) +
  geom_histogram(binwidth = 60) +
  facet_grid(cols=vars(track), rows = vars(year)) +
  geom_vline(data = data_medians, aes(xintercept = x),
             linetype="dashed") +
  geom_text(
    data=data_medians,
    aes(x=x, label=x_labels(x), y=25),
    size = 4,
    nudge_x=+1000,
    color = 'black'
  ) +
  geom_text(
    data=data_count,
    aes(x=0, label=paste("# finisher:", x), y=35),
    size = 4,
    nudge_x=1500,
    color = 'black'
  ) +
  scale_x_continuous(breaks=c(60*24, 60*48, 60*72, 60*48*2, 60*24*5),
                     label=x_labels) +
  xlab("Tempo totale") +
  ylab("Numero di finisher") +
  theme_solarized() +
  theme(
    legend.position = "none",
    axis.title = element_blank(),
    axis.line.x = element_line(linewidth=.8),
    axis.ticks.x = element_line(linewidth = .8) ,
    axis.ticks.length.x = unit(.5, "cm"),
    panel.border = element_blank(),
    panel.grid = element_blank(),
    plot.title = element_text(face="bold", size=21)
  ) +
  ggtitle("Venetogravel: confronto distribuzione tempi finisher")

(def plan-start-19
{:description "Starting on April 19th"
 :daily-plans [{:label "Day 1"
                :activities [{:start "15:00" :length 6 :type :ride}]}
               {:label "Day 2"
                :activities [{:start "07:00" :length 5 :type :ride}
                             {:start "17:00" :length 3 :type :ride}]}
               {:label "Day 3"
                :activities [{:start "08:00" :length 6 :type :ride}]}]})

which results in

To do:

• integrate data from GPX files (altitude is fundamental)
• learn how to rotate entities with SVG (transformations seem to work in the least intuitive ways)

The setup is now more compact and feels more comfortable.

The front bag contains the sleeping bag (15 ⁰C) and both the tent layers (Naturhike Cloudup 2). I didn't think it was possible, but it was just a matter of squeezing (and believing) harder. Also, not using compression bags helps, because this way the material is more free to occupy all available space.

This makes the front bag slightly wider, so I had to add spacers to keep it clear of the levers.

I added an Ortlieb accessory bag on the front, where I put food and some kitchen tools (nothing particular, a collapsible bowl, sporks, … stuff like that)

The saddle bag is much smaller and shorter, which makes the bike easier to handle. It now contains just the mat, the tent base layer, stove + pot (another new addition to my kit), and clothes.

I am quite satisfied with the results. One thing I have to learn is how to re-pack things so that dirty or slightly soggy clothes don't ruin other clean items; this would allow me to do longer journeys.

$ cat .inputrc
set completion-ignore-case on

Cool that it is so easy to include an inspector in the GUI:

defaultLayout

  | rt |
  rt := Raytracer new.
  rt scene: (Scene demo).

  ^ SpBoxLayout newLeftToRight
    add: (SpBoxLayout newTopToBottom
      add: (SpMorphPresenter new morph: (rt imageMorph));
      addLast: (SpPresenter new newButton label: 'Render';
        action: [rt render] ) expand: false;
      yourself);
    add: (StInspector new model: (rt scene objects) );
      yourself

From Ron Gilbert's blog.

"The Muse visits during the act of creation, not before. Don't wait for her. Start alone." - Roger Ebert

One of my favorite quotes and one I keep needing to remind myself of. No matter how blocked or stuck I am, if I just force myself to start writing or designing, it's not long before the ideas start flowing.

A Pictorial Guide to the Lakeland Fells is a series of seven books by A. Wainwright, detailing the fells (the local word for hills and mountains) of the Lake District in northwest England. Written over a period of 13 years from 1952, they consist entirely of reproductions of Wainwright's manuscript, hand-produced in pen and ink with no typeset material.

A bit above 100km in a single ride.

And here Veloviewer's map update. Max square still 3x3, but I covered more territory.

• Reading more books than those I read during 2019.
• Contribute to an open source project. In 2019 I was particularly happy because I managed to get a patch accepted for a tool I use daily (org-mode).
• Riding my bike for a total of 3500 km. I only recently got more serious about biking. At the moment I am not interested at all in speed and pure performance: for me it's more about exploring and spending time outdoor, but yet I started collecting data.
  • Why 3500? I initially thought 3000, because it's a nice round number. But it didn't make me unconfortable, as an objective should do. Adding 500 km does, yet it should not be a crazy stretch, especially if I develop the habit of using the bike instead of U-Bahn for commuting. I plan to post monthly reports here.
  • As a sub-goal, I'd like to try bikepacking, at least for a weekend.
• Start and publish a software project: I had several ideas over the last years, but all of them didn't go beyond the explorative or half-baked idea stage.
• Make some efforts at learning German (I'd like to reach a level where I can read articles and simple books).
• Stop wasting my time.
• Continue tracking expenses, sleeping and physical activities.

Novels

• 2 extra switches (backtick and backslash will no longer need fn)
• injection-molded case with smaller dimensions
• detachable USB cable
• default firmware is Kaleidoscope (QMK will still work)
• cherry-MX-compatible switches in sockets (removable without soldering)
• optional labels on keycaps

• How to Interview a Programmer
• Advanced Programming Language Features for Executable Design Patterns

$ xdg-mime query default inode/directory
nautilus-folder-handler.desktop
$ locate Thunar.desktop
/usr/share/app-install/desktop/thunar:Thunar.desktop
/usr/share/applications/Thunar.desktop
/usr/share/xfce4/helpers/Thunar.desktop
$ xdg-mime default Thunar.desktop inode/directory

Some parts of Emacs GUI are not configurable through faces (obvious). My Emacs is compiled with GTK 3.0, so it uses that library to render some of the elements of the GUI (even more obvious). Tooltips are among those elements. So, in order to change their style, I need to intervene on the configuration of GTK. For example, I had this:

Creating a file ~/.config/gtk-3.0/gtk.css:

@define-color tooltip_bg_color #fff8dc;
@define-color tooltip_fg_color Black;

and restarting Emacs, I obtain this:

This is very useful, but I'd also like to be able to use symbolic references to connections defined elsewhere, so that for example one does not have to specify the password every time, interactively or, worse, in the .org file itself.

I am also a user of sql.el, that provides a custom variable sql-connection-alist, where users can define a mapping between connection names and connection details.

The patch I submitted extends the behavior of org-babel-execute:sql so that it's possible to specify a new param :dbconnection containing a connection name, used for looking up sql-connection-alist.

by Joaquim Vancells

• Nate Silver's The Signal and the Noise
• The Language Instinct by Steven Pinker
• The Wandering Earth by Cixin Liu. I heard about Cixin Liu for the first time when he was nominated for the Hugo Awards, but never tried reading anything. This one is ideal, as it is a collection of shorter novellas.

Quoted in a profile of Donald Knuth published on NYTJ.

Over the past decade, we have designed six typefaces based on mathematical theorems and open problems, specifically computational geometry. These typefaces expose the general public in a unique way to intriguing results and hard problems in hinged dissections, geometric tours, origami design, computer-aided glass design, physical simulation, and protein folding. In particular, most of these typefaces include puzzle fonts, where reading the intended message requires solving a series of puzzles which illustrate the challenge of the underlying algorithmic problem.

• Jonathan Strange & Mr.Norrell was repeteadly recommended by colleagues. Years ago, when the book was published and gained attention and success, I somehow didn't notice: I have only a vague idea about the subject and the plot, so I'm excited about what I'm about to discover.
• I took Greek Mathematical thought and the origins of Algebra largely because of a casual conversation I recently had about mathematical formalism and its history. I had only sketchy ideas about the subject, so I thought this one could be useful reference material.
• I am curious about Decoding the Universe (let's see if the book can hold up to the hype of that subtitle)
• The Mathematical Theory of Communication is a classic, picking it up was an easy decision.
• I have never read anything by Ray Kurzweil so when I saw this The Age of Spiritual Machines I put it on my pile without hesitation.
• For quite opposite reasons, but with the same effect, I grabbed this copy of I am a strange loop

I would be supposed to be learning German but as of today my exposure is still quite limited. I think the only times when I see the letter ß is when reading street signs.

Perhaps the reason is that no one has (ever) solved the spatial problem, and the cosmos is littered with time travelers adrift between the stars and galaxies.

The USDA Pomological Watercolor Collection documents fruit and nut varieties developed by growers or introduced by USDA plant explorers around the turn of the 20th century. Technically accurate paintings were used to create lithographs illustrating USDA bulletins, yearbooks, and other series distributed to growers and gardeners across America.

Kudos to my teacher from last summer watercolor lessons for finding this pearl.

The venue is in the complex of Charité – Universitätsmedizin Berlin: Forum 3 is a nice building and has also some space outdoors (fortunately the conference days were blessed by sun and a nice temperature).

• First keynote was not strictly related to Python or data science/engineering. It was an extremely interesting, fun and in some moments moving account of the hacker scene in Romania before the collapse of Ceaușescu's regime in the eighties. The story of the COBRA was particularly interesting (COBRA is a Romanian clone of ZX Spectrum, the result of a remarkable process of reverse-engineering, glorious stubborness and sometimes not-strictly-legal work-arounds).
• Next I attented Five things I learned from turning research papers into industry prototypes. A practical collection of advices if you are tasked with the mission of converting some "theory" from a paper into something executable. Apparently a problem the audience could relate to a great deal. You can find the slides here.
• Simple diagrams of convoluted neural networks seemed interesting, but unfortunately the presentation was hard to understand to my ears. Anyway, I managed to extract some value from it, mostly because the arguments led me to think about the general problem of devising a notation for expressing and describing a complex system (like a NN): it should make the reader able to follow the process step by step, it should make it easier to spot errors in the system, it should adhere consistently to the metaphor –if any– it decides to follow, it should pay attention to representing clearly what and how it's combined in the various phases of the process, and it should be dynamic (so apparently trying to represent neural networks using a static diagram is a lost cause?). The speaker said that the baseline is currently very low, and there's much space for improvement. The slides.
• Compared to the previous talk, Launch Jupyter to the Cloud: an example of using Docker and Terraform was very basic but very well presented. The lesson is you can use Terraform and Docker to completely describe (thus making it really reproducible) the entire configuration needed for an experiment (being it some data analysis task, a Jupyter notebook, things like that). The slides.
• I was particularly excited about the talk coming after the lunch break: Let's SQL Like It's (NOT) 1992! The main point of the speaker is that writing SQL is usually a skill one learns in college, then it's only rarely refreshed and kept up to date with the improvements to the standard. Also, SQL is frequently thought only as a query language, but it actually includes a data modeling language and a data definition language. The presentation was compelling and well delivered (it was actually a live coding session), but unfortunately James run out of time and had to stop abruptly and pass the podium to the next speaker before arriving at the most interesting parts of his talk. He promised to put the code on github. Besides a couple of idioms I didn't see before the talk, I discovered a seemingly useful extension for PostgreSQL, allowing users to implement bitemporal tables automatically (so that it's possible to have usual CRUD primitives, and still be able to reconstruct the state of the dataset at any given time).
• Next talk was A/B testing at Zalando: concepts and tools. A researcher from Zalando illustrated the tools (and the mindset) they adopted for conducting A/B tests. An endevour they took very seriously, apparently, as they dedicated 3 BE Engs + 3 FE Engs + 4 Researchers + 3 Product managers = 13 persons to it. They developed an internal tool called Octopus and released a OS Python library called ExPan for statistical analysis of randomised control trials. Highlights: one of the attendees asked what are common pitfalls when developing A/B tests. According to the speaker, one is testing too many variables at once (he said they're developing techniques to automatically detect variable "interference" in A/B experiments, such as frontend variations that can reciprocally hinder each other). Another common error is stopping the experiment too early (for example because management wants answers faster), leading to results that have no statistical relevance. He also stressed the point that stats and probability form only half of the picture: business stakeholders need to be involved from the very beginning (e.g. How much running an experiment cost?)
• Frankly, I chose next talk because I had headache, the other ones in this time slot seemed a bit above my head so I chose something simple: Solving very simple substitution ciphers algorithmically. It was about a toy problem (automatically decyphering mono-alphabetic substitution codes) so nothing new, but what I liked very much is that the speaker was a mathematician, and it was a pleasure following the terse, ordinate and precise explanation ("Let me first name and define a few things").
• The second keynote of the first day was about GDPR. It was a nice round up from the point of view of the legislator, explaining the principles (old and new) underlying the regulation. The juicy part came during the Q&A afterwards, according to me. First question was about a practical problem that might rise in the context of ML: what if some data a user decided to let the controller store is used to train a model, and then the same user asked for that data to be deleted? Is the model still valid? The speaker explained this is out of the scope by GDPR, it's an open question and she would be interested in reading a paper about that if someone would bother to write one. Second question was a bit of a critique: GDPR is endangering small startups and grassroot association that don't have the resources to implement what's needed for complying with the regulation: the speaker said it's a common problem and added that in her opinion the time (two years, more or less) we had to prepare for GDPR was not very well spent: we should have a platform allowing anyone to comply with GDPR using ready tools. We're not there yet.
• Last of the first day was the lighting talks session. I particularly like this formula: very brief (5 minutes) but intense talks about various topics, useful for those that had no time to prepare a full fledged about their idea. The most interesting was the "Don't trust your data" talk: a Phd student discovered a dataset about chemical compound skin penetration, used since the 60s is incomplete, yet used over time in many research endevours (such as training 20+ ML models). He went back to the original papers illustrating the dataset, discovered many more features were available, and published a new refined dataset. Certainly a lesson in questioning your input. End of first day.
• Second day opened with a keynote: Fairness and Diversity in Online Social Systems.
• Next, mobile.de (an Ebay company) presented the architecture and the tools they use to offer their users a personalized web experience, and specifically to infer future users' behaviour using a stream of events describing their usage of the website. They started using Hive (with Jinja2 to generate SQL queries) but then switched to (Py)Spark, gaining a 5x time improvement and, according to their judgement, a much easier system to understand. They didn't publish the slides but I found some pointers on one of the speakers' personal website: “Which car fits my life?” - mobile.de’s approach to recommendations.

• In Going Full Stack with Data Science: Using Technical Readiness Level to Guide Data Science Outcomes Emily Gorcenski suggested we could use NASA's TRL (a scale used by engineers to measure progress of technology) adapting it into a "Data Science Readiness Levels" scale. Here the original scale, with a possible translation for software products and for data science projects.

  TRL	Product	Data Science
  Basic principles observed	Need or shortcoming identified	Algorithm design & development
  Technology concept formulated	Technology concept formulated	Data explored and described
  Experimental proof of concept	Tests written	Experimental proof of concept
  Technology validated in lab	Tests passing on dev machines	Algorithm validated against sample data
  Technology validated in relevant environment	Tests passing in develop	Algorithm validated against production data
  Technology demonstrated in relevant environment	In QA	Algorithm integrated in develop
  Prototype demonstrated in relavant env.	Beta version in limited staging	Prototype demostrated in operational env.
  System complete and qualified	QA passed and ready for staging	System complete and qualified
  System proven in operational env.	System running in production	System proven in operational env.

  She proposed the idea of "full-stack teams" (opposed to full-stack devs, unrealistic if one has to take seriously the amount of knowledge modern system engineering encompasses), and the fact that data science / data analysis is inseparable from the other facets of a software project, since its inception.

• In Data versioning in machine learning projects Dmitry Petrov started from what I think is a very common problem: we have good tools to manage code versioning, but the same can't be said about versioning data. More generally, he stated that while hardware development has a well established methodology (Waterfall), and software development has one as well (Agile/Scrum), the same can't be said for data related projects. He presented a tool he's developing called DVC, an extension to git (similar to git-annex in some aspects) specifically designed for managing large volumes of data.
• Big Data Systems Performance: The Little Shop of Horrors by Jens Dittrich was in large part a tirade against the over-hyped terms like "Big Data" &co, that often bring more confusion than clarity when it comes to evaluate a solution for a data related problem. This lack of clarity hinders reaching an efficient solution, because of the mix of three "dimensions" that should instead be orthogonal (as the name Dittrich chose suggests): 1. fancy sounding buzzwords, 2. technical principles and patterns, 3. software platforms. He dismissed the first as good only for marketing (he apparently had a bad opinion about marketing), he said being familiar with 3 is important, but even more important is knowing very well 2, because those principles are ubiquitous and more solid. He brought a real life example, where he obtained a 10000x speed improvement applying different patterns and tools from the already existing solution.

• Overall, I like the syntax. More specifically, I like the fact there are very few principles that uniformly apply in many situations. Most of the time I can "invent" the way something has to be written and it usually turns out as the right form.
• I like the ecosystem I've seen so far: pandas is a great tool, for example. I'm struggling with SQLAlchemy, but I never quite liked ORMs anyway.
• I am trying to follow PEP8, even if I have quite different ideas at least about aestethics in code (first time I run pylint on a script I scored -8.61/10).
• I didn't quite get yet the way modules are organized on the file system.
• I feel the documentation lacks regularity and completeness. I can find a lot of tutorials about any topic, but I still could not find a systematic source to use as a reference.

Excellent content on the Atreus mailing list. An user shows how he used Ragel state machine compiler to implement the logic of his Atreus' controller. Impressive and very interesting.

(via ariis' stream)

I understand and I can sympathize with the nuisances the author mentions (the error messages!), but I do not hate LaTeX.

I use LaTeX for practically everything I need to print. Actually, for most of the things I use org-mode, using its exporter later to obtain a LaTeX or a PDF document – via LaTeX, again – when needed. When I don't need anything special, it's good enough. And it's all plain text, which is also good.

When I need something special, I can thrown in some packages doing the work for me. If I need something very special, well, it might lead me to swearing and tears and whatnot, but I know at the end I'll have something largely more manageable than any other system I know could give me.

Yesterday I spent the entire day in Rome to attend another Haskell meeting. It's been quite a productive and interesting event: as usual, instead of talks we had impromptu groups engaged in different practical projects. Yesterday, the majority of people followed a beginners course. In my case, I showed my Wiz project to some more experienced programmers, receiving a great deal of observations, questions and suggestions. Other remarks: I saw a "Frankenpad" and learned some details about it; I showed my mechanical keyboards to other aficionados; I unexpectedly received a bottle of Rohrer & Klingner Leipziger Schwarz fountain pen ink (thank you!).

One of our many problems with thinking is “cognitive load”: the number of things we can pay attention to at once. The cliche is 7±2, but for many things it is even less. We make progress by making those few things be more powerful.

An interview with Alan Kay caught my attention this weekend. There are many things worth noting and I invite you to read the entire article, but a few of them are particularly interesting.

And by the way, chat and tweeting? Remove that, because the utterances are so small, they’re basically transliterations of oral. And that has been studied in Africa by some of Jerome Bruner’s students.

Putting a writing system into an oral society doesn’t actually do it, doesn’t change them. It requires something more, because the thing that’s important about writing and how it changes the thinking of the civilization is the literate aspects of it, the structure and the thought, in various ways. Anyway, so this is all stuff that’s water over the dam, but most people don’t understand it. Most people in media don’t understand it.

In fact, mobile computers, he says, have turned out to be mind-numbing consumption devices—sophisticated televisions—rather than the wheels for the mind that Steve Jobs envisioned.

One nice thing about Lisp and image based dev environments is that they make the act of exploring easier and more frictionless. This means producing something working is easier, when you're learning a new API or technology. On the other hand they make easier also to transform a crack-fueled idea into something deceitfully working, especially if you don't know well the domain. Thus breaking the rule "Right things should be easier to do", I guess.

• Riding bike. Berlin is a very nice city to visit with a bike. Most of the streets have room dedicated to cyclists. Gardens and parks are a few minutes away, wherever you are. I guess the average velocity of the bikers is higher compared to Italy. Average attention and respect is higher too.
• Programming
  • Some progress with my Scheme interpreter, the environment model is kind of working (enabling features like closures), but I'm still having problems with quoting (this is what prevents me from pushing lastest changed to a public repository).
  • Minor fiddling with Lisp, specifically using CEPL (I have I rather ambitious project idea).
• Reading
  • Designing Data-Intensive Applications by Martin Kleppmann
  • The Rise and Fall of Dodo by by Nicole Galland and Neal Stephenson
  • Winter of the World by Ken Follett. A friend recommended the Century Trilogy to me (this is book two). Not my usual genre, but it flows easily and as I developed an attachment for some of the characters, I want to know what is going to happen to them.
• Painting
  • I was scouting the web for technical conferences to attend, but I found instead a watercolor course for beginners. One could even register for just one lesson. I ended up doing five (7.5 hours total). It was very fun, interesting and useful, absolutely worth the money. And I made some new friends in the process. Call it serendipity.
• Playing
  • See below about The Swapper

Decided to download a new game from Steam, The Swapper. Interesting game mechanic, and daunting sci-fi setting.

I started reading last Neal Stephenson's (and Nicole Galland's) novel. I'm only a few dozen pages into the book: it's soon to tell but it seems to be less "hard" SF than then other things I read from Stephenson. We'll see.

A couple of remarks if you're inclined to experiment on your own.

• When I started I was not able to run cepl:repl, due to the OpenGL version exposed by my driver (3.0, whereas the mininum for CEPL is 3.1). But that's not the actual version supported by the hardware. To access the real capabilities, and ultimately to be able to run CEPL, you must ask explicitly, for example (cepl:repl 800 600 3.1); I initially missed that, so I spent time trying to solve the wrong problem.

• I work with xmonad. The default tiled windows positioning is not ideal with the CEPL output window, but thankfully CEPL's window is easy to identify at manageHook level by its title. So I added this in my configuration: <+> (title =? "CEPL" --> doFloat). For example:

  myManageHook = manageDocks
    <+> (title =? "CEPL" --> doFloat)
    <+> manageHook defaultConfig
  

Noticed this Reddit thread in one of Sacha Chua's Emacs News posts, and wondered what I could answer.

~/.emacs.d (master) $ git log --reverse --pretty=format:%ai | head -n 1
2014-05-23 10:29:04 +0200

I didn't realize it's been 3 years already since I started using Emacs.

Indirect buffers are buffers that share text with another buffer (the base buffer); org-mode, for example, allows the user to display a subtree in a indirect buffer, which might be a convenient way to focus on a particular section of a document.

Convenient but not practical to me, as I keep forgetting the combination used to open that indirect buffer (C-c C-x b), plus the cursor does not move where I'd want it. Here some code I borrowed from the configuration presented in the post: it is very simple, and in my opinion it makes the usage of indirect buffers a lot more pleasant:

(defun open-subtree-in-another-window ()
  (interactive)
  (org-tree-to-indirect-buffer)
  (windmove-right))

(global-set-key (kbd "C-M-l") 'open-subtree-in-another-window)

• The Last Door (I played the Android version) - This is a classic point-and-click adventure. Rather simple, but the plot -a homage to Lovecraft's and Poe's horror tales- is interesting. Special mention for the original soundtrack, a real plus in setting the mood. The graphics is intentionally low-res and pixelated, an odd choice that surprisingly played well on a game of this type: I guess it is because the player's mind has to convert the limited detail the images offer into actionable information, thus staying more focused. In practice, I ended up being immersed into the game reality, and that made the scary moments (some of them really upsetting) more effective. Recommended.
• SIM (Sara is missing) (I played the Android version) - In this game of interactive fiction Sara is missing and you find her smartphone. You're supposed to rescue her, looking for clues in her messages, emails and whatnot, with the aid of Iris, an artificial intelligent system running on her phone. The game is very simple and the player is merely instrumental in letting the story unfold. There are a few scary moments, but in retrospective they were more about how the message was delivered, rather than the message itself. To sum up, the game mechanism is interesting but I would have appreciated a more complex plot.

Seymour Papert’s Mindstorms was published by Basic Books in 1980, and outlines his vision of children using computers as instruments for learning. A second edition, with new Forewords by John Sculley and Carol Sperry, was published in 1993. The book remains as relevant now as when first published almost forty years ago.

The Media Lab is grateful to Seymour Papert’s family for allowing us to post the text here. We invite you to add your comments and reflections.

Maybe syntax highlighting is not as good as it seems.

The IRCv3 Working Group is a collection of IRC client and server software authors working to enhance, maintain and standardize the IRC protocol using backwards-compatible extensions.

New page, with some notes about the ongoing process of writing a test library for CL (just a toy project, I'm not going to spoil the ecosystem).

I've been searching for a while for a function that does this in (Common) Lisp. Does one already exist, or do I need to code it on my own? To be more specific, I'm looking for a function that if I fed it in something like '(1 2 4 1), it would return 1?

First of all, the request specifics are incomplete: what should the function return if there's more than one element that occur most frequently? What is the notion of sameness among the elements of the list?

As a beginner, I often find myself looking for idiomatic ways to do things: reusing code in a package is apparently the way to go, but I haven't found a clear path yet for such researchs: I usually look for something in Quicklisp package collection, then on github and the Clwiki. I suspect that, at least for these simple functions, CL makes it so easy to roll your own version that everybody end up writing a homemade solution.

I have used a REPL connected to a production system to change code. Yes, I have changed code in a running production system. Does that terrify you? Honestly, it kind of terrifies me a little, too! Regardless, sometimes the best way—the only way—to diagnose a particularly nasty bug is to poke a living organism and observe the result. I am more like a doctor diagnosing a patient and less like a detective trying to piece together a sequence of events from the clues left behind.

There's that and plenty of fascinating observations about the difference between a system constructed as a organism (system paradigm), and constructed as a cathedral (or a pyramid: that's the language paradigm).

I am fascinated, but I'd like to talk to someone who had this kind of experience. I understand the beauty and the utility of the REPL, yet intervening in a system in such a organic and (apparently, to me) not organized fashion seems more dangerous than it's compelling. How one can ensure the changes applied to the running deploy will be incorporated in the code base? How can you properly "undo" the changes you've made while you were tinkering with the system. Anyway, a nice and inspiring post.

• Writing some simple Common Lisp, for exercise. The Wireworld simulator and editor –which has some significance per se besides being interesting as a CL exercise– is on pause (while I try to figure out Lispbuilder-sdl's ways of treating surfaces), and I'm now on something simpler. It's a Sudoku solver assistant. It's not clear to me what the scope of the project will be, however I'm discovering handy techniques and tools useful for a "real" system: for example I borrowed from scmutils the idea of using TeX to obtain a representation of the Sudoku problem (it's faster than I initially thought).
• Reading Seveneves by Neal Stephenson. I hope to write something more substantial as I reach its end.

(defun create-new-function (function-name)
  "Creates a new function definition, given a selection. Removes
  the selection and replaces it with a call to the newly created function"
  (interactive "sFunction name: ")
  (let ((code (get-region)))
    (progn
      (save-excursion
        (progn
          (move-to-empty-point)
          (insert-new-function-definition function-name code)))
      (insert "(" function-name " )"))))

Comments welcome.

Mark Jason Dominus on syntax higlighting.

Syntax highlighters should be highlighting the semantic content like expression boundaries, implied parentheses, boolean subexpressions, interpolated variables and other non-apparent semantic features. I think there is probably a lot of interesting work to be done here. Often you hear programmers say things like “Oh, I didn't see the that the trailing comma was actually a period.” That, in my opinion, is the kind of thing the syntax highlighter should call out. How often have you heard someone say “Oh, I didn't see that while there”?

This function converts my list of bookmarks (expressend in a org document that is also used to build my Links page) in a data structure suitable for webjump.

(defun get-webjump-sites ()
  (with-current-buffer (get-file-buffer "~/Dropbox/stefanorodighiero.net/links.org")
    (delq nil
          (mapcar
           (lambda (i)
             (let ((item-string (cdr (assoc "ITEM" i)))
                   (regex "\\[\\[\\(.*\\)\\]\\[\\(.*\\)\\]\\]"))
               (if (posix-string-match regex item-string)
                   `(,(match-string 2 item-string) . ,(match-string 1 item-string)))))
           (org-map-entries 'org-entry-properties nil 'file)))))

(setq webjump-sites (get-webjump-sites))

(require 'cl)
(defun get-webjump-sites ()
  "converts a org document in a data structure suitable for webjump"
  (let ((regex "\\[\\[\\(.*\\)\\]\\[\\(.*\\)\\]\\]"))
    (with-current-buffer (get-file-buffer "~/Dropbox/stefanorodighiero.net/links.org")
      (loop for i in (org-map-entries 'org-entry-properties nil 'file)
            for item-string = (cdr (assoc "ITEM" i))
            if (string-match regex item-string)
            collect `(,(match-string 2 item-string) . ,(match-string 1 item-string))))))

Ditching the blog also means I'm now using one tool only for all the editing and publishing.

Things to do:

• testing
• implement some sort of feed for the updates
• re-linking minor stuff that has not yet a place in the new structure

(defun my/org-convert-region-quote ()
  "Converts selection in a QUOTE block"
  (interactive)
  (progn (insert "#+END_QUOTE\n")
         (exchange-point-and-mark)
         (insert "#+BEGIN_QUOTE\n")))

Knowing about point and mark is useful to understand the code. One defect of this code is that it doesn't work if you select a region starting from the end.

(reproducing it here for archive)

• it was an error to compare mobile devices to computers
  • computers have protean nature; how they behave (the function they enable) depends on software
  • one chooses what functions his computer needs to perform, and buy appropriate software accordingly
  • On the other hand
  • Mobile devices use the computer and a ground model, but their nature is to be capable of many things off-the-shelves
  • Hence users can legitimately perceive as absurd the fact that software (apps) cost money
  • It feels more natural to pay for services
• Apps are not human concept
  • I mean the fact that one has to pass from an application to another one to accomplish tasks
  • see for example "The Human Interface" by Jef Raskin
  • On the user level, computer- and human- concepts are intermixed, but there's no human reason to do so
• Google presented "Instant Apps"
  • it seems they would eliminate to boundaries between one application and the other one
  • the OS is just a framework (with unified interfaces and metaphors) where users can accomplish tasks and access to services
  • OS seamlessly manages the acquisition of other components (modules? apps bits?) needed to do so

Today, this is no longer the case. Sussman pointed out that engineers now routinely write code for complicated hardware that they don’t fully understand (and often can’t understand because of trade secrecy.) The same is true at the software level, since programming environments consist of gigantic libraries with enormous functionality. According to Sussman, his students spend most of their time reading manuals for these libraries to figure out how to stitch them together to get a job done. He said that programming today is “More like science. You grab this piece of library and you poke at it. You write programs that poke it and see what it does. And you say, ‘Can I tweak it to do the thing I want?'”. The “analysis-by-synthesis” view of SICP — where you build a larger system out of smaller, simple parts — became irrelevant. Nowadays, we do programming by poking.

It must be any language designer's ultimate dream.

(And this is probably Lisp's greatest weakness as well – with this level of possible diversity, everyone has to use the “common lowest denominator” simply because nobody can agree on what alternative syntax / library / etc. is better and should be used.)

Interesting read, that resounds with something we were talking about at last Haskell meetup.

Lisp is so powerful that problems which are technical issues in other programming languages are social issues in Lisp.

Consider the case of Scheme, again. Since making Scheme object-oriented is so easy, many Scheme hackers have done so. More to the point, many individual Scheme hackers have done so. In the 1990s, this led to a veritable warehouse inventory list of object-oriented packages for the language. The Paradox of Choice, alone, guaranteed that none of them would become standard. Now that some Scheme implementations have their own object orientation facilities, it's not so bad. Nevertheless, the fact that many of these packages were the work of lone individuals led to problems which Olin Shivers wrote about in documenting the Scheme Shell, scsh.

Especially interesting is what Minsky observes about teaching programming languages:

I remember a few years ago bringing up the topic of teaching programming, and how I was hoping the Wolfram Language would be relevant to it. Marvin immediately launched into talking about how programming languages are the only ones that people are expected to learn to write before they can read. He said he’d been trying to convince Seymour Papert that the best way to teach programming was to start by showing people good code. He gave the example of teaching music by giving people Eine kleine Nachtmusik, and asking them to transpose it to a different rhythm and see what bugs occur. (Marvin was a long-time enthusiast of classical music.) In just this vein, one way the Wolfram Programming Lab that we launched just last week lets people learn programming is by starting with good code, and then having them modify it.

Interesting post about programming language writing tools.

[…] the languages were developed in complete ignorance of these tools, which made them somewhat hostile to those goals (anybody who tried to implement a correct C++ parser knows what I mean, life before clang was just painful). As a result, very complex tools making heavy use of specialized partial parsers, static analysis, and crazy heuristics emerged. And they emerged as part of even more complex development suites to combine them all in a coherent form: the IDE was born.

[…]

But more recently, things took a different turn (for the best I think): a new language emerged that was promoting a different paradigm: Go. Instead of making the tooling an afterthought, it’s been pretty much there at some level since inception. It even shows in the language grammar itself, which is designed to enable fast compilation, partial parsing, and a whole bunch of analysis tools.

It resonates with an old paper I'm reading: Programming in an interactive environment the “LISP” experience by Eric Sandewall.

(I found this reference in an excellent post by Michael Fogus)

The only way to beat this would be giving me more time to read it. (It's a wonderful boxed-set edition of the famous Feynman Lectures on Physics)

Nice post on Stephen Wolfram's blog ("In other words, she basically proposed to take on the role of CEO, with Babbage becoming CTO").

So far, I just built some familiarity with the codebase and I managed to obtain a static (I mean, non-configurable) dashboard with a single widget showing my monthly expenses. Like that (code is on github):

But the real problem is designing a sensible dashboard configuration language.

A list of interesting elfeed tricks

One thing to keep in mind is that Git has several distinct layers:

• The data model
• The plumbing
• The porcelain

The data model is incredibly simple. This, I think, is Git's main attraction. I've written about the data model in my article "Git from the Bottom Up", and also via a Haskell library for interacting with this model, called gitlib (http://hackage.haskell.org/package/gitlib).

The plumbing is… unintuitive to say the least. The porcelain is… fairly bad, but slowly getting better.

This is similar to what I want: ThreeWindows

(defvar *larsen/split-layout-type* t)

(defun toggle-split-layout ()
  (interactive)
  (progn (change-split-type-2 *larsen/split-layout-type*)
         (if *larsen/split-layout-type*
             (setq *larsen/split-layout-type* nil)
           (setq *larsen/split-layout-type* t))))

(global-set-key (kbd "M-<f1>") 'toggle-split-layout)

The one thing that Lisp programmers can agree on is how much better Lisp is than C and similar languages. I was talking last week to some programmers who use the Clojure version of Lisp and it made me wonder “If Lisp is so great, why did this guy have to build a slightly different version instead of building a popular application program in an existing version of Lisp, such as Common Lisp?”

Interesting discussion in the comments

In a virtual machine, to avoid compromising my existing main setup

• UPDATE <2015-09-24 Thu 09:38> Danilo Poccia wrote a post to recap the event: YOOXlabs Technology Event

A biography of John Horton Conway. Arrived on Monday.

Charlie Stross on his blog:

Assume you are a historian in the 30th century, compiling a pop history text about the period 1700-2300AD. What are the five most influential factors in that period of history?

The comments are interesting.

I can't even start telling how much is significant to me.

I'm told that Bruce Sterling now lives in Italy, in Turin. This is a collection of stories set around Italy. Just skimmed the very first pages so far, I noticed an overflow of the word "occult".

• Typing Analytics in Emacs
• Emacs extension to measure typing speed in the background? [Reddit]

• http://jaspervdj.be/hakyll/reference/Hakyll-Core-Configuration.html
• An example: Switching from Jekyll Bootstrap to Hakyll

Next question is: how could I add more commands?

I thing this will be handy in the future

use strict;
use warnings;

use DateTime;
use DateTime::Duration;

my $dt1 = DateTime->new( year => 2015, month => 8, day => 1 );
my $dt2 = DateTime->new( year => 2015, month => 8, day => 31 );

my $duration = $dt1->delta_days( $dt2 );
print $duration->days();

It prints 2, because the days() method is implemented as

abs( ($duration->in_units( 'days', 'weeks' ) )[0] )

meaning that the duration is first converted to weeks, then the remainder is returned.

Here an extended piece of code to show what happens:

use strict;
use warnings;

use DateTime;
use DateTime::Duration;

my $dt1 = DateTime->new( year => 2015, month => 8, day => 1 );

foreach my $d ( 2 .. 31 ) {
  my $dt2 = DateTime->new( year => 2015, month => 8, day => $d );
  my $duration = $dt1->delta_days( $dt2 );
  printf "%s days and %s weeks\n", $duration->in_units( 'days', 'weeks' );
}

which prints:

2 days and 0 weeks
3 days and 0 weeks
4 days and 0 weeks
5 days and 0 weeks
6 days and 0 weeks
0 days and 1 weeks
1 days and 1 weeks
2 days and 1 weeks
… and so forth

If you want to know how many days there are between two given dates, better be explicit and use $duration->in_units('days').

The doc explains it clearly if you take the time to read it:

These methods return numbers indicating how many of the given unit the object represents, after having done a conversion to any larger units.

But it's baffling to me nonetheless.

You have a grid of squares. Some are filled in black; some of the black squares are numbered. Your aim is to ‘light up’ all the empty squares by placing light bulbs in some of them.

Each light bulb illuminates the square it is on, plus all squares in line with it horizontally or vertically unless a black square is blocking the way.

To win the game, you must satisfy the following conditions:

• All non-black squares are lit.
• No light is lit by another light.
• All numbered black squares have exactly that number of lights adjacent to them (in the four squares above, below, and to the side).

Non-numbered black squares may have any number of lights adjacent to them.

First thing, board representation and some diagrams code to obtain a graphical rendition.

import Diagrams.Prelude
import Diagrams.Backend.SVG.CmdLine

data Square = Empty
            | Box
            | Light
            | Lamp
            | Num Integer

type Board = [[Square]]

board :: Board
board = [[Empty, Box,   Light, Empty, Box,   Empty, Empty],
         [Empty, Empty, Light, Empty, Box,   Empty, Num 0],
         [Box,   Num 2, Lamp,  Light, Light, Light, Light],
         [Empty, Empty, Light, Empty, Empty, Empty, Empty],
         [Empty, Empty, Light, Empty, Empty, Num 1, Num 1],
         [Num 2, Empty, Box,   Empty, Empty, Empty, Empty],
         [Empty, Empty, Num 1, Empty, Empty, Num 0, Empty]]

squareSize = 30

drawSquare Empty = square squareSize
drawSquare Box = square squareSize # fc black
drawSquare Light = square squareSize # fc yellow
drawSquare Lamp = circle (squareSize * 0.3) # fc white
               <> square squareSize # fc yellow
drawSquare (Num n) = text (show n) # fc white # fontSize (Local 16)
                  <> square squareSize # fc black
drawBoard :: Board -> Diagram B R2

drawBoard b = vcat . map (alignR . hcat) . (map . map) drawSquare $ board

sketch = drawBoard board

main = mainWith sketch

Saving games still scare me.This is something I should have figured out months ago. The issue isn't a matter of how to store the data, it's way more complex than that. There is a lot of data to iterate through and save off in a way that can be reconstructed. Doing save games is harder today than it was back in the SCUMM years. Back then we didn't have to worry about patching. These days, the save game has to survive the game being patched and that can mean resources being added or removed.

ghci -isrc -fno-ghci-sandbox src/Main

Ryan is John Carmack's son.

I’m still taking a little heat from my wife for using an obscure language instead of something mainstream that is broadly used in industry, but I have nothing but good things to say about using Racket and DrRacket for a beginning programmer, and highly recommend it.

Just arrived. It's printed in colours!

I didn't have the courage to ask the courier about two more books I'm waiting for: he seemed very pissed off for the problems he had finding my address.

They implemented different ethical settings in the software that controls automated vehicles and then tested the code in simulations and even in real vehicles. Such settings might, for example, tell a car to prioritize avoiding humans over avoiding parked vehicles, or not to swerve for squirrels.

As the technology advances, however, and cars become capable of interpreting more complex scenes, automated driving systems may need to make split-second decisions that raise real ethical questions.

At a recent industry event, Gerdes gave an example of one such scenario: a child suddenly dashing into the road, forcing the self-driving car to choose between hitting the child or swerving into an oncoming van.

“As we see this with human eyes, one of these obstacles has a lot more value than the other,” Gerdes said. “What is the car’s responsibility?”

;; Is there a better (more idiomatic) way to aggregate values?
(defun aggregate (aggregate-function lst)
  (let ((hash (make-hash-table :test 'equal)))
    (loop for key in (mapcar 'car lst)
          for value in (mapcar 'cdr lst)
          do (if (null (gethash key hash))
                 (puthash key value hash)
               (puthash key (funcall aggregate-function value (gethash key hash)) hash))
          finally return hash)))

(defun pages-per-month-raw ()
  (with-current-buffer (get-file-buffer "~/org/books.org")
    (mapcar (lambda (b)
              (let* ((month (format-time-string "%b" (date-to-time (cdr (assoc "TIMESTAMP" b)))))
                     (pages (string-to-int (cdr (assoc "PAGES" b)))))
                (cons month pages)))
            (books/in-year "2015"))))

(defun pages-per-month ()
  (let ((ppmr (pages-per-month-raw)))
    (aggregate '+ ppmr)))

(defun month-list ()
  '("Jan" "Feb" "Mar" "Apr" "May" "Jun"
    "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"))

(defun complete-hash (hash)
  (let ((new-hash (make-hash-table)))
    (loop for month-name in (month-list)
          do (if (null (gethash month-name hash))
                 (puthash month-name 0 new-hash)
               (puthash month-name (gethash month-name hash) new-hash))
          finally return new-hash)))

;; Poor man's TSV export
;; TODO check the implicit assertion on the ordering
(maphash (lambda (k v) (insert (format "%s\t%s\n" k v)))
         (complete-hash (pages-per-month)))

Then, for example:

stats <- read.csv("/tmp/stats.tsv", sep = "\t", header = F)
names(stats) <- c("month", "pages")
stats$month <- factor(stats$month, month.name )
p <- ggplot( stats, aes(month, pages)) +
    geom_histogram() +
    theme(axis.text.x = element_text(angle=45, hjust=1))
p

Original tweet

First its characteristics:

It is a IBM Thinkpad X32. A good news is it sports one of the best keyboards one can find on a laptop (and I was lucky enough to find the GB layout). I found it at an electronic fair I recently visited, and grabbed it without much thinking from the pile (literally) where it layed together with some of its twins.

I think it's remarkable that such an old piece of hardware can be a perfectly usable machine (at least for the way I'm used to work). All it takes is some attention to the software one chooses to install:

• Linux, obvious choice to revive old hardware (in this case, I had to recur to a non-PAE kernel due to the particular CPU architecture)
• i3, a lightweight tiling window manager
• Emacs 24.3, where I'm going to spend much of my time (w3m is a decent surrogate of a proper graphical browser for reading documentation)
• I'm even running Hakyll locally to prepare this post

Anyone who works with computers learns to fear their capacity to forget. Like so many things with computers, memory is strictly binary. There is either perfect recall or total oblivion, with nothing in between. It doesn't matter how important or trivial the information is. The computer can forget anything in an instant. If it remembers, it remembers for keeps.

[…]

Our lives have become split between two worlds with two very different norms around memory.

[…]

The online world is very different. Online, everything is recorded by default, and you may not know where or by whom. If you've ever wondered why Facebook is such a joyless place, even though we've theoretically surrounded ourselves with friends and loved ones, it's because of this need to constantly be wearing our public face. Facebook is about as much fun as a zoning board hearing.

Essays/Computer science/$work stuff

I guess it could actually have some uses, who knows?, but I wrote it mostly because I wanted to see how fast repos are growing, and R is the obvious tool to tinker with the results.

I'm less than a beginner with R, and I have to admit plotting data from a multi-column CSV file is less straitghforward than I expected: I had to use xyplot from the lattice package, like this:

xyplot(
  Perl + Bourne.Shell ~ 1:nrow(sloc),
  data = sloc,
  type = 'a',
  auto.key = list( space = "top", lines = TRUE, points = FALSE)
)

Here the result, with data provided analysing the Dancer github repository (branch devel).

First of all, to the zealots that may happen to read this article and feel compelled to whine on "scent of paper" and other oddities: I'm not planning the disposal of all my "real" books, neither I'm considering buying only digital contents from now on.

I decided to buy an ebook reader because I wanted to see on my own what can be done with this technology, which I consider immature and yet to be completely exploited.  I think I am an early adopter, even if Amazon Kindle and its competitors hit the market several years ago.

Also, I think having an ebook reader is nowadays the most practical solution to the eternal problem "What books should I bring with me during the journey?". Being able to answer "All!" is a wild dream that comes true (but I understand this can be a problem as well).

Anyway, here a few impressions from a very very beginner.

• The device itself looks beautiful. It's not heavy and it seems prolongated use will not be tiring. On the other hand, I have the impression it's not particularly sturdy. Again, this is something I can say only in a few months (or in a few hundreds kilometers).
• I think the slogan "it's like paper" is inaccurate.  Whatever appears on the screen seems printed, but it does not recall paper to me.  Besides that, fonts are very  crisp and readable, so Kindle hits on the spot for what is supposed to be its  main use.
• I am positively surprised by the refresh delay. Maybe because  I expected it to be even worse, I think it's bearable, at least for the kind  of books you read cover to cover in a sequential fashion. In other words, good for novels, articles and stuff like that; maybe not practical for manuals, documentation… in general, things you want to study, or browse randomly.
• I suspect I will eventually feel hampered by the position of buttons on the device. Anyway, this can't be but a speculation.
• I'm currently at my parents' place, and there are problems with the Internet connection, so I couldn't try its wifi capabilities yet. A pity: one of the things I was more eager to try was Kindle's use in conjunction with Instapaper.
• Ah, the screensavers are wonderful!