stream

Links #57 link

rando-planner

The tool I am building to plan multi-day bike events is coming together. Now one can obtain a map with markers that are automatically placed based on the data in the plan data structure.

Defining a plan Using a plan to put markers on a map

Links #56 link

Processing documents with transducers Using transducers to extract information from XML, JSON and other documents (in Clojure)
What To Eat Bikepacking And Ultra Cycling

Links #55 link

Using Clerk to plan bikepacking events meta dev

I have been experimenting with Clerk to build a tool I can use to study different strategies for Venetogravel 2024. Inputing parameters such as the distance I have to cover, the average speed I think I can maintain during the event, and how I intend to distribute the effort over several days, I can obtain a diagram. It's a work in progress, here what I got so far:

(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)

Bikepacking updates meta

I only managed two overnighters during this season, but I learned something on how to pack, reaching a nice setup for my kit.

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.

TIL dev

$ cat .inputrc
set completion-ignore-case on

Links #54 link

Some experiments with Pharo dev

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

Links #53 link

Shattered Landscapes (using R with Rayshader to create beautiful, abstract visualizations)
Triplanar mapping
Normal Mapping for a Triplanar Shader
Running Open Genera 2.0 on Linux

Links #52 link

Rayshader is an open source package for producing 2D and 3D data visualizations in R.
EventCatalog is an Open Source project that helps you document your events, services and domains.
How about some actual innovation (part of European Innovation & Technical Capabilities)

Links #51 link

Annotations on Graham's ANSI Common Lisp
Little Languages Are The Future Of Programming
Huntington Digital Library
Collapse OS

is a Forth operating system and a collection of tools and documentation with a single purpose: preserve the ability to program microcontrollers through civilizational collapse.

Links #50 link

Links #49 link

Links #48 link

Provenance Semirings

We show that relational algebra calculations for incomplete databases, probabilistic databases, bag semantics and whyprovenance are particular cases of the same general algorithms involving semirings.
How I draw figures for my mathematical lecture notes using Inkscape
3D Math Primer for Graphics and Game development

Links #47 link

Links #46 link

Links #45 link

Links #44 link

My Fanless OpenBSD Desktop (I like this desktop case a lot)
Data Structure Visualizations
Modeling subscription revenue
JAR on Object-Oriented
Bicycle Germany Start Page

Links #43 link

Links #42 link

Links #41 link

Org-roam

I started experimenting with org-roam (v2, with org-roam-ui to have an idea of the progress). Still not entirely clear to me, but I will continue.

Links #40 link

Links #39 link

Counterexamples in Type Systems «a compendium of horrible programs that crash, segfault or otherwise explode.» (but please read on)
Creating a random 2d game world map
Emacs link scraping (2021 edition)
Comparison of Common Lisp Testing Frameworks (31 May 2021 Edition)

Links #38 link

Mühlensee meta

Links #37 link

Links #36 link

A guide on disabling/enabling lsp-mode features
Gerald Jay Sussman & Chris Hanson - Adventures In Advanced Symbolic Programming [videos] Google Tech Talk of Sussman & Hanson's Adventures in Advanced Symbolic Programming (6.945). This material should correspond to what is written in the book “Software Design for Flexibility (how to avoid programming yourself into a corner)”
Desmos Graphic Calculator
The "Complete" Beethoven

This website celebrates the 250th anniversary of the birth of Ludwig van Beethoven with a chronological exploration of his life and music.

The contents of this site were created during the year 2020 with daily posts on the Twitter feed @beethoven250. Each day focused on one or more compositions accompanied by YouTube videos of mostly live performances.

Links #35 link

Links #34 link

Scicloj meeting #19: Alan Dipert: Common Lisp for the Curious Clojurian
Patterns - Abstract-Factory

In this series of blog posts I'd like to go through some of the well known design patterns and make a comparison between the implementation in Scala and Common Lisp. Scala is a statically typed, multi-paradigm language running on the Java Virtual Machine. Common Lisp is a dynamically typed, multi-paradigm language running natively on many platforms.
xeus-sql: a Jupyter kernel for general SQL implementations
The History(s) of Video Games: "a list of games chronologically sorted in the year they take place in." (via ariis)
Python Design Patterns
Uncovering a 24-year-old bug in the Linux Kernel

Links #33 link

Links #32 link

Biking, December update meta

Links #31 link

8086 microcode disassembled
Mara Schema - Mapping of DWH database tables to business entities, attributes & metrics in Python, with automatic creation of flattened tables
OpenLineage - OpenLineage is an Open standard for metadata and lineage collection designed to instrument jobs as they are running. It defines a generic model of run, job, and dataset entities identified using consistent naming strategies. The core lineage model is extensible by defining specific facets to enrich those entities.

Biking, November update meta

Biking, October update meta

A snippet for LibraryThing books

A very short one, to extract book titles from the widget "Your list" on the right, in a format suitable to paste in a Org document. Unfortunately I could not find an API endpoint to do the same thing in a more structured way.

$$('ol#list_yourlist li a').forEach( book => console.log('[[' + book.href + '][' + book.textContent + ']]'))

Links #30 link

Project Cambria - Translate your data with lenses
We have met the Excelnemy and he is us
Test-driven Web application development with Common Lisp
Jo Walton reads Monthly reading list by author Jo Walton. I like she writes succinct yet enough-to-decide reviews, and the fact she uses the notion of "bath book" (although I'm not sure she and I mean the same thing with it)

Links #29 link

The Algorithm Register is an overview of the artificial intelligence systems and algorithms used by the City of Amsterdam. Through the register, you can get acquainted with the quick overviews of the city's algorithmic systems or examine their more detailed information based on your own interests

Biking, September update meta

Links #28 link

EuroVelo, the European Cycle Route Network
Eureka Archive (Eureka is the journal of the Archimedeans, the Cambridge University Mathematical Society)
Binder an Emacs minor mode influenced by Scrivener
Studio Ghibli pictures collection "Feel free to use it within the bounds of common sense." (or, at least, this is what Google translate thinks it's written on that page)

The Muse link

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.

Links #27 link

Compiling a Lisp: Overture
Lisp vs. Python: Syntax
A place for us less messy data hoarders. (subreddit)
Johnny Decimal A [filing] system to organise projects
Energy Efficiency across Programming Languages (pdf)

Blankenfelde

Alfred Wainwright link

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.

Biking, August update

Links #26 link

Andyʼs working notes Andy Matuschak's notes are public. He developed a cool system to navigate them.
Niklas Luhmann-Archiv

Luhmann was famous for his extensive use of the "slip box" or Zettelkasten note-taking method. He built up a zettelkasten of some 90,000 index cards for his research, and credited it with making his extraordinarily prolific writing possible. It was digitized and made available online in 2019
Mines, from Simon Tatham's Portable Puzzle Collection

The first square you open is guaranteed to be safe, and (by default) you are guaranteed to be able to solve the whole grid by deduction rather than guesswork. (Deductions may require you to think about the total number of mines.)
A simple way to manage your household budget with Common Lisp and TravisCI

A cool hack

Biking, July update meta

Links #25 link

A web GUI for TikZ-cd
Protesilaos Stavrou's Emacs configuration — I got several learnings from it, Protesilaos++ for spending time to do in a literate programming style.
Lunar Programming Language by David A. Moon

Lunar is my attempt to distill 40 years of programming language experience into the "best" language I can come up with. I hope that this will bring some forgotten ideas back into the spotlight of public attention.
The Many Faces of an Undying Programming Language

Biking, June update meta

Done almost nothing (bad weather, bad mood)

Links #24 link

Standard Common Lisp Symbols
The Rise and Fall of Commercial Smalltalk
Surgical Reading: How to Read 12 Books at Once (the title is a bit over the top and I don't like it, but I appreciate the practical techniques illustrated in the article: like, deriving a sense of the structure and content of a non-fiction book using the index, then comparing it with the TOC)

Links #23 link

Biking, May update meta

Links #22 link

First (metric) century meta

A bit above 100km in a single ride.

Links #21 link

How (some) good corporate engineering blogs are written
Common Lisp and Docker
Diagrams, a Python package to generate diagrams (based on graphviz)
Bicycle Bike Noises, Clicks, Ticks, Creaks, Clunks, Knocks Repair by Jim Langley

Links #20 link

Biking, April update meta

Biking, March update meta

Started well. Abrupt stop: riding in the midst of COVID19 related restrictions didn't feel right.

Links #19 link

The PARA Method: A Universal System for Organizing Digital Information
Access a IPython repl from pdb
CLUI: Building a Graphical Command Line
Bikepacking Gear List

One of the main motivations on writing such a list is that if you search online for bikepacking gear tips most of the times you find accurate descriptions of the gear used by ultra endurance bikepacking riders in epic self supported races like the Transcontinental race or the Silk Road race. These gear tips may be useful in general, but you need to keep in mind that the main goal of those riders is to win the race: their gears are very minimalist, ultra lightweight, and comfort is not the main priority. The main goal is to cover the most amount of km in the least amount of time, resulting in often sleep deprived nights of riding. If you’re travelling for fun, you’ll cover the same amount of km in much more time (often 3/4 times what those guys take), and probably comfort is one of the top priority. This results in different needs and different trade-offs regarding the gear you’re willing to carry.
Power up Anki with Emacs, Org mode, anki-editor and more

Links #18 link

Biking, February update meta

Not very exciting (bad weather and broken glasses)

Links #17 link

Links #16 link

Biking, January update meta

Here some stats about January.

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

Links #15 link

Links #14 link

Books I finished in 2019 meta

Novels

A Legacy of Spies
Tattoo
Impossible Times trilogy
L'amante senza fissa dimora (Italian Edition)
In the Garden of Iden
Fall; or, Dodge in Hell
Plot It Yourself

Other books

Veloviewer stats meta

One of the fun parts of riding a bike is generating stats. Using Veloviewer (via Strava), for example, one can compute the max cluster size of his activities. Mine is 3x3, at the moment.

Plans for 2020 meta

I don't particularly like the plans-for-next-year literary genre, but I imagine it will be fun to read this at this very same time next year: a memento of what my focus was. Anyway, here what I'd like to start, stop and continue doing next year.

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.

Links #13 link

Incredible Real-Time Touch Controller for the Yamaha DX7 Synthesizer
Python Notebooks for Fundamentals of Music Processing
Recoll finds documents based on their contents as well as their file names

Links #12 link

Reconfigure "Open Folder"

Just a note to myself, because I keep forgetting:

$ 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

Links #11 link

A view on the river Havel

Changing style of Emacs' tooltips meta emacs

It seems obvious now that I figured it out.

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:

A patch for Org Babel dev meta

Org-babel allows SQL snippets to be run on a database connection that can be specified in the source block header using parameters such as :dbhost, :dbuser, :dbpassword and so forth.

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.

Links #10 link

Links #9 link

Links #8 link

Links #7 link

Birches link

by Joaquim Vancells

Links #6 link

Data Visualization - A practical introduction, via bactra.org: "This book is the best guide I've seen to (1) learning the widely-used, and generally handsome, ggplot library in R, (2) learning the "grammar of graphics" principles on which it is based, and (3) learning the underlying psychological principles which make some graphics better or worse visualizations than others"
You’re probably using the wrong dictionary
OOP Before OOP with Simula
Lessons learned scaling PostgreSQL database to 1.2bn records/month

Links #5 link

Kílta: "This is a personal language. By this I mean it is a step or two away from a heartlang. It is designed to express my own interests best, and few other considerations, apart from my own sense of linguisticesthetics, are in play here"
Life Off the Grid, Part 1: Making Ultima Underworld
About watercolor toxicity

Bürgerpark Pankow meta

is conveniently close to home (the picture was not taken in the park but just outside it, on my way back)

Links #4 link

The MAESTRO Dataset and Wave2Midi2Wave
ISO 3013 is a standard published by the International Organization for Standardization (commonly referred to as ISO), specifying a standardized method for brewing tea
Introducing Darkstar: A Xerox Star Emulator
Grid Edges: "Games with grids usually use the tiles but there are also cool things to do with edges and vertices. For construction games the edges can be useful for blocking connections between tiles (walls, chasms, windows) and allowing connections between tiles (doors, pipes, wires)."

Books batch books

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.

Links #3 link

xcape: "Linux utility to configure modifier keys to act as other keys when pressed and released on their own."
Introducing the baroque theorbo: a very interesting and well delivered introduction to theorbo (or chitarrone) by lutenist Elizabeth Kenny
AI Winter is coming
Laws of Tech: Commoditize Your Complement

Links #2 link

Technology, ranked Ranked by importance, although it's not clear how they're defining "important" (electronic computer is #48, scissors are #44)
Chess Steganography
Looking back at Postgres
English verb regularization in books and tweets
Adding Glue To a Desktop Environment "In this article we will put some light on a lot of tools used in the world of Unix desktop environment customization, particularly regarding wmctrl, wmutils, xev, xtruss, xwininfo"

Links #1 link

(I often encounter links that I think are interesting. I often forget them. So I'm going to try to collect and publish them regularly here).

Forge: "Work with Git forges from the comfort of Magit"
The best things and stuff of 2018: Annual restrospective post from Michael Fogus
Writing a natural language date and time parser: parsing natural language date strings such as "7 hours before tomorrow at noon", in Lisp
Emacs in 2018: My Year in Review
It's Magit! - John Wiegley
Best of 2017 in tech talks

Fun with Fonts link

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.

Latest batch books

Latest loot from the used-book store.

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

Capital Sharp S in German orthography link

Mark Dominus points to an article from typography.guru: The Capital Sharp S in now part of the official German orthography.

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.

The Utter Failure of Fictional Time Travel link

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.

USDA Pomological Watercolor Collection link

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.

Fruit meta

Today I said: "Cherries are the best fruit with the worst user interface". I love how they taste, but I'm always afraid to choke or break a teeth on the core, I find it annoying to dispose of the petioles, and so on. A colleague replied: "There's a XKCD for that! And he disagrees!". Indeed there is one!

PyData Berlin 2018 dev meta

First Python conference I attend.

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.

First experiences with Python meta

At the new job I use Python for my programming tasks. Currently developing some data related stuff (ETL and reporting) and a web service, trying to organize the stuff I write so that it can be used by other members of the team for other projects. I will register a few impressions:

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.

Update

Speaking of great tools in the Python ecosystem, I just discovered Jupyter received the ACM Software System Award. Congratulations!

eyebrowse meta

I started using eyebrowse more systematically. I tend to have multiple frames scattered around my xmonad workspaces, but I usually also have a workspace exclusively devoted to a fullscreen Emacs frame, and there I usually work on different projects, that require different windows configurations. So eyebrowse is useful. To be able to switch more confortably from a configuration to another, I added this little piece of code to my setup:

(loop for i from 1 upto 9
      do (define-key eyebrowse-mode-map
           (kbd (format "M-%d" i))
           `(lambda ()
              (interactive)
              (eyebrowse-switch-to-window-config ,i))))

The Oldest Board Game link

New job!

I joined the team of Idagio, a streaming service for classical music.

Which mathematicians were known for their ability to teach? link

Atreus firmware + Ragel logic link

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.

"Why I (don't) hate LaTeX" emacs

(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.

Code to read meta

I opened a new repository on github. It's called code-to-read, an attempt to collect and organize links to code bases particularly good for a human to read.

Pocket Perl ebook meta

The publisher released an ebook version of my book.

Haskell Day in Rome meta

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!).

"Lisp is the greatest single programming language ever designed"

Another insightful post by Alan Kay on Quora:

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.

"The right thing should be easier to do"

I register here a series of tweets I already posted, for further ruminations.

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.

August 2017

I spent the entire month in Berlin, half telecommuting, half being my summer vacations. So, I had some free time I spent in many ways, in particular:

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

The Swapper

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

Orankesee (Berlin short bike stroll)

It's remarkable how easy and quick it is to reach green areas and parks in Berlin. This is a mere 20 minutes from where I'm staying. I took many pictures (they're going to be reference material for future watercolor paintings).

Melvin Decimal System stats on LibraryThing books

I just noticed LibraryThing released a new feature.

The Rise and Fall of D.O.D.O. books

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.

CEPL dev

This weekend I have been exploring CEPL: "a lispy and REPL-friendly Common Lisp library for working with OpenGL", as its author writes. I have no prior experience with OpenGL, but thanks to Baggers' video series "Pushing pixels with Lisp", and predating the examples I found, I managed to write some working code. I have a project idea in mind, let's see how it ends up.

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
```

When did you start using Emacs? meta emacs

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.

Record Keeping link

Indirect buffers emacs

Inspired by a post found on the excellent Emacs news curated by Sasha Chua (Replacing Scrivener with Emacs and Vim), I decided to give indirect buffers another try.

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)

Wacom tablet meta

Quite surprisingly, the rotation property is a property of the stylus and the eraser, not of the pad.

$ xsetwacom --set "Wacom Bamboo 16FG 4x5 Pen stylus" Rotate half
$ xsetwacom --set "Wacom Bamboo 16FG 4x5 Pen eraser" Rotate half

Haskell Day dev

Haskell Day in Milan, hosted by Mikamai/LinkMe offices.

Games meta

I've been playing more than the usual, recently:

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.

Mindstorms books

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.

xmonad + Libreoffice problems meta

Apparently I fixed the pesky problems I had with xmonad + Libreoffice.

hledger-dupes is now in hledger dev

Simon Michael asked me to include hledger-dupes in the main hledger repo.

Scheme interpreter going on dev

I spent part of the weekend on my Scheme interpreter implementation, after a long hiatus. Cleaned up some code, and started enstablishing the grounds for adding closures (thus passing from the substitution model to the environment model of evaluation, a profound change).

Why Catholics Built Secret Astronomical Features Into Churches to Help Save Souls link

Quick, How Might the Alien Spacecraft Work? link

:syntax off

Maybe syntax highlighting is not as good as it seems.

The Case Against TODO link

IRCv3 link

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.

A history of storage media link

Kiran Bhattaram published a very interesting piece about how storage evolved in computing.

Emacs Lisp's Future link

A thread from two years ago reemerged

Writing a test library for Common Lisp dev

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).

"Finding most frequent element in a list" link

A question on Stackoverflow and a brief search led me to some thoughts I want to register to document my learning experience.

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.

A-LANG: ways to implement computer languages on 6502s link

Mac OS X -> Linux meta

In other news, I completely switched from Mac OS X to Linux.

The System Paradigm dev

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.

The Classics of Science Fiction link

Status update meta

Some days off, not very much done. Somehow relevant in the context of this stream:

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.

ELisp refactoring tools dev

Started working on tools to help me refactor Elisp code. Here the first main function:

(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.

Surprising reasons to use a syntax-coloring editor link

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”?

Bit Twiddling Hacks link

Automatic webjump list from org emacs

Webjump is a bookmark facility for Emacs. Fed with a list of bookmarks (as an association list) it presents a menu, then open a browser page with the selected link. Simple and handy.

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))

Update

I asked for a review on #emacs, bpalmer kindly pointed out a few things that should be done in a different manner:

I'm building a list containing nils, which I need to delete later (delq). I shouldn't be creating them in the first place
Probably no need for posix-string-match instead of string-match
I should provide a docstring

So, here a better version, using the loop macro

(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))))))

It's more concise and direct, definitely better, but I'm still not satisfied: it lacks clarity and cleanliness.

New site structure meta

I just published a restructuring of my website. Content is more or less the same. Main difference is I ditched the blog: I discovered blogging (I mean, organizing the stuff I publish as distinct articles ordered in time) is not for me. I'm more comfortable dedicating a page to each project I'm following, and keep updating the page as the project proceeds.

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

Manipulate regions emacs

A useful code snippet to manipulate regions.

(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.

Darius Bacon link

Oh good lord I found again a web page I was used to peruse like 20 years ago. Many journeys started from there. It's the personal homepage of Darius Bacon.

The Early History of Smalltalk link

Alan Kay's reading list link

So you want to be a compiler wizard link

On Google's last week announcements

One of the things presented during the Google I/O I consider particularly important. Some annotations (which might or might not lead to a a more structured piece):

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

Nowadays, we do programming by poking link

http://www.posteriorscience.net/?p=206 https://vimeo.com/151465912#t=59m36s

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.

Dyson's Dodecahedron link

A nice collection of hand-drawn RPG maps

Isabella the Catholic brings change to Chess link

Org as a Word Processor link

"Learning Racket" series

An expert programmer learns Racket and takes notes in the process. Many interesting remarks, for example (after discovering a library that let the user bend the language):

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.)

Switched to Ubuntu Xenial Xerus meta

Better hardware support with less work for me (the Broadcom Wifi chip has been recognized with no problems).

eshell and why can't I convert to you link

Some interesting Emacs shell tricks in this Reddit thread.

The Lisp Curse link

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.

What are some of the must-read, harder Sci Fi books you all recommend? link

R setup dev

I need to setup a R environment on the Linux machine. RStudio (which I'm currently using on my Mac) eases packages installation and at the same time provides a rich and pleasant to use environment, but I'm considering going for a different setup on my Linux machine. For example, one way could be using Debian packaged R plus Emacs ESS.

Farewell, Marvin Minsky (1927–2016) link

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.

A surface code quantum computer in silicon link

How modern languages will save the text editor link

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.

Black Hole, by Bucky Sinister books

The best things and stuff of 2015 link

The annual post by Fogus. Great stuff.

Yay! New laptop meta

Now some work to make it work like I want (it comes with Windows 10 installed but I want a GNU/Linux system on it. So far I've only tried a live distro to check hardware support. As I expected, it's going to need some work to make the wifi chipset work properly).

Update

Linux installed. First update from the new environment!

Creating Adventure Games On Your Computer

by Tim Hartnell, published 1983

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

Early Christmas present books

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)

Untangling the Tale of Ada Lovelace

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

How to get good at chess, fast

Adding dashboards to hledger dev

I spent a couple of days trying to hack some changes into hledger-web. I use it from time to time, especially to visualize the item tree generated from my journal, but I would need more to incorporate it in my workflow. What I would like is a system to describe arbitrary widgets to compose in a dashboard. Things like "monthly expenses, comparing this and last year, using a histogram". Or "breakdown of the top N expense categories, using a pie chart".

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.

Chris Wellons: 9 Elfeed Features You Might Not Know emacs

A list of interesting elfeed tricks

Update

I spent some time fiddling with my elfeed configuration. I like the interface and the way one could program and extend it. Here some more resources I found useful:

Update

Some times elfeed gets stuck while downloading the feeds. Reading a relevant issue on github, I discovered the function elfeed-unjam that fixes the problem.

Programming Interactive Worlds with Linear Logic link

Logo-ish drawing environment dev

Some months ago I bought a copy of "Turtle Geometry". I am looking for a LOGO environment to follow along and do the exsercises, but I could not find anything good enough for Mac OS X (which is quite surprising, if you ask me). So I decided to write my own version. The first usable thing I produced is not quite LOGO, but enough to do fancy drawings and (I'm guessing) translate most of the exercises without efforts. Code is on github.

Update

One thing I'm not sure how I could do is the interactive environment, but I discovered I have something acceptable at no cost, thanks to how Lisp and the lispbuilder-sdl package work.

Here a piece of code from my project:

;; [...]
    (with-events ()
      (:quit-event () t)
      (:key-down-event (:key key)
                       (when (sdl:key= key :sdl-key-escape))
                       (sdl:push-quit-event))
      (:idle (reset-turtle)
             (fancy 20)
             (draw-turtle *position-x* *position-y* *direction*)
             (update-display)))))

Since we're implicitly using the :poll event mechanism, the :idle event is triggered at each "game loop" iteration. Thus, if I redefine the functions used in the body associated to the :idle event while the program is running, I obtain a different drawing. What I do, at the end, is:

evaluate (main) (the SDL window appear)
focus in the Emacs window
edit some relevant functions (for example the body of fancy)
C-x C-e to re-evaluate the definition
voilà, new picture is drawn

A Basis for Concurrency and Distribution link

Spoiled by xmonad meta

I'm doing some experiments with xmonad and I particularly like its mod-Space key combination to switch the window layout in a workspace. Is there something similar for Emacs?

This is similar to what I want: ThreeWindows

Update

I ended up doing this (the entire code is here: larsen-functions.el)

(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)

John Wiegley on git

From emacs-devel mailing list:

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.

lispbuilder-sdl dev

Tried to install listbuilder-sdl via quicklisp, but got stuck on cocoahelper dependency. Is it supposed to work on Yosemite?

Managed to install the library on a Linux virtual machine. Tried Asteroids to test it.

Collection of CSS styles for org link

A thread on Reddit with pointers to CSS styles for org-mode HTML export.

A neat tmux trick dev

Francesco showed me his tmux conf. This is particularly useful:

bind . send-keys B Space E Enter

Clojure: If Lisp is so great, why do we keep needing new variants? link

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

Old but interesting

The "high-level CPU" challenge

Published the interview with Oliver Charles meta

Trying Spacemacs emacs

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

The installation process seems to be smooth.

It asked a couple of questions: one mysterious about the environment I would prefer, and another one about the initial settings (minimal or not) I'd rather use.

Initial setup finished with no errors

Which is good. The only problem –if one wants to be picky– is that the status line looks messy, probably due to a lack of proper fonts.

I try to venture in the scratch buffer

I have, somehow, Vim keybindings and Emacs' ones. So for example I can edit some Elisp expression using "Vim" then evaluate it with C-x C-e. I think there are people that were burned like witches for much less.

I'm surprised

I had the uneducated conviction that with evilmode (on which Spacemacs is based, if I understood correctly) one could either use Vim bindings or Emacs' ones, choosing on a buffer basis. And that seemed unconvenient and unpractical to me. I should dig deeper, but this mixture seems well conceived and sound. As I wrote in another place, quoting Nic Ferrier, Vim is a superior editor, but Emacs is a superior environment to write editors. And Spacemacs is a proof.

Just arrived: Land of Lisp books

Finished Anathem books

Software I'm looking for meta

Switching theme emacs

When you use load-theme the chosen theme is applied together with any other theme precedently activated. This small function could be useful to switch theme instead of just pushing another one on the stack.

(defun switch-theme (theme)
  (interactive
   (list
    (intern (completing-read "Switch to custom theme: "
                             (mapcar 'symbol-name
                                     (custom-available-themes))))))
  (dolist (curr custom-enabled-themes) (disable-theme curr))
  (load-theme theme))

Attended Yoox techevents.yooxlabs.com

UPDATE Danilo Poccia wrote a post to recap the event: YOOXlabs Technology Event

Giraffe: Using Deep Reinforcement Learning to Play Chess link

Freer Monads, More Extensible Effects link

Trying to configure ox-rss.el meta

I'mq trying to properly configure ox-rss.el to produce a feed for this stream.

Computer Science Courses that Don't Exist, But Should link

Genius at play books

A biography of John Horton Conway. Arrived on Monday.

The present in deep history link

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.

Upgrading Haskell on my system

(all started trying to do some experiments with Servant)

Monkey Island turns 25yo link

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

Urania 1622 books

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".

A review by Umberto Rossi

I have history back to ~2003. link

TMK firmware

Trying the tmk firmare on the Atreus. The feature list is very interesting, but it's not clear to me if it's all appliable to the specific hardware I'm using.

Typing analytics

I wish I could be able to measure my typing speed in a consistent manner, and without recurring to tools external to my flow. Ideally, it would be something sitting behind and observing my keyboard usage as I work.

First Atreus mod idea

I'd like to attach a wire to the board's pins that pilot the LEDs, thus being able to see when I'm on a certain layer.

hakyll deploy command dev

Hakyll allows users to configure a deploy command:

Next question is: how could I add more commands?

Post: Double feature keyboard review meta

Width-adaptive XMonad layout link

I thing this will be handy in the future

DateTime::Duration dev

Here a surprising feature in DateTime::Duration's API. What this code will print?

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.

How recursion got into programming: a comedy of errors link

Anathem, by Neal Stephenson books

~15% into the book. Some action. I'm not complaining, I think this prolonged immersion in the concent's life will be crucial – not just colour, I mean – to comprehend the plot that is unfolding.

Light Up dev

Simon Tatham's Portable Puzzle Collection is a nice collection of puzzle games that should be interesting to solve automatically. I installed the Android version of the collection and played a little with Light Up.

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

twitter followers == 0?

Apparently my Twitter following/followers counter has been reset to 0.

Fixed

which-key

@manuel_uberti wrote about which-key, a package that displays available keybindings in popup. Manuel shows an example to activate it:

(which-key-mode)

(setq which-key-idle-delay 0.5
                which-key-key-replacement-alist
                '(("<\\([[:alnum:]-]+\\)>" . "\\1")
                  ("up"                  . "↑")
                  ("right"               . "→")
                  ("down"                . "↓")
                  ("left"                . "←")
                  ("DEL"                 . "⌫")
                  ("deletechar"          . "⌦")
                  ("RET"                 . "⏎")))

State of the Common Lisp Ecosystem, 2015 link

an observation

So, apparently the code highlighting I get publishing a org document gets affected by the current theme in Emacs (note to self: using the cyberpunk theme produces unreadable code on white background).

wiz dev

Trying to expand the vocubulary of my interpreter including graphic primitives.

The environment will get enriched with a list of Pictures that together compose the Sketch we want to draw (I'm using Gloss)

data Sketch = Sketch [Picture]
  deriving (Eq)

data Environment = Environment (Map.Map String Expression) Sketch
  deriving (Eq)

The Sketch is drawn at the end of the repl session (meaning that we accumulate Pictures to be drawn all together at the end of the session: I intend that only as the first step, I want an interactive environment where the user can have instant feedback on the picture he's composing). Something like that:
```
draw sketch = Graphics.Gloss.display (InWindow "wiz Test" (640, 480) (10, 10))
   white (drawSketch sketch)
```
So, we pass from two to three effects evaluating an expression can have:
1. Returning a value
2. Changing the symbol table (part of the environment)
3. Adding a picture in the sketch (part of the environment)

I hoped to be able to include the third effect in the eval function, but so far that's only able to return values, without affacting the environment. I guess this was a poor decision, that needs to be amended.

ghci dev

ghci + Gloss don't play well on my system. I need to do

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

Ron Gilbert on Thimbleweed Park link

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.

Ryan Carmack's game link

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.

wiz dev

I wanted to do some progress on the Scheme interpreter, but I ended up instead fixing code that went on github by mistake, and fighting with some git nuisances.

Anathem, by Neal Stephenson books

I'm currently approximately 5% through the novel. I still have only faint ideas about what's going on. Not yet alarming, by my count.

Clojure IDE dev

Spent some time setting up a development environment for Clojure using Leiningen + Emacs + CIDER + clj-refactor. Still confused by some parts of the system but I can see how pleasant it can be.

Meeting J-Bob: Notes on "The Little Prover" Chapters 1-5 books

The Little Prover books

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.

How to Help Self-Driving Cars Make Ethical Decisions link

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?”

Measuring things dev books

I use org-mode for registering the books I read. Here some code to produce stats.

;; 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

"With great power comes a really shitty UI"

Original tweet

Installed the Chicken Scheme interpreter dev

The Turing Digital Archive link

Basic setup dev meta

Basic stream setup done.

Anachronistic computing

Yay! The laptop I recently bought for a ridiculously low price is eventually working like I want.

First its characteristics:

CPU	Intel Pentium M (Dothan)
RAM	512MB
HDD	40GB 2.5" PATA
Display	12.1" TFT with 1024x768 resolution

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

The Internet with a human face

An interesting talk by Maciej Cegłowski.

bt14.012.jpg

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.

2011 in books

Essays/Computer science/$work stuff

In 2011 I started my adventures in the perilous lands of bigdata, so I've begun harvesting literature on the subject. Extremely interesting and relatively young field. I have an almost finished review of "Data Analysis with Open Source Tools" which I hope to publish soon.

Novels

My first encounter with Douglas Coupland. I particularly liked Microserfs, that somehow seemed to be speaking directly to me. Perhaps not for everybody.

Five minutes after Games of Thrones s01e01 I realized I couldn't wait an entire week to know the rest of the story. Still entertaining, after ~3000 pages and already in the fourth book.

REAMDE

I'm a hardcore Neal Stephenson fan. I also have Anathem in my stack, but I decided to read Reamde first, because it seemed less dense. It was, and also more fast-paced than usual.

How fast my git repositories are growing

I wrote a very small utility to gather LOC counts from a git repository. Called gitsloc, it's based on Cloc, with some extra goodness provided by Sysadm::Install (a rather inaptly named module, if you ask to me, but full of useful gems).

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).

Kindle first impressions

I just unboxed my Kindle. I played with it for a few hours only, but I'm satisfied with the choice so far.

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!

stream

Venetogravel finisher stats meta

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link

Links #57 link