The making of a friendly robot

Learnt more about the “origin story” of Roomba from an article in the WSJ this weekend.

  • First sold as a product 20 years ago
  • Joe Jones joined the AI pan 20 years before that
  • Various hiccups: lab lost funding, he was fired from the next gig
  • Rescued from irrelevance by a serendipitous Pepsi ad
  • First prototype was made with Lego (!)

Monthly Curations: July 2022

Star formation inside the galaxy NGC 7496

Monthly recap: July 2022

A patch of ground

Major update(s)

  • An “almost forty” birthday party for me and Shivi
  • Car trouble (more on this later)

Minor update(s)

  • Found a new used books store in Menlo Park
  • “Family board game time” with Mastermind and Ticket to Ride
  • Re-re-discovered Wolfram Mathematica
  • Played Minecraft with Tara (yep, it’s fun and addictive)
  • CSMA camps for Tara: she made a bunch of fun art


  • Cleaned up and brought the decade-old Yamaha piano out from garage storage 🙂
  • Went to play tennis in the courts nearby
  • Half-way through season-3 of Stranger Things
  • Watched Marcel the Shell in the hall
  • Watched Harry Potter and the Half-Blood Prince

Books on Software Complexity

(from this HN thread)

If only all posters collected their responses into a spreadsheet like this one did

Here is the summary post (my preferences in bold):

From my perspective, the top “must-reads” are:
— John K Ousterhout, A Philosophy of Software Design
— Titus Winter (et al), Software Engineering at Google
— Hanson and Sussman, Software Design for Flexibility

Other interesting titles that caught my eye:
— Peter Naur, Programming as Theory Building
— Scott Wlaschin, Domain Modeling Made Functional
— Yehonathan Sharvit, Data-Oriented Programming: Unlearning objects (upcoming)
— Nick Tune, Patterns, Principles, and Practises of Domain Driven Design
— Robert L. Glass, Facts and Fallacies of Software Engineering
— Donald Reinertsen, The Principles of Product development Flow
— Eric Normand, Grokking Simplicity

Language comparison

Came across this pros/cons table recently (some un-named company, when deciding on micro-service language-of-choice):

Mostly agree, except that

  • We do have generics in Go (as of 1.18) and “… unfamiliar with the language” is true for any language
  • The Python cons will remain as they are (though they should matter much less when not doing cpu-intensive tasks)
  • The Rust cons will reduce as (1) it becomes less ‘new‘, and (2) the ecosystem becomes more ‘strong‘, and (3) async/await has been standardized now, but yes, the memory model will always take time to learn.

Given this, and admitting a lack of Kotlin knowledge, IMO Go seems like a safe default choice (or Rust/Python where appropriate).

Extension Languages

Found this old post by Jon Skinner on why SublimeText went with Python.

If you’re building an application, then your users will get much more out of it if you given them a plugin API. For Sublime Text, I settled on Python as the extension language. In fact, I think you’d be mad to choose anything else.

It’s well-reasoned, and considers all the alternatives at that time.

What about JavaScript? It’s an underrated, elegant language, with a huge number of people acquainted with its syntax. Its weakness is that it’s not used as a general purpose language, so there’s no selection of libraries your users will be able to build on. No libraries and no built-in standard APIs (file system access, I’m looking at you) rule JavaScript out.

However, it’s also clear how, 14 years later, the landscape favors JS/TS as the scripting language for an editor/IDE like VSCode.

Lua is another candidate, which has a lot of uptake in games. It has a very small code footprint, and excellent runtime speed. However, its paucity of libraries, weak Unicode support, and small-medium user base make it hard to justify as an extension language for desktop applications.

Ditto for Lua in Neovim today.

To CIEL and beyond

There have been a lot of “modern” libraries within Common Lisp, but there isn’t a coherent way to “look at” them together.

So the impression of CL as this “frozen in time” language persists (I think of it more as a system than a language, but still).

CIEL is one attempt, by Vindarel (who’s also making a video course at Udemy and contributes a lot to the Cookbook), to bring together “the best bits” from libraries such as alexandria, serapeum, cl-json, access, uiop, trivial-do, ppcre, bordeaux-threads, lparallel, fiveam, and more.

See the documentation for details on all these features. If all you’ve known is the old, bare-bones CL, you’re in for a surprise.

This, or something like it, is sorely needed, to have a “pseudo-standard” to allow people to write “similar-looking code”, without having CLHS as the only common ground. I wish him luck.

P.S. I made some quality-of-life improvements in a personal fork, based on my attempt to get this working on my MacBook.

Geometrick T-shirts

I had a T-shirt with a certain pattern that was fading out. I didn’t know at the time that this had a name, and later learned it was a geometrical pattern that had certain interesting connections. I won’t link to that here, but you can find it by searching for “Metatron’s cube” online.

Re-creating this geometrical pattern became a fun exercise within Wolfram Mathematica (which is such a useful and under-rated tool, btw, I can’t recommend it enough for anyone with the slightest interest in doodling, tinkering, learning, simulating …).

Nothing fancy, just a bunch of circles, points, lines, triangles. Good old-fashioned geometry.

I was able to experiment with a few different designs until I settled on one I liked. Mathematica allowed me to export what I had as a regular PNG file.

I still had to do some post-processing — to be honest, I’m sure there are tools within Mathematica for this, but I just used a photo-editing tool on my laptop to remove all the black and make the background transparent.

I had to pick a website to use for this, since there are so many options today. I went with something that I knew from many years ago, Zazzle, though again, I’m sure there’s something better right now.

Here is the finished product:

Here’s an example of rendering it within Wolfram Mathematica:

“Metatron’s Cube”