Ask HN: Which ideological software factions do you know of, and do you like any? | Hacker News Reader

Ask HN: Which ideological software factions do you know of, and do you like any?

28 pointsunix_hacker16 comments

What I specifically mean is a programming community with values that transcend the projects that they maintain. In some cases, these values precede the projects themselves, and the projects are merely a tool for advancing the values.

I use "faction" instead of a "community" because there is an ideological bent to them. It's not merely a community that manages a couple of helpful open source projects.

Here are the ones that I know of:

1. GNU: it advocates for an OS that is libre, and can be studied and modified and shared by anyone. It has idiosyncratic attributes, like the use of Lisp as an extension language.

2. OpenBSD: unlike the FreeBSD community which is largely about FreeBSD, OpenBSD has several different projects that share a core ethos of security and correctness. Some of these projects (like Game of Trees) aren't even officially slated to be part of the OpenBSD distribution. Others (like OpenSSH) are more popular than OpenBSD itself.

3. Suckless.org: it advocates simple, clear, frugal, and elitist software for *nix users. (No really, the website mentions "elitist" on the page for DWM)

4. Cat-v.org continues to advance the Bell Labs vision of a second network-centric iteration of Unix with its 9front distribution and other projects.

5. Smalltalk advocates for programming environments that are discoverable and educational, and various projects like Pharo and The Glamorous Toolkit advance this mission in a variety of ways, sometimes less ideologically strict.

Curious to ask HN what other ideological software factions can they mention? And what do you think of the various factions? Do you identify with any?

Some examples that come to mind:

1. Among long-time Mac users and developers there is a strong sense of what is “Mac-like” based on not just the guidelines set in place by the Macintosh Human Interface Guidelines, but also by prominent examples of well-received Mac software. For example, Microsoft Word 6 for Mac was famously rejected by Mac users in favor of its predecessor, Word 5.1, due to Word 6 not being considered Mac-like while Word 5.1 was upheld as an exemplar of software for the Mac. To this day there are many discussions by long-time Mac users and developers expressing concern about the future of the Mac and whether todays Macs uphold the values they’ve long associated with the Mac.

2. Richard Gabriel’s famous dichotomy between “the New Jersey way” promoted by Bell Labs and Berkeley Unix hackers versus “the right thing” promoted by Lisp hackers from MIT and Stanford/Xerox PARC.

3. The Unix philosophy of small tools that do one thing well that can be combined using pipes and shell scripts.

4. The “move fast and break things” ethos promulgated by Facebook and some other Silicon Valley companies.

Worse is better is interesting.

I prefer a measured pragmatism. Once you adhere to an ideology, you cut yourself off from opportunities and even validity at times. Ideologies are useful as rules-of-thumb, but never as absolutes (because they're made by humans, who are imperfect and exist in a world of imperfection).

Most of these are kind of bad because they get organized around the aesthetics of a particular person or small clique.

Just like how science only progresses one funeral at a time, it is probably the same for software.

That said, I do like some general principles of some communities. My biases are based on my own aesthetics and values.

Arch Linux seems to have the philosophy of staying very close to upstream, and having all the tools be as simple and minimal as possible. This feels like the right approach for a distribution. To ensure everything makes it upstream, and have the packages all work together, and almost strive to make themselves irrelevant.

Their build scripts are very minimalist and clear, and they have done good work on reproducible builds. So the ideology is determinism, minimalism, and no-magic. This jives with my view that software is buggy and error-prone, that it adds attack surface and points of failure. So the goal should be to minimize all of that.

Guix, Nix, and Fedora SilverBlue seem to adopt this kind of strategy and take it even further.

I liked Lennart Poettering's vision for the future of operating systems http://0pointer.de/blog/projects/stateless.html

- vim users who like configuring their vim. goes double for people who like scripting nvim with lua

- python coders who keep trying to add haskell features to python

- phil wang (@lucidrains on github)

- people who have a strong stated preference for toml over yaml

- rustaceans

- julia people

- people who are inexplicably really rude/mean in github issues

- automatic1111 (main creator of stable-diffusion-webui)

- frankly, quite talented, the multiple tf2 hacks devs for ruining all the official servers. was talking to one once and he said he wrote it all in c++, and that he only read from the game process and avoided all protected memory regions

+1 to rustaceans, that’s definitely a cult.

It reminds me when at former company I asked a colleague to write my name in Chinese so that I could join WeChat and… just hang out… because I couldn’t read nor contribute anything.

Thankfully rust has unsafe, so I can write some code.

There is a small community of people interested in formal verification. Unfortunately, it is mostly confined to the academic and research communities, rather than regular software engineers. In part because the tools they use do not have the same level of productivity.

But it seems like one possible next step in programming language evolution. Security and correctness will likely matter more and more.

Productively producing incorrect and insecure code may be less valuable in an age where machine learning and botnets are constantly improving and trying to break into your systems, and where a greater and greater percentage of GDP is dependent upon systems not failing. Increasingly we are building systems where lives are on the line, and failure is not an option.

I would say that this does kind of end up as a bit of an aesthetic divide. Because this is kind of an old school view. There's whole aspects of computing right now that are very trendy which have thrown that old school approach out the window.

The field of machine learning is fine with having systems where they have no real idea of what a system will do, whether that result will for sure be correct, how it came up with a particular result, or reliably being able to reproduce the same result with the same inputs.

They may recognize that those are deficiencies, and be working to improve that, but ultimately their paradigm is inductive and statistical, and thus error-prone by its very nature. They recognize that this is a valuable tradeoff for many applications, and a way to build systems that do interesting things right now.

The "symbolic" AI approach would likely take decades to make visible progress.

What are some entry points for (say) a motivated programmer to the topic of formal verification?

You are on your own mostly. That's part of the problem. I am right there with you in my lack of understood in how best to get started.

The most trendy language on HN (Rust) has an initiative called Prusti, and a working group.

Most of the languages that are used for actual formal verification in industry settings are arcane. Like AdaSPARK.

And then there a lot of academic-focused languages meant mainly to experiment with dependent types or prove math theorems.

TLA+ also has some ability to support it, but not out of the box. DynamoDB at AWS was built with it.

The homepage for it has some approachable resources, but for the language itself. The formal verification systems are separate.

https://lamport.azurewebsites.net/tla/tla.html

Alloy, mostly used for modeling and analysis but see the program verification section about halfway down this very long page:

https://alloytools.org/citations/case-studies.html

Linked at the top of that page is a book about Alloy. There is also a book about TLA, mentioned in another comment here.

Interesting question!

There is a faction that I wish existed: a public domain faction. A group of software devs that are explicitly dedicated to writing code for the public domain and perform grassroots work to abolish (c)opywrong law via a "Freedom to Publish" Amendment:

    Section 1. Article I, Section 8, Clause 8 of this Constitution is hereby repealed.
    Section 2. Congress shall make no law abridging the right of the people to publish or implement ideas.

Does anyone know of any?

What a fantastic question. You've basically just stepped into the realm of anthropology. https://www.goodreads.com/book/show/55711621-anthro-vision

What would be stunning would be like an XKCD-style 'map' of our kinship structures in FOSS.

Here are a few more that I know about:

- Ultra minimalist / embedded crowd - ML crowd (currently ascendant) - Humanist-linguist crowd (think Perl)

I'm part of the faction that knows C strings, null terminated, are insane.

Free Pascal strings, are pure magic. They just work. You don't have to allocate nor free them. They can hold gigabytes.

Java xenophobia and the resulting “write once run anywhere”

I consider myself to be part of the strong type system faction.

Disclaimer: These low-effort ChatGPT summeries, because I'm tired. Almost posted without them, but I think readers will appreciate the context without having to click through. I encourage you to do so if you're interested in the details, particularly for Local-first Software.

1. Handmade Network: Values creating software that works with computers, rather than against them, and prioritizes the needs of the user over those of the programmer. Believes that the current state of software is terrible and that the software development community is responsible for this through thoughtless behavior, such as ignoring hardware and putting their desires above the user's. The Handmade idea is about reinventing wheels, looking under the hood, and building software that is better than what currently exists. They value curiosity and an open mind over formal education or experience.

2. Local-first Software: Values software that prioritizes both collaboration and ownership for users. They argue that cloud apps centralize data storage on servers, which takes away ownership and agency from users. Local-first software, on the other hand, enables users to work offline, collaborate across multiple devices, and have greater control over their data while improving security, privacy, and long-term preservation. Suggests Conflict-free Replicated Data Types (CRDTs) as a potential foundational technology for realizing local-first software, and they have developed prototypes to test the viability of CRDTs in practice.

For my own part, idk, I like Scheme and Smalltalk and the post-RMS GNU foundation projects. Copy-left has been a really fascinating movement that I wouldn't have expected to become as popular as it has. I like the suckless philosophy, but wish they weren't associated with nazis^Wasshats[3] and right-wingers like FRIGN (Laslo Hunhold) and Luke Smith. All the Plan9 and formal verification nerds I've met have been cool folks.

1: https://handmade.network/manifesto

2: https://www.inkandswitch.com/local-first/

3: https://lobste.rs/s/qjuqpi/how_you_respond_security_research...

Reply on news.ycombinator.com