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.

https://store.steampowered.com/app/392160/X4_Foundations/

The expansion packs have expanded the size of the game world considerably, making the whole thing even more amazing

[1] https://store.steampowered.com/app/255710/Cities_Skylines/

I was bothered by this problem so I solved it for my own city builder game, Archapolis (still very early development):

https://www.youtube.com/watch?v=7q0l87hwmkI

I can path 200,000 to 300,000+ units simultaneously to random destinations, with a bonus of utilizing all shortest paths between two points.

The paths are all cached for constant time path finding, but I figured out how to do so efficiently (both building and storing tree/graph)

I wrote a non-technical article here:

https://www.yesboxstudios.com/2022/04/27/all-nck-shortest-pa...

https://www.factorio.com/blog/post/fff-176

It's still leagues ahead of any other game I've played though.

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.

[0] https://www.gnu.org/savannah-checkouts/gnu/emacs/news/NEWS.2...

[1] https://www.masteringemacs.org/article/speed-up-emacs-libjan...

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

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.

It still is. (And Blazor is pretty cool, too.)

https://github.com/magiblot/tvision

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.

[0] : https://tonsky.me/blog/syncthing/

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*

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.

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)

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

- things that were the same on both sides so aren't in the diff

- things that were different but auto merged, and aren't in the diff

- things that were different, were auto merged, and are in the diff

- merge conflicts

But how did it distinguish the last 3? And how does it get so confident about #2 that it doesn't show them and there isn't a single command to show them?

When hg was more popular I knew someone working on Google Code who told me it was better because it didn't have rebases, but I'm pretty rebases and linear history are safer than this.

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.

Nor do my coworkers who keep committing whitespace changes and machine-specific configuration changes unrelated to the tasks at hand.

For a more serious answer: I find it extremely useful to be able to control what goes exactly into each commit. Sometimes I refactor more than one part of the code at the same time. If one part passes tests and another one doesn't, I can commit just the one that does. If I spot an issue in one part of the codebase and I add a TODO or FIXME in a comment, or if add some logging, or some other inconsequential change, I can leave them in the working copy for later while still adding "atomic" changes to the repo.

But by far the most use I get out of it is as a last chance of reviewing the code I just wrote, or as a way of checking the results of an automatic merge before the actual merged commit gets written.

My understanding is that other distributed version control systems, such as Mercurial or Bazaar, take a similar approach to the above.

It does seem like it'd work without it, since there's commit --amend.

https://stackoverflow.com/questions/tagged/git?tab=Votes

There are also posts here mentioning vim, which to most people is weird and useless at first.

Some tools takes effort to understand, but once you put in the effort, they become tremendously powerful.

I would say that they are elegant in that they allow you to do something otherwise difficult in an effortless and obvious way. Both vim and git does exactly that - once you've gotten to know how they work.

But this CANNOT be said about git! For example [1]:

-----

In Git you can merge with an unrelated repository by doing:

> git fetch <project-to-union-merge>

> GIT_INDEX_FILE=.git/tmp-index git-read-tree FETCH_HEAD

> GIT_INDEX_FILE=.git/tmp-index git-checkout-cache -a -u

> git-update-cache --add -- (GIT_INDEX_FILE=.git/tmp-index git-ls-files)

> cp .git/FETCH_HEAD .git/MERGE_HEAD

> git commit

Those commands look quite arcane to my eye. In Mercurial we do:

> hg pull --force <project-to-union-merge>

> hg merge

> hg commit

-----

So in a sense you are right, that's exactly the point of contention. However, simple (and hard) things in Git are done in a complicated and non-obvious way, which require you to memorize a bunch of commands and flags which require understanding the internal implementation of git. There are much easier and intuitive ways of doing version control, and Mercurial proves it.

As a side note, I can't be bothered to look it up right now but iirc even Torvalds said that originally Git's CLI was not actually meant to be used by end users (rather, another abstraction layer on top would provide a friendlier approach to version control). But people ended up using it as it was, for various reasons.

[1] https://stackoverflow.com/a/892688/1780726

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.

Many cars and especially planes & spaceships are have tons of systems like this.

I worked on a system that did things like in response to a primary datasource being offline would switch the queries it used to a different database to include substitute data and pass this back to be used instead until the primary store came back online. Three years after it was put in production this happened on one of the company's biggest and most important days of the year, and our SREs were sitting there calmly trying to solve the issue, ended up waiting until late at night to deploy a fix. It would have been reasonable for this service to just rely on the primary source, but we would have been offline for hours if this little trick hadn't been put in place.

The thing that trips me up about this is how can you ensure that the substitute data is actually useful. Is the substitute data a copy of the primary data? I guess it all depends on the use case...

I wonder if the occupants of the other car benefit in any way...

Now if they had only bought a Mercedes as well, they could have chosen the self-breaking option to avoid the collision in the first place.

https://nowiknow.com/the-special-sound-a-mercedes-benz-makes...

Here's a link with some more information: https://99percentinvisible.org/article/breakaway-hit-street-...

Another thing to look into if you find that cool is guard rail design. Modern guard rails have some cool features designed to reduce risks associated with hitting them.

https://norvig.com/spell-correct.html

The short circuiting `or` chain is also pleasantly virtuosic. Sometimes a little flashiness is tolerable when it works this well!

You're saying python computes an expression that's part of a default value when the code defining the function is run? I guess it makes sense now that i say it, I wouldn't have automatically assumed that. That's an interesting one to remember.

    >>> def function(b, a=[]):
    ...     a.append(b)
    ...     print(a)
    ... 
    ...     
    >>> function(1)
    [1]
    >>> function(2)
    [1, 2]
    >>> function(3, [4])
    [4, 3]
    >>> function(5)
    [1, 2, 5]

    >>> def function2(b, a=None):
    ...     if a is None: a = []
    ...     a.append(b)
    ...     print(a)

  >>> def func(b, a=list()):
  ...     a.append(b)
  ...     print(a)
  ...
  >>> func(3)
  [3]
  >>> func(3)
  [3, 3]

def foobar(my_list=[]): my_list.append(42)

A cursory glance suggests this function appends a number to an empty list every time it's run. But actually, the default argument is evaluated once when the function is defined, so calling this function repeatedly will continue to append to that same list.

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.

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.

Personally I'm pretty happy with Reminders, being able to shout reminders at Siri, and getting location-based reminders has actually been pretty useful for me especially these days when I don't know when specifically I'll be in the office.

A shared to-do list with my wife was the real killer feature.

Things 3 have been out for a long time now so personally I wouldn’t take the risk and would rather wait for Things 4, so that my payment lasts some time.

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.

http://wok.oblomov.eu/tecnologia/mixed-dpi-x11/

Edit - To add a little context since that on reflection seems too dismissive...

I did try a whole bunch of things a while back, include several variations on xrandr stuff. I never did get to a place where all the following were true:

  Both screens were operating at their maximum resolution
  All app windows were appropriately sized (readable fonts, correctly scaled menu bars, etc.)
  Neither screen was blurry due to scaling

I love the command line. I just don't find messing around with config to make the basic system stuff work properly edifying.

You're right it didn't work out of the box but it was very simple thing even though I'm relatively new to linux myself (relatively speaking)

(1) https://gist.github.com/r0xsh/4d1c7219ee63e4cee0c7fe1077559b...

It is a bummer that it's not on Wayland, and seemingly they have no current plans on migrating.

More here: https://linuxmint-user-guide.readthedocs.io/en/latest/upgrad...

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.

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.

https://dreampuf.github.io/GraphvizOnline/

Another example might be my favorite text editor, vis[1].

[0] https://www.openbsd.org/ [1] https://github.com/martanne/vis

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

I was surprised to read "surprised" cause even if GitJournal choose badly, the history is still there.

Nevertheless thanks for letting me know. I'll bump it in my internal Todo list.

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.

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:

http://antirez.com/news/75

Data structures and algorithms that make Lucene & Elasticsearch fast (video):

https://youtu.be/eQ-rXP-D80U

Can’t find original pub; here’s someone’s host of the original paper though: http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf

[1]: https://github.com/elixir-ecto/ecto

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.

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.

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!

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

I think this is actually much more complicated than it seems at first thought. There are a lot of different ways to represent booleans, each with their own advantages, and then the hardware has it's own ideas that might need to be considered. I'm not sure that there's any way to do bool that doesn't lead to pain somewhere.

Pffffffft... bahahah. No. You can write unreadable turds in ANY language.

They're games, and relatively short/easy, but it's beautiful and elegant.

[0] https://www.monumentvalleygame.com/mv2

There is a metric ton of elegant games. It's the elegant mundane software that is much more rare and therefore interesting.

https://youtu.be/QtVkteAS15M

Elegant software doesn't normally need an interest group dedicated specifically to preventing people from misusing it. http://www.eusprig.org/

> Elegant software doesn't normally need an interest group dedicated specifically to preventing people from misusing it. http://www.eusprig.org/

Plenty of the other software listed has user-error misuses (For instance C is listed, and by the same standard it could be considered responsible for more software vulnerabilities than anything else!).

Sure there are errors in spreadsheets, but as the alternative is often calculating something by hand or asking similarly-trained users to write a python scripts, I think both those options probably create more errors.

Looking at the 'horror stories' listed on that website:

* The first listed is about the UK government using a version of Excel that is over 10 years old, with an issue that would not have happened if they updated the software.

* The third listed is because someone ENTERED incorrect information into a procurement spreadsheet (they copied the specification for a standard bed in rather than a critical care bed).

* The fourth is user input error - they input a fund as Dollars rather than Euros (how is this Excel's fault?)

* The fifth and sixth talk about logic errors - one with hard-coding a value and another with using 'cumulative mileage totals rather than running calculations on a sample average for vehicles'.

I agree that spreadsheets can have issues, but most of these can be mitigated by setting up sheets properly and I haven't really seen a compelling replacement for a spreadsheet for the sorts of stuff it gets used for.

The real problem with spreadsheets is a lack of training - I would estimate less than 20% of users know how to turn on cell validation, less than 10% know how to write a dynamic array formula, and less than 5% know how to use PowerQuery. It's like asking a bunch of people to write python code, but only 10% of users know how to write a loop, and then we are surprised that there are issues.

Besides, if you input a fund into a fancy financial package with the wrong currency it will cause the same issues.

We don't expect any other off-the-shelf technology to meet such a wide variety of use-cases, and somehow I think the statement 'excel is bad at processing bioinformatics data' speaks a large amount about how pervasive and flexible it is.

Besides, in reality Excel actually can handle the data perfectly fine if the data is brought in correctly (i.e. Data -> Get Data and using PowerQuery rather than just importing a file and hoping Excel works out the types correctly).

And then in 1987, I opened Excel 1.0 on a Mac SE for the first time. Was blown away at how elegant that felt. Later versions seemed to loose that original elegance as features were added.

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.

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!

calculator.exe is at 74 MB working set, 24 MB Memory (private set), 50 MB Memory (shared working set), 48 MB commit size.

mIRC.exe is at 31 MB working set, 13 MB Memory (private set), 18 MB Memory (shared working set), 38 MB commit size.

Doesn't matter which value you use for "How much memory does this program use?". mIRC is smaller in all of them.

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.

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

It's well-maintained, extremely fast, always responsive, easy to configure, supports ligatures and IBus.

Some innovative keyboard functionalities. E.g., highlighting all the URLs in the current buffer, so I can open it in the browser with just keyboard shortcuts, same for file paths. One keyboard shortcut let's you open the last output in a pager. So I don't have to `previous-cmd | less` again. There are a lot of small stuff like this.

Configurable to its core.

Broadcast feature which lets you print output to multiple panes.

Plugins (called kittens!) which can extend the functionality a lot. Like ctrl+f in the terminal.

And as the sibling mentioned, well maintained. Kitty is one of the softwares on my "donate-to-when-financially-stable" list.

Bitwarden

Linux Mint

If you're ever in Paris, get a front-row seat on subway line 14 and feel the magic.

Very simple, instant search, and having the same UI for searching and creating notes is genius - way fewer duplicated notes, for one thing.

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

https://openhardwaremonitor.org/downloads/

https://github.com/openhardwaremonitor

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

[0] - https://trio.readthedocs.io/

[1] - https://linkdd.github.io/triotp/

> Abstract: We show that it is Scheme, of the Lisp family, the language that deterministically emerges when one opts for elegance.

https://chaitinschool.org/blog/the-most-elegant-of-arrays/

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.

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.