Their devblogs are really nicely written and you can tell they are extremely passionate about getting things right. In my experience that's a rarity now.
And of course, it's a brilliantly addictive game.
It's also an incredibly cool, interesting game design. If you like Factorio + Tower Defense you should check it out.
I'm not sure that, on the whole, robust and performant software can be put together by teams much larger than that.
I'd prefer a factorio over almost another UI.
I'm imagining a port of factorio's UI into most strategy games would be very nice, both from a VERY zoomable map, a clear research/progression tree. A few improvements could be made IMHO, but it's lighyears better than TF, CS, the Chris Sawyer set, etc.
Like Factorio it's incredible and makes me wonder wtf I was doing chaining together bullshit service APIs in my day job.
[1] https://store.steampowered.com/app/255710/Cities_Skylines/
I'm aware that the concept can be difficult to grasp and that the cli commands seem weird at first.
Once it clicks however, it's an absolutely fantastic tool. I'm still often amazed by what is possible with selective resets, diffs, greps, and most impressively interactive rebases. It makes a lot of otherwise difficult tasks much easier, and more elegant.
Git is IMO one of the most important pieces of software made in the last couple of decades and should be celebrated more for it.
For example, I hate the use of "ours" and "theirs" in merges and rebases. I understand the theory of why it works the way it does and why it's different when merging versus rebasing, but I just think it's downright confusing, and I still have to double check every time to make sure I accept the right changes. I don't understand why they couldn't just use the branch name (or branch + commit hash).
Git is built upon a powerful and beautiful concept, but the Git CLI is just about the worst viable interface to that concept that you can build. There's a reason that there are so many other Git UIs, such as Magit, SourceTree, GitKracken, etc.
Elegant software doesn't normally need an interest group dedicated specifically to preventing people from misusing it. http://www.eusprig.org/
Nothing since is anywhere near as productive. Lazarus is ok, but the documentation is horrible, (almost non-existent, only doc-strings in many cases) which makes the system far less useful.
As someone who very much enjoys tinkering with Linux and such, but also likes trying to onboard other people who aren't as techy, Syncthing is such a killer example. It's almost depressing because I want other free and open source stuff to be this good, though I know the economics (and proprietary interference, perhaps?) make that tough.
I've been dragging my feet migrating a hard drive from my old desktop to my new one for 1.5 years. This past weekend I finally got motivated to power the old one up and wait for syncthing to give positive indication that it's in sync with my server. The reason that was even a concern of mine is that the last time I used that desktop, I spent a whole weekend cleaning up about 200 GB of renamed and duplicated "sync conflict" files that syncthing created and then synced to my server when I previously migrated hard drives. I wasn't sure if all the fixes had made it to the server yet. That required writing my own tooling to positively confirm every duplicate was bitwise identical before deleting one or the other.
The official documentation suggests I remove syncthing's metadata from the drive and then add it again on the new computer, and let it re-sync. It's a good way to check for bit-rot I guess. At least the documentation these days suggests marking one instance as read-only.
I would've love to write about how awesome it is but came across this wonderful essay regarding the same titled _"Computers as I used to love them"_ [0]. Highly checking it out.
Forth, Lisp (Scheme, in particular - I love CL but it's the C++ of Lisps), and Lua - three languages that take a small set of elegant primitives and synthesize them to give you incredible power.
Remember the Milk is a task-tracking SaaS that is one of the few pieces of software that I actually like, which is especially impressive given that it's proprietary. Cheap, fast, effective, and with a UI design that continually impresses me with its mix of intuitiveness and ergonomics.
Good examples IMO are Magit and Org-mode. They are basically large applications created in Emacs, and each so good that they are worth learning/using Emacs just for using them (I'd say AucTeX is also in this category).
The game is beautiful, performant, and almost entirely hand-written assembly by one guy.
Plus, the parks themselves can look very elegant (kind of like factorio factories).
https://www.pcgamesn.com/rollercoaster-tycoon/code-chris-saw...
For another fun game in this genre, check out Parkitect which has some additional logistical elements around transporting and hauling stall inventory https://themeparkitect.com/
http://www.chrissawyergames.com/feature3.htm
https://www.youtube.com/watch?v=5UKKaTGwIqc
https://www.youtube.com/watch?v=p6Fci7NWYUo (videos by Simon Foster, from https://redd.it/32jind)
Kitty, the terminal emulator by Kovid Goyal
wouter, a minimal JS routing library
espanso, a text expansion program
KDE Connect
Tailscale
The last 2 together
curl
Could you elaborate on what do you feel is better or makes you more comfortable using kitty against any other random terminal?
I also vouch for KDE Connect. Painless to use after installing. Very convinient for file transfer
Bitwarden
Linux Mint
Altium
Comsol
Proprietary yes, but I’ve used all three over the last few years and found them each to be very streamlined, productive, and elegant after a fashion.
A browse through their application gallery can be pretty interesting:
There's examples of studies into everything from cooking beef in a convection oven, to Bose-Einstein condensates, medical implants, geothermal storage, semiconductor manufacturing, etc, etc.
Vim's entire command model is based on the simple composition of motion and action.
Until you understand this you will never 'get' vim. You may be able to use it, even efficiently, but you will never understand how these two simple concepts when fully understood are a force-multiplier.
Motion indicates a range, of characters or lines, there are motion keys that will get you: to EOL, to EOF, to next matching char, to braces, to function / class blocks, to predefined marks.
An action is something that applies to that range, these can be anything from auto-formatting, changing case, calling out to another process, anything you can imagine.
When you understand this suddenly g=GG, ct(, y$ become: reformat document, cut to next paren and copy till EOL respectively. Does that sound horribly esoteric? that's only because you don't yet understand vim motion composition.
I'm happy to argue that if anyone fully understands this concept they cannot help but agree that vim is at it's heart seriously elegantly designed software.
I just recently had an opportunity to flex my "wizard muscles" in a case where we had to feed a test consisting of about a hundred similar messages with minimal differences (numbers) to a system in order to reproduce an issue.
"Can't we try to reproduce this?"
"Maybe, but we'd need a lot of messages in order to reproduce this."
"And...?"
"That's tedious."
"Watch me" *grinning*
The short circuiting `or` chain is also pleasantly virtuosic. Sometimes a little flashiness is tolerable when it works this well!
Some time ago I spent a good amount of time looking for a development stack that allowed me to just build stuff. I ended up trying and deciding on Laravel Jetstream with InertiaJS https://jetstream.laravel.com/2.x/stacks/inertia.html. Laravel was easy enough already to just pick and do things, now this solves the backend+frontend projects for me by allowing me to just put vuejs components on top of my laravel app and jetbrains already comes with Auth stuff setup solved.
What do you mean by this? Perhaps that's a typo and you mean Jetstream?
I run 4 monitors on 2560 resolution on two separate amd cards and everything runs flawlessly. I have all the software for free and most OSS is just as good if not better for my work (except games and Photoshop but photopea is a good alternative for that, and it can be easily my second nomination for this thread).
I know linux has evolved a lot and it's the effort of millions of volunteers which has made Linux what it is today, but for me personally Linux Mint really combines all the great things about linux into an amazingly elegant software.
A pity, as I dislike snaps and the generally dumbed down direction of recent Gnome, so it would otherwise have been a good fit for me. For now I'm (still) on Ubuntu though.
Non-trivial graphs will make it produce hard-to-read output, and you can try fiddling with it forever to get better output. But it's still the first thing I reach for when I have to make a graph.
Simple. Free. Open Source. E2E encryption. Basically, No frills.
Their idea is to make software not with most features but the one that stays until the next century.
They have a great blog on this philosophy. https://standardnotes.com/longevity
On that note (no pun intended), I do wish it was possible to query tag intersections, so to speak. E.g., show notes tagged with both 'todo' & 'coding'.
They're games, and relatively short/easy, but it's beautiful and elegant.
There is a metric ton of elegant games. It's the elegant mundane software that is much more rare and therefore interesting.
https://en.wikipedia.org/wiki/History_of_the_Berkeley_Softwa...
In case someone is wondering how a staid brokerage came up with this incredible technology: the trick is, they didn't.
For obvious reasons it is much more common to see this level of design in physical, life-critical systems like aerospace or automotive technology, but you do see it sometimes in software. Well designed services that under heavy load, various kinds of infrastructure failure, attack, or other kinds of scenarios well outside the bounds of normal expected operations intelligently compensate while signaling alerts with precise, useful information, and attempt whatever kind of recovery is possible.
This is hard to anticipate and often thankless to build in advance. It's always a stressful time when this behavior is visible, but it gives me a feeling of admiration for the perhaps long gone employees who built it.
They did a really nice job of building thin layers up the stack from byte buffers (bytes), to async-friendly logging (tracing), basic IO (mio), async runtime (tokio), generic request/response services (tower), HTTP (hyper), and a web framework (axum).
Each of the layers are useful independent of the other layers above, and every one is has a thoughtfully designed, pragmatic interface.
Pipes in Unix as a concept are also a great abstraction. A bit dated, but still every powerful today.
Files in Unix as well. Some people have gripes which are fair, but the idea that a device, a file, and a socket are all accessed via the same API is fantastic. Of course there are issues, but it's generally worked really well for me.
I've used it to:
- batch edit columns copied from excel files.
- wget/rename/run cli commands on dozens of inputs without having to worry about how for loops are written in bash/bat/powershell by just typing commands on a hundred lines and concatenating them with &&
- extract data from various text files without writing parsers or even thinking about regexes
This is one keyboard shortcut, with one of the smoothest learning curves ever. Pure elegance.
- Unix and its inertia
- Licensing of Unix allowing it to proliferate to the masses and being used for education
- because it is simple enough that a compiler can be quickly brought up for any new ISA that appears, as long as it looks enough like a 70's-80's CPU architecture enough for pointers to work.
Elegant? No.
- Making pointers and arrays synonymous is elegant only from the CPU's perspective.
- The pointer syntax sucks.
- Casting does weird stuff sometimes.
- Bool - how hard is it to get true and false right?
- Everything being an operator leads to the confusion between assignment and equality which is inelegant. It was cute in the 70's when you had limited disk space but sucks now.
- `void *` being used for function pointers is not elegant.
- Threads and any notion of multiple CPUs doesn't work well without a lot of libraries or help.
- An elegant language would have not cared about the underlying CPU memory model, but C had to be enhanced for 16-bit x86 segmented memory models.
- If you are using intrinsics or whatever to generate assembly opcodes (e.g. vector instructions) because your language doesn't support them, you are surpassing the limitation of your language in an inelegant way.
- An elegant language makes things like the IOCCC impossible.
A full-featured IRC client for Windows that includes an entire scripting language and yet it consumes less RAM than calc.exe.
But is it really true that vanilla mIRC consumes less RAM than calc.exe...?
That'd be impressive, if I could believed that!
Very simple, instant search, and having the same UI for searching and creating notes is genius - way fewer duplicated notes, for one thing.
But I’ve never considered it elegant.
OwnTracks is an app that logs your position and sends it somewhere else. It has been running on my phone for like 2 years without issues, and talks to a server I wrote myself.
FolderSync syncs folders on my phone to remote storage. It's super flexible and generally just works. The conditions for syncing are highly configurable. I lament the lack of a similar utility on Mac - basically an rsync+cron UI.
Match this, do that.
- Propellerheads Reason, a sweet DAW
- emacs, a text editor so elegant it’s a real OS
- Procreate, the nicest iOS drawing app
On a similar tangent, NodeRED is also an interesting software to build workflow-based automation visually.
Microsoft SQL Server 7 or later
NextStep
BitTorrent (more the protocol, but could also apply to any good implementation)
JetBrains software (pretty much any of it)
Think Pascal
ZFS
OS/firmware in Nokia “slab” phones from the late 90’s
StarCraft II, original Tetris, original SimCity (since all the cool kids are suggesting games)
Macromedia Director, it was amazing how quickly you could create an interactive standalone app or CD-ROM.
It's not everyone's cup of tea, but given the limitations it has decided to work within, it really is a wonder.
It's almost like Git + Gitea, all in a single application. Code + tickets + wiki + notes all version controlled and capable of hosting the server itself. Also, the repo is just a SQLite database, so backup is easy.
It's architecture, the window manager/system, the UI, how it is built by and for the users, how the API is integrated and how fast it is compared to other software.
Another example might be my favorite text editor, vis[1].
[0] https://www.openbsd.org/ [1] https://github.com/martanne/vis
Graphite for "simple" time series storage:
https://www.aosabook.org/en/graphite.html
HLL datatype (PFCOUNT, PFADD, PFMERGE) in Redis for counting unique items in a set:
Data structures and algorithms that make Lucene & Elasticsearch fast (video):
Can’t find original pub; here’s someone’s host of the original paper though: http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf
Visual Basic (cue the hecklers). Yes the language is awful. But the tool was great. I wish Microsoft (or somebody) would release a new version for full-stack apps with a drag-and-drop UI with js event handlers, easy backend framework, and a one-button “deploy to cloud” button for testing. Then a “publish” button that sets up your CI pipeline for production deployments. I feel like we’ve raised the white flag in terms of what software development should look like in 2022. Writing yaml feels like banging rocks together compared to possible alternatives.
Of course the current/latest version of it has took a life of its own in size and complexity (but of course with performance and reliability too) but the initial version still shines through!
Prolog. There's a reason it's been king of the Logical Paradigm for decades.
Oberon OS.
Turing Drawings. ( https://maximecb.github.io/Turing-Drawings/ )
procmail ( https://en.wikipedia.org/wiki/Procmail ) one of the most beautiful (yet hideous) programs I have ever read.
Although one might argue it to be a case of really elegant documentation and literate programming.
Some of the best C++ code written. Extremely clear and concise. Chess-AI is a bit complicated but the source-code + comments seems to inform the programmer where all the problems are.
If you're ever in Paris, get a front-row seat on subway line 14 and feel the magic.
Geometric algebra for any R{p,q,r} dimensional space. Has it own custom JS to JS transpiler so the literal number "1e10" becomes a bivector. The code is just around a thousand lines while it lets you do amazing things like this right in the browser:
https://enkimute.github.io/ganja.js/examples/coffeeshop.html...
It's written in C# and the design seemed clean and approachable (at least a few years back when I tailored it a bit for my own use).
I used this to show my kids how computer games work. I started out by showing them Unreal Engine 4 so they understand the modern tool chain, but that still leaves the mystery of how the game is represented inside the computer. Within minutes you can have some code drawing things, real graphics, on the screen. I cannot adequately describe how easy it is.
The experiment I did with them (young kids) was define some variables, draw a counter on the screen, start a loop, and then increment the counter. After they saw how that was represented to the computer it was easy to get them to imagine a character with all of his stats assigned at the beginning and then updated on every iteration of the loop as events take place. But with kids you've gotta move fast or they lose interest. PyGame makes creating games so fast you can literally pick it up and start teaching it to kids without knowing it yourself. It's that good.
It allowed me to implement a mini OTP framework in Python[1].
> Abstract: We show that it is Scheme, of the Lisp family, the language that deterministically emerges when one opts for elegance.
I'm not sure what other protocols exist today for tracking a list of servers, providing information on them, and are as up to date as the frequency of the heartbeats from those servers, but I suspect there are similar protocols out there, and I'm just not familiar with them.
Unfortunately despite how elegant the QSpy protocol is, most modern video games no longer provide server browsers as first-class features, eschewing them in favor of matchmaking services or publisher provided dedicated servers.
The language design of python made almost everyone learn programming.
OurGroceries, a lovely little free app to share grocery lists with your family FooBar2000, an early windows-based media player uTorrent (or at least the very early versions, before it became bloatware) Snapchat (again, the early versions when it was 5x quicker than any other mobile photo sharing platform)
It's very focused on the task of writing - novels, short stories, screenplays. It pares away the parts of e.g. a word processor that are distracting (layout and the like), adds the functions of a database for tracking characters, locations, research and so on.
The underlying implementation is also storing as plain files in directories, so you can be comfortable that you'll be able to retrieve your writing if Scrivener no longer exists.
Also, at any point in time, it's likely to have zero open issues and zero open pull requests, which is pretty impressive for a project of its size.
To be fair, my job lend itself toward this at the time, the WWW was nowhere near what it was a few years later, and everything-tied-to-everything was miles away. But this blew my mind.
- CWM
- Music On Console
- Sfeed+sfeed_curses+xargs+wget+MOC
- Entr
- Mit-Scheme + Edwin + SICP. It doubles as an IMAP client. Use Stunnel for TLS.
- UDFClient
- NNCP
- S-Nail. It can be easier than Mutt.
https://www.oreilly.com/library/view/beautiful-code/97805965...
Their Setup for the Docker stack [2] is not only well documented, but also suitable as a blueprint for any persistent software setup with Docker. They also have a mentality for documentation as a firct class member, which is really important for OSS and self-hosting. You'd have to look hard to find any outdated piece of information or lazy written part in the docs. Lastly, the interface is just beautiful, simple and elegant. I finally enjoy listening to my music library again.
[1]: https://funkwhale.audio/ [2]: https://docs.funkwhale.audio/installation/index.html#availab...
Scrubs
Distributed parity
Hot spares
Encryption
Snapshots
Compression
Quotas
All in an intuitive way that led to an almost cult like following in the Unix/Linux admin world.
https://solvespace.com/index.pl
A single executable of about 6MB with pretty significant capability.
The source code is pretty clean as well.
If yes, then I’ll offer an oldie but a goodie: Adobe Photoshop.
Many of its tools are intuitive. As a photo artist you don’t want the application getting in your way. It’s easy to learn how PS organizes multi-color/layer/channel images. You can do a lot with a little bit of knowledge of the application, so you can do the simplest things easily and quickly. With more application skill you can produce the highest quality images necessary for _any_ static image project.
I tried many alternatives, then finally found XYplorer. It is so easy to use, well structured, but when needed it is also a power house full of soo many tools you otherwise need another app for. Really loving it and many kudos to the only(?) developer from Germany who constantly improves it.
The first thing that comes to mind as elegant compared to the alternatives is k9s for managing/monitoring kubernetes.
Rustc.
Pov-RAY (for creative interpretations of "elegant").
Diff and patch.
The original Starcraft and BroodWar.
Battle for Wesnoth.
Bittorrent.
Probably one not many people have used or heard of: CoCreate Solid Designer.
https://vega.github.io/vega-lite/ https://altair-viz.github.io/
even on an ancient laptop, it runs smoothly. I had no idea a javascript game could look/play this good. I've spent 100 hours on it since I first saw it posted here on HN
PFE back in the day. Simple macros and templates that made life much easier in a small package. Some editors today don't even bother with macros or have all of PFE's options.
passwordstore.org
One of the most beautiful spreadsheet programs ever designed.
Telix
QEdit
Adobe Indesign
Monodraw
GNUcash
Django
Beeminder
Does exactly what it promises
Being able to just plot sin(x) blew my mind.
More seriously: cholmod
haha just kidding!
Incredibly easy to host open source network video recorder with object tracking and hardware acceleration support. You have to install hardware and know what you're doing to hook things up, but bespoke systems that do these things cost tens of thousands for hardware/licensing alone and don't do them half as well.