Enlightenmentware

I couldn’t fathom why anyone would use Windows²

I saw this sentence, was about to type something in response, and then I expanded the footnote (side note: is it really a 'foot'note if it's not in the footer of the page?):

I became significantly more tolerant since my early university years. Windows (specifically the NT family) is a great operating system. I even have it installed on my gaming pc so that I can buy games I never play.

It's pretty rare to see such a balanced perspective with respect to Windows when someone starts off with 'UNIX'.

Doubt anyone will be surprised by this from me, but, Nix, 1000x. The amount of crazy stuff you can make work with Nix and Nixpkgs is nuts. This weekend someone pinged me wanting a static build of a Rust binary that had some gnarly bindings to C++ libraries. In under 100 lines of Nix, we have everything: static musl-based build, dynamic glibc build. Want an AppImage? `nix bundle` with an AppImage bundler. Want an OCI image? dockerTools.buildImage on top of your derivation. Throw it in GitHub actions using the Determinate Nix Installer action and you get automatic caching of the Nix store using GitHub actions cache; pretty useful since neither musl Rust nor static LLVM are cached in Hydra. Want to share your cache? Pipe a list of Nix store paths to Cachix, then they can pull it down, or add the Cachix GitHub action to automatically pull from and/or push to it for the CI build. So if anyone wanted to re-use your cache from GitHub Actions CI runs, they could, provided they trust you. You can even cross-compile with MinGW, or run it on macOS.

It's a hugely complex time sink, but my God, it's great. Whereas I don't generally recommend people go down the NixOS rabbit hole unless they're convinced it's right for them, I definitely think Nix is worth having in your toolbelt, it's ridiculously versatile.

I can't really think of a good example that other people haven't mentioned, but I have an anti-enlightenment piece of software, spring framework.

Spring actively hindered my ability to understand the simple concept that is dependency injection, and I know I'm not alone. Many a Java developer think that you need a big complicated framework to pass dependencies into your modules, instead of having your modules fetch them for themselves.

This isn't a criticism of spring per se, it's fine, it provides value for people, but I think it can lead people to build software that is more complicated and less portable than it needs to be.

Speaking of Bazel, I wanted to try it out for a Java project, but it felt a bit more complex than expected.

Would you recommend using it even for mono languages projects?

Coming from C++ and Python, Go's packaging + deployment tooling really enlightened me. It's SO EASY to depend on things and deploy my apps, I love it!

I've also heard Rust gives folks similar warm fuzzy feelings in regards to building and deploying, one day I'll try that too

I would say the compiler explorer[0] fits the definition perfectly. It may seem like a straightforward piece of software, but it has immensely changed the way people discuss and share knowledge around compilers and performance optimization.

I regularly feel the impact on the quality of forum discussions. There's a lot less speculation about if "call X gets inlined", or "Y gets vectorized". Bold claims can be supported or disproven quickly by sharing a link. And then you have tools like llvm-mca[1] or uiCA[2], if you don't mind going into the weeds.

[0] https://godbolt.org/

[1] https://llvm.org/docs/CommandGuide/llvm-mca.html

[2] https://uica.uops.info/

Docker is one of these tools for me.

The unspeakable amount of my time and headache it saved during my consulting career puts a smile on my face.

Docker allows me to quickly iterate over the steps required to run ancient projects.

Not having to install 5 different relational database servers on my host OS alone is worth the learning curve.

Also crucial for running concurrent, reproducible, Python environments in my laptop.

Maybe one day the buck2 ecosystem will evolve to be that bazel replacement. It has a much smaller core. Right now it’s lacking in ecosystem support, tooling, examples, and a local build sandboxing (which could be fine if there was an easy to use local implementation of remote build that felt natural). Also no go support is sort of painful, and it’s a bunch of work as i understand it to get something like rules_go to work for buck2.

They are "round": they pack the most volume in the smallest surface area. unix surface area is tiny, but it unlocks much power. Emacs and Git are all over the place, but their core is small, sweet, and easy to appreciate.

I really like this 'round' concept, seems very precise. Maximum interface area / use cases (surface area) with minimum core volume.

We used SVN at my first job in 2006 and I had the exact opposite experience with it. I never fully understood what I was doing, nothing made rational sense, merges were an absolute nightmare, and somehow I would always ended up corrupting the repo and had to pull a nightly backup to get out of the broken state.

Git was a literal breath of fresh air in comparison. I fell in love hard and fast. Everything just made sense, even if our workflow using git am patches seems downright ancient these days. Friends at the time tried to sell me on hg, but I was in love.

Closed tab at Bazel.

Magit, the git client for emacs, fits the bill perfectly. It is a masterclass in simplicity, effectiveness, and discoverability. It is one of those rare tools that makes you better at the underlying tool it abstracts over; instead of introducing its own jargon and workflow it exposes git's capabilities better than git does.

I would add

Haskell - the rabbit hole to category theory and all the mad stuff Haskell people get into (compilers, proofs etc.)

Bitcoin - love or loath it, technically it is a marvel. At the time Bitcoin came out I was musing on the same problem but never could figure out how to avoid double spends and would never have come up with blockchain!

I’ll mention Typescript.

It elegantly improves almost unimprovable mess of JavaScript. It makes JavaScript development much more productive and pleasant. And it’s surprisingly powerful.

I hope the author would consider trying Doom Emacs, he mentioned knowing Vim and using Vscode, so with Evil and lsp support he will feel at home, the configuration has great defaults!

Yeah, one of the best programmers I've ever worked with would launch Epsilon (a commercial emacs style editor for various OSs) each morning and then do _all_ of his work from it.

The closest I come to that is messing emacs keyboard shortcuts when I'm not using a Mac.

I really wish that there were more programs which completely re-examined all aspects of various tasks _and_ incorporated scripting in a fashion which allows folks to take advantage of it.

Some of the apps I would consider if putting together such a list:

- LyX --- billed as a "What You See is What You Mean" Document Processor, v2.4 is looking to be quite promising...

- TeXshop/TeXstudio --- the former in particular is _very_ nice for folks who aren't able to devote the effort to learning emacs

- pyspread --- have a spreadsheet where every cell can contain a Python program or SVG graphic is _way_ cool --- I just wish it was as flexible as Lotus Improv/Quantrix Financial Modeler

- Solvespace --- I wish I could do better with 3D --- usually I fall back to OpenSCAD, esp. now that there's a Python-enabled version: https://pythonscad.org/ though I often use: https://github.com/derkork/openscad-graph-editor

- TikzEdt/IPE --- I really wish there was a nice graphical front-end for METAPOST/METAFONT (or that the graphical front-end for Asymptote was more flexible)

On the gripping hand, one has to give props to the Krita folks for making scripting a first-class citizen: https://scripting.krita.org/lessons/introduction

Git was nothing like Subversion. It had a steep learning curve and confused everyone to no end

I've actually found git much easier to teach to people who don't know subversion than to people who do. It's still a confusing mess, though. Why do you create a branch with `git checkout -b` rather than something like `git branch -c` (`-c` to checkout new branch)?

It looks like the `git switch` command helps a lot, but I never remember to try to use it as I'm used to the old ways, so I never teach it to new people either. I wish I could alias `git branch` and `git checkout` to remind me to use `git switch` but you can't alias over a built in command.

These tools capture our imagination, open new possibilities, and affect how we design our own systems.

Puppeteer/Playwright fits the bill for me. Learning how to scrape websites with those tools subtly changed how I approach lots of other programming tasks and opened many new possibilities in both personal and work projects.

The event model of the web platform has had a deep effect on how I generally think about systems.

Some people may throw tomatoes at me for this last one: Google Apps Script. The docs and API aren't great, but it has opened so many new possibilities for automation of things related to my personal and work Google accounts.

Re: capturing my imagination, physical computing with RPi/Arduino. I've also gotta admit that GenAI APIs have been an explosion of new possibilities for my line of work (technical writing)

Thank you to OP for creating a productive and inspiring topic (enlightenmentware) for us to discuss and share ideas around

LaTeX.

I LaTeX, Git, and emacs every day.

Happy to see emacs on the list, changed my life.

Enlightenment hardware: kinesis advantage 2, many non obvious, non ergonomic benefits, like adapting the hardware to _my way_ of working/thinking.

Certain games also feel like enlightenmentware.

Although I’m writing these words in Visual Studio Code, I always have my Emacs open

He is writting the blog's text in Code praising Emacs. Makes me a bit sceptical or am I missing something?

React is this for me. Before it, I was fumbling around with libraries like ExtJS for my first job, but after I started using it the concept of components that produce a view as a functional output of state really made so much sense to me.

It has given me so many powerful primitives to use while coding for the web

Great article. For me it's creative use of tools by others - sometimes myself - in a non-standard way (sometimes that becomes standard!) that brings enlightenment. Be it language, source control, networking, you name it.

Aside: assuming the author is reading, minor typo in the first para: But once in a w̶h̶i̶t̶e̶ while

I found quicken to be enlightening. It took me two months to master my family’s finances and budgeting and I’ve never looked back. Learning it’s ins and outs and why it is what it is and provides some features but not others was a wonderful learning experience.

I'll nominate another text editor for this subject: Sam. It's a graphical text editor, but it doesn't resemble any other graphical editor I've ever seen. I've been told it's "like ed on steroids" but I can't verify that statement as I've never used ed.

Sam made me reconsider the way I think about the mouse. In Sam, the mouse is integral to your workflow, but the way you use the mouse is unlike any other editor I've ever used. Brief strokes blended with keyboard stuff. Sam translates remarkably well to the trackpoint, even though it was designed a decade before laptops existed. Its command language is somehow as simple as sed, but (almost) as powerful as vim. It's really old software now, so it lacked some features I wanted (auto-indent, mainly). The source code is simple enough that I just added auto-indent myself!

I used Sam for the last two years of my undergrad. I wrote Python, C++, Nim, and Verilog using Sam. Sam shaped the way I think about computers in so many ways. At a glance it would seem idiosyncratic and weird. Having used it, I consider it to be wonderfully ergonomic and creative.

I don’t know whether this is a provocative or tedious thing to say, but the quintessential ‘enlightenmentware’ to have come out of the past several years is ChatGPT. Name anything that brings as much functionality with so simple an interface and so elegant a core!

(It’s simply a pity that we can’t install it locally or tinker with the internals. :) )

I really like the buku terminal bookmark manager. https://github.com/jarun/buku I like that I can just `man buku` when I don't understand something and I can actually find the answer I'm looking for.

You have a typo. "earn to" when you probably meant "yearn to".

ClearCase is confusing like a Russian novel: All the characters have strange names, the plot is complex, and it doesn’t end well.

Well done.

Git removed the friction from using version control; there was no excuse not to version anything of value anymore. Merging branches with Git didn’t cause anxiety disorders. The staging area—confusingly named index—became essential to my workflows. But my favorite feature was the breathtaking beauty of Git’s design, the elegant mix of distributed systems, acyclic graphs, and content-addressed storage.

I love seeing glowing reviews of Git.

lazygit (https://github.com/jesseduffield/lazygit) is enlightenmentware for me. It helps me navigate Git commands I forget all the time, like using the reflog to undo things, custom patches, or rebase --onto.

It makes working with Git a lot more fun, and I giggle like a little child whenever one of the weirder things work out again.

blaze is one of mine too, specifically for the realisation that your build setup really feels rock solid when your entire dependency list is spelt out as an explicit DAG in a build file. inferring or otherwise auto discovering dependencies on the fly is seductive, but it always ends up letting me down when things get complex.

NixOS fits the mold. The confidence it instills feels similar to when I moved from Windows to (Ubuntu) Linux.

I’m barely a programmer, but I have been using computers for nearly four decades. Among the various tools that have, over the years, captured my imagination, opened new possibilities, and affected how I create things with computers, the current leading enlightenmentware by far is LLMs. Nearly every day I discover something surprising and useful that they can do for me.

Shells, and how by scripting them you have programmatic access to the entire operating system.

But occasionally, we discover a piece of software that transcends mere utility. These tools capture our imagination, open new possibilities, and affect how we design our own systems.

For me, it was DEBUG.EXE on MS-DOS.

This humble debugger allowed me to peek into interrupt vector tables, inspect the content of ROM, learn how MS-DOS boots from scratch, etc.

I fondly remember the days when armed with an assembler, some knowledge of the CPU and the computer architecture, we could plunge into the depths of the system, unravelling its intricacies to our heart's content.

I also must confess to a strong bias against the fashion for reusable code. To me, "re-editable code" is much, much better than an untouchable black box or toolkit.

I had never come across this particular thought by Knuth, but this hits home so hard.

It feels that most of our productivity is a function of how re-editable the code is in the codebase we operate.

It’s intriguing to think about what makes code re-editable vs simply reusable.

Once in a white, we discover a piece of software that transcends mere utility. These tools capture our imagination, open new possibilities, and affect how we design our own systems. I call such software enlightenmentware.

In this article, I praise the software that contributed the most to my enlightenment.

What’s your enlightenmentware?

It is vscode and es6 to me.

Agda. Not as in something i'd use everyday, but using it definitely shaped the way i reason about programming and type systems

Streaming and transforming structured documents at scale used to require some awfully complex machinery such as Apache Camel, Kafka Connect, Flink, etc. I was so happy when I bumped into Benthos https://benthos.dev which can be used as a lightweight replacement in most cases. Bonus: It’s written in Golang, so I don’t have to bother with heavy dependencies and slow start times.

The only good tools I've ever used are typescript and tqdm (a python progress bar).

Wandb and React can get honorable mentions.

JAX

I want to thank wmii for being a vanguard force in illuminating the path before me, by being both a fine tiling window manager, while also showing it's guts, exposed as a 9p file-system.

Being able to craft together super crappy shell scripts to monitor and manage my windows was amazing. It was a huge turn on to feeling like someone who was really communing with the computer at it's deeper level, rather than just surfing above the application's crust. This feels like the real enlightenment goal: bringing forward the (ab-)natural philosophy that underlies each bit of software, rather than crafting facades of interface atop the core.

I have high hopes that general systems research can one day again spark an age of revelation & understanding, that we can form better more earnest symbiosis with machines. wmii was a good example of one way to let bonds grow close & strong.

Laravel. I had been developing web apps since I was 12 years old, but Laravel completely changed the speed at which I could deploy and maintain a production-ready app. And the ecosystem of plugins, add-ons and developer tooling is incredible.

Common Lisp. Not just the language, but the entire runtime: repl, debugger, system loading, quicklisp. It just works.

My road to Emacs was similar to the author's. When I was learning programming everyone was using IDEs. It seemed like they were inseparable from the programming language. I remember thinking I couldn't learn C++ because I didn't have a C++ IDE. After my second or third language I started to think this was ridiculous. It's all just text! And these built in text editors are terrible! It took the best part of a decade for everyone else to realise and move to VSCode, a vastly inferior editor.

Boost::graph feels like one of the dustier corners of the Boost libraries. I have used it, it worked, but it took a long time to wrap my head around the design and actually adapt it to my project. It is not great for getting simple things done, but it will get them done, with the power and flexibility as stated in the article. You will likely never see the Boost interfaces poking through whatever facade you end up erecting around it.

In my case Cycle JS (https://cycle.js.org) was very enlightenment and pedagogic. It make me realize that software is always and only a matter of data transformation. And those pure data transformations can be keep separated and decoupled from "side effects".

One day, I'm working on a Linux machine with my Emacs open, I'm using a Bazel to clean my today's to-do list project. And I open the browser to find a person who wrote a blog about Boost.graph which I never heard about, but I'm really interested to look at. I finish this writing, save the buffer and =C-c g= to lunch magit to write a commit message "good day", then pushed to my git repo.

I have a couple of these to add as well:

VCVRack - simply one of the most mind-expanding things a synthesizer-nerd can play with. (https://vcvrack.com/)

ZynthianOS - another example of a simple software solution to a problem nobody realized existed, opening the door to an absolutely astonishing array of Audio processing tools (https://zynthian.org/)

Emacs, Squeak, and Genera (Lisp machine OS) all qualify for me. It's no surprise that all of these examples are what I call "pervasively programmable": you can not only extend them with code, but examine and modify the running system by typing code into it, shaping the system to your needs as it runs.

Another pervasively programmable piece of enlightenmentware is Ashton-Tate Framework. It wasn't just a spreadsheet but a piece of "integrated software" (the 80s term for office suite), sporting spreadsheet, word processing, database, graphing, and serial communications capabilities, all under a unified desktop-GUI-like interface and programmable with the Lisp-like FRED language. If there were ever an "Emacs for business", it'd be Framework. It's pretty amazing that a program that powerful existed on 1980s PC hardware.

It turned a mundane job of fixing bugs into an exercise in skill.

Emacs does this for me. It's like a toy always there to play with when you're bored with mundane job tasks.

JAGS - allows you to specify a probabilistic model and sample from the posterior distribution

Docker would be on the list for me - for reproducible environments. Probably JUnit as it was my first real testing framework - for being able to use test driven development for hard problems.

With programming, I had so many "aha"-moments, it's hard to remember them. It's not all about software, but more about understanding the concepts and being able to transfer this knowledge. Being able to pass functions or function pointers. Streaming / piping data instead of a fixed data structure. Interpreted vs compiled languages. How everything we do here only happens through a long list of 0s and 1s and how this clever setup makes us even see graphics on the screen. Or hear audio through a screen reader....

Smalltalk and as a particular case Pharo is an example of this for me. (https://pharo.org/). When I was in uni a paper that I always came back to was Licklider's 1960s paper on human-computer symbiosis.

"[...] to enable men and computers to cooperate in making decisions and controlling complex situations without inflexible dependence on predetermined programs."

Experimenting with Smalltalk (and also with Clojure and Emacs) was one of the things to me that genuinely felt like that vision of programs as living, interactive, organic things rather than the formulaic, static and low level programming that I was used to learning. I think it's still such a shame that in daily jobs it's so difficult to convince people of trying these technologies out because it requires such a big shift in how people think about software.

https://worrydream.com/refs/Licklider_1960_-_Man-Computer_Sy...