What's your most unpopular dev opinion?

My programming font. It’s proportional and uppercase letters have a 1/3 of a space of left padding.

Proportional because they are faster to read in general, and the padding makes reading camel-case faster as well.

https://github.com/ericfortis/verdanacamel

Rust has a horrendous developer experience and companies and teams investing in it are making a huge mistake.

Rust doesn't belong in the Linux kernel. eBPF turned Linux into a microkernel. systemd is terrible and bloated. IPv6 addresses are convoluted. Gödel's Incompleteness Theorem proves we'll never have Artificial General Intelligence.

I like Free Software / Open Source but I can't stand the idea of companies using my stuff for parasitic purposes, and I can't believe taking a stance against evil gets projects ostracized from the "freedom" community.

very few of us are engineers or trained to think like one. most of us a tradespeople who know how to make digital things.

as a trade we have gotten lazy and complacent. many of us have figured out how to look the other way while making software that does terrible, terrible things.

we deserve to have our trade destroyed by LLMs.

Software engineers should use formal risk management tools like FMEA (failure mode & effects analysis) like engineers in any other discipline.

That AI is utterly dreadful at coding, and I can't fathom how anyone is getting any productivity gains out of it.

Lisp is a king of PLs, those who do not write in Lisp are just ruining our world because FOSS values are effectively lost if bad guys can use GPL code which becames elusive after compilation. Lisp program which does not share its source code can not share full set of properties which are expected from Lisp code. Some devs really understand how it is inevitable to be fully FOSS for the sake of preventing digital feudalism, but no one claims that all software must be not only FOSS but also written in Lisp.

TypeScript is too much work for not enough reward.

AI and LLMs are really useful tools and engineers need to stop being all-or-nothing with them. They can't write code, they can't design code, but they can be used to make your code or designs better. Some people are turning up their noses on principle and they are missing out on a lot of useful functionality.

Programming is a one-person job.

Most "Software Engineers" AREN'T ACTUALLY ENGINEERS... it's illegal in many states to use that title if you're not licensed with the state's Professional Engineering Board.

If you haven't taken professional engineering exams, and passed, you're not an Engineer.

STOP IT!

I have two and, judging from colleagues’ reactions, I am unsure which is more unpopular.

The font size in my text editor/terminal is 22 pt (I think; it might be 24). I want to avoid eye problems when I am older and I believe avoiding strain on them when I am younger will make that more likely.

My lines of code are no longer than 80 characters because reading vertically is faster and less error-prone than reading horizontally. (100 characters is also acceptable.) This has nothing to do with old software except as far as it introduced the 80-character limit at all. However, it is somewhat related to the font size, given a larger font means fewer characters per line, but they are otherwise independent choices.

The most useful programming language is Bash.

Programming languages (and many other programs) should not insist on using Unicode. Unicode string types (especially as the main string types and character types of the programming language) are harmful more than GOTO is, because GOTO won't affect API calls to libraries, while data types do affect API calls to libraries.

Although many programming languages try to avoid the problems of C programming language, some of these things that they try to avoid are not really so bad, and they often make it worse in other ways, anyways.

Computer programs should not have too many dependencies.

You should not use one character set for everything.

You should not use computers for everything, either.

ASN.1 DER is not a bad file format (and is often better than using other formats; I think DER is generally better than BER and CER, and is also generaly better than JSON and CBOR and others).

I also think that systemd is no good, but many people believe that (although also many people think that systemd is good).

Furthermore, HDMI is no good, and USB is no good, and UEFI is no good, and Unicode is no good.

X.509 client authentication would handle authentication better than 2FA, WebAuthn, OpenID, etc. (It can also be used for authorization as well as authentication, and this authorization can be partially delegated to yourself and/or others, therefore making fine grained personal access tokens unnecessary.)

TLS should not be mandatory for connections that do not require authentication (e.g. read-only access to public data), but TLS should still be allowed for any connections whether or not they require authentication. If you are only using the connection to download a file, and the contents of the file is not changing, then knowing the cryptographic hash of the data will be better than using TLS, although you can do both at once if you want to (these are not mutually exclusive).

For security within a computer, capability based security with proxy capabilities is a good way to do it, at the level of the operating system (rather than within a programming language or in a single program).

Programmers should not only program in modern computers, but should also program in old computers too.

- Code format / conventions should not be customizable

- Commonjs should be actively deprecated

- Dev interviews should have live coding sessions, face to face

Naming things well (and renaming them as new information evolves) is massively important. As important as tests.

Computer Security was solved in the 1970s with Multilevel Secure Systems and Capability Based Security.

Security doesn't require making computers unusable, either.

If we had the collective will, we could eliminate cyber-security as a profession within a decade, as an un-necessary thing of the past.

But... that's not gonna happen.

Well, these should get me in trouble here fairly quickly...

• Modern Java is a good language.

• It's ok not to be polyglot.

• Debugging should not start with the debugger.

• If you can't express yourself clearly you probably can't think clearly.

• HN should support Markdown :)

Some exceptions for all of these, of course.

GenAI should not exist, all development of it should be ceased immediately. Freed time, resources and brainpower should be invested into development of precision tools which do not require boilerplate to be produced at scale.

Developers are terrible at writing software that solve business problems. Developers are better at writing software the solves problems for other developers

Law penalties on spam / scamming should 10x harsher.

We shouldn't only reject bots, we should feed them incorrect information on purpose in order to degrade the systems they are feeding.

rewrite your code every four years

rewrites are worth it

also: functional programming has never really mattered, and will never matter

That's fun. I try to always have at least five unpopular opinions. You never know when unpopular takes can turn into competitive advantage.

Here are some:

1. Pure capability based security doesn't work and such ideas are a dead end. [1]

2. Companies writing eng blogs about trying to to scale Postgres should just rent an Oracle Database instead. [2]

3. There are no approaches to concurrency any better than others. Locks are just as good as actors.

4. Inheritance is a good language feature and languages without it have made a mistake. Exceptions are a great language feature and languages without them have made a big mistake!

5. People should write more desktop apps.

A lot of opinions being posted to this thread are actually quite popular opinions, but I'm sure most/all of the above would be considered obviously stupid by most developers.

[1] https://blog.plan99.net/why-not-capability-languages-a8e6cbd...

[2] https://news.ycombinator.com/item?id=44074506

Flash was an unreasonably effective way to build web apps.

You should be able to prototype with your whole codebase.

Premature optimisations are often fine, actually.

1. People think differently. Some languages suit some people better than they suit other people. The language you're so enthusiastic about, that feels like a revelation to use, is one that fits you. Others don't share your enthusiasm, not because they're dumb, not because they haven't tried, but because the language does not fit them.

2. There is no "best" language for all people or all tasks - not Haskell, not Lisp, not Python.

3. People who answer "what's your most..." with more than one response should learn to count.

Um... oops.

DEI hiring mandates destroy teams.