Ask HN: What are your favorite examples of elegant software? design or otherwise |
Ask HN: What are your favorite examples of elegant software? design or otherwise |
One of the most beautiful spreadsheet programs ever designed.
It's not everyone's cup of tea, but given the limitations it has decided to work within, it really is a wonder.
Telix
QEdit
Adobe Indesign
Monodraw
GNUcash
Django
Beeminder
GPalantir is definitely being more open with their demo now, so there are some good ones on their youtube channel.
You can skim through.
https://www.youtube.com/watch?v=uF-GSj-Exms
I'm impressed by how polished everything looks. As a person who does UX / product design, their working software looks better than most designer's portfolio mockups.
I'm impressed by how fast and snappy everything works or feels.
I'm impressed by how rich and custom tailored their UI component library is.
I'm impressed by how focused and tailored their UI for job at hand.
I'm impressed by how every single page in their application looks beautiful, not just a handful.
They actually have all their React UI library published as opensource here. https://blueprintjs.com/
If there's anyone from pltr reading this, good job. Your design people are amazing.
No, but when they arrest you, you see the effect :)
Just by looking at the answer in this example, the idea of isolates seems pretty complicated https://stackoverflow.com/questions/67041878/how-do-i-embed-...
This is not to say there is nothing one can do with tmux that one cannot also do with screen, or vice versa. There could be. I only opine that tmux is elegant, and more elegant than screen.
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.
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.
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.
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.
Much later, Node added two little abstraction layer over V8's APIs: one that is mostly done in some header files (to deal with the occasional backwards compatibility issue) and another which actually wraps V8; and, even then, AFAIK the latter was mostly done to allow entirely replacing V8 with ChakraCore. But neither of these abstractions are designed to be used by others outside of Node's cosebase (something I almost sort of got working once, but not really): they don't help you embed V8... V8 is already easy to embed.
Notably: V8's embedding API isn't particularly more complicated than the API of any other engine: it is simply more templated. If you sit around with SpiderMonkey, JavaScriptCore, or even DukTape, you will find yourself allocating machines, managing handles, converting strings, and checking types of values. This is of course going to be verbose, in the same way that using JNI to call into Java is verbose, or generally accessing any embedded VM from a language like C/C++ is verbose (and for all the same reasons).
In case someone is wondering how a staid brokerage came up with this incredible technology: the trick is, they didn't.
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.
- 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)
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.
Macromedia Director, it was amazing how quickly you could create an interactive standalone app or CD-ROM.
passwordstore.org
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...
But I’ve never considered it elegant.
https://en.wikipedia.org/wiki/History_of_the_Berkeley_Softwa...
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.
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.
I have set and forgotten it for a few things here and there, like making sure the photos I take on my phone are backed up and available on my laptop as soon as they're on the same network.
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.
Match this, do that.
The first thing that comes to mind as elegant compared to the alternatives is k9s for managing/monitoring kubernetes.
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.
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.
There is a metric ton of elegant games. It's the elegant mundane software that is much more rare and therefore interesting.
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.
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.
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.
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).
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 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...
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.
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.)
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.
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 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.
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.
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.
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.
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.
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'.
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:
Data structures and algorithms that make Lucene & Elasticsearch fast (video):
[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).
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.
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.
It does seem like it'd work without it, since there's commit --amend.
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.
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.
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.
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.
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...
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.
My understanding is that other distributed version control systems, such as Mercurial or Bazaar, take a similar approach to the above.
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.
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.
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.
>>> 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.
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
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.