It's weird how smart people are naturally attracted to complexity like moth to a flame. It takes years to learn to fight the urge to over-engineer.

Once you learn to see it though, it's hard to ignore. Now I can tell instantly if code is over-engineered. Unfortunately It seems like maybe 99% of code is over-engineered. The developer's incentive to maximize their own lock-in factor and billable hours are powerful forces. Even developers who appear to be totally robotic and ego-less are often guilty of over-engineering. It works on the subconscious mind. Few are ever able to escape the mindset because they are not fully conscious. They are not thinking about every single line of code that they write. They decide on some goal and then churn out whatever code first pops into their heads to get incrementally closer to that goal... Not realising that, at each step, there were many alternative paths that which were superior.

I love this site, always get a laugh out of it. My absolute favorite:

Microservices

grug wonder why big brain take hardest problem, factoring system correctly, and introduce network call too

seem very confusing to grug

I have a beef with the typing section:

> grug very like type systems make programming easier. for grug, type systems most value when grug hit dot on keyboard and list of things grug can do pop up magic. this 90% of value of type system or more to grug

Juniors at my job routinely ship code that breaks due to null access in production, Sentry tells me. During intensive development periods that's about 1 detected null-access bug per day per junior developer.

Using a proper type system with static checks would probably help immensely by pointing out "Hey, this can be null. You sure?" in their IDEs...

Also, you can have completion even without static typing.

> big brain type system shaman often say type correctness main point type system, but grug note some big brain type system shaman not often ship code. grug suppose code never shipped is correct, in some sense, but not really what grug mean when say correct

That's just rude and uncalled for.

I have shipped code mainly in in C, PHP, Python, Haskell and typed Python. The incidence of bugs that make it into production is much lower with typed languages. That's one reason to like it.

It also makes refactoring much, much easier. I can check whole code base for broken callers when I change something widely used and get reliable results in seconds. That helps immensely with iterating on a growing code base.

OK I reckon everyone is going to get on the HTMX wagon over the course of the next few months, and it's going to blow a ton of young minds and save a huge amount of global energy and make a lot of people very happy. And then these same inquisitive young people are going to click enough links on htmx.org that they stumble across hyperscript and it's gonna be like that moment in Dusk till Dawn where the vampires come out

I've been a developer for 30 years, and I'll admit that in my early days, I was arrogant and thought I was smarter than everyone else. I'd describe myself back then as one of those "big-brains" loving all the complexity demons.

10 years later, and I've shifted more towards being a "Grug brain" developer. Now, I focus on the simplest solution that could possibly work, knowing that it's probably not perfect. But that's okay, because it gets me closer to what is correct, allowing for iteration.

The best thing you can do as a developer is to delete code! Right now, we have a requirement that we've been living with for two years that suddenly isn't a requirement anymore. I can't tell you how excited I am to go through and rip out a whole bunch of code, because it makes everything simpler.

Grug came up a week ago in a Philosophy of Software Design submission's comments. I thought the commentary was pretty good. https://news.ycombinator.com/item?id=38011938

> I feel the exact same about grug. I don't think people actually agree on what's simple, so it's pretentious to pretend your "simple" is the obvious one that a caveman would agree with.

Simple/simplicity is often one of the most complex things to discover. I see a lot of people resolute & certain that everything around them (except what they do) is complex & needs to be bent into simplicity. It feels dangerously weak & clutching after authority.

I've operated by and described the concept of Chesterton's Fence countless times, so that's a great name to learn. It's such a regular thing working with new grads, etc. that they see some "old legacy crap" and their first reaction is to want to tear it out or scrap the whole thing start over.

On some occasions it can be worth the lesson to let them try but it's a good thing to remember that the people who came before us weren't all complete idiots and there is generally a reason why they did what they did.

Sometimes it is gross old code that needs to be replaced, but even then it often still contains a hard fought record of all of the corners and edge cases you need to understand and handle to build anything in that domain.

I love the section on tests. It really is exactly what I've come to learn over the years. Integration tests are the sweet spot for finding bugs. Mocks tend to over complicate things (I still use them sometimes but I avoid using them systematically) and unit tests are too brittle in face of refactoring whereas integration tests help with refactoring.

> Complexity very very bad.

> best weapon against complexity spirit demon is magic word: "no"

> sad but true: learn "yes" then learn blame other grugs when fail, ideal career advice

Complex wisdom from grug.

Discussed at the time:

The Grug Brained Developer - https://news.ycombinator.com/item?id=31840331 - June 2022 (374 comments)

Everyone's blub paradoxed about simple.

Anything below your chosen level of simplicity has no features.

Anything above is too complex.

You are at the true simplicity optimum. Your manager is the one who doesn't get it. Terrible guy. Understands nothing. Unlike you, true artist, pure simplicity.

Grug Inc. -- Fantastic! I really enjoyed reading this and feel like im guilty of unleashing the complexity spirit demon, even though im not even a big brain. Out of curiosity, are there any programming languages that naturally steer people away from complexity? but still "get the job done".

This piece reflects some of the most frustrating professional interactions I’ve ever had where people insist that something is too complicated with no concrete suggestions for simplification.

"danger abstraction too high, big brain type system code become astral projection of platonic generic turing model of computation into code base"

Who wrote that? I want to know! I need to know! I need to follow him/her on Twitter, LinkedIn, GitHub, Whatever, ... I need to work with him/her, it's my doppelganger!

> limit damage of big brain developer early in project by giving them thing like UML diagram

Ah so this is the purpose of UML!

If you need nuanced behavior, you need a complex controller. And you always need more nuanced behavior, this is the inherent nature of software development. Sometimes the appearance of simplicity is achieved by making the behavior simpler (e.g. dropping the support for old versions, not implementing parts of the specification, and so on). This is degradation, not simplicity. The right simplicity is an art of having the required complexity yet somehow manage it internally. So complexity is not bad. It is given. What is deficient is our skill.

ok. so grug make good, good point. many good point.

now say others no listen and do opposite of what grug say for month after month. code complex. code very complex

what grug do now

A lot resonates with this, particularly factoring code and carving out barriers later on when the project has settled.

I believe there are some antipatterns like singletons and globals that on the surface look grug-brained but are actually complexity multipliers.

I read it in this voice.

https://youtu.be/v79fYnuVzdI?si=2iEdgEgx3Q-7RyI_

(Zathras Wrong Tool)

I enjoyed "black think juice".

> but grug must to grug be true

Incredible essay. Very funny and very wise.

>sad but true: learn "yes" then learn blame other grugs when fail, ideal career advice

grug speak only true

OK, this was better than expected.

very hard to read, but worth it

Grug took their muse too far. Had much hard time try parse meaning from grug.

This is just the best. I’m gonna force this on you ger colleagues.

Thankfully ChatGPT can translate this into readable English.

This is my favourite read this year I think :D

Nice to see this pop up again. Grug life!!