II. Solve problems instead of creating them

    We want to solve concrete problems, not anticipate the tasks
    others might have in the future, so we create applications
    instead of frameworks. We write editors, not text-editing

Me: zooms in so I can read the tiny ascii webpage

    II. Solve problems instead of creating them

    We want to solve concrete problems, not anticipate the
    tasks
    others might have in the future, so we create
    applications
    instead of frameworks. We write editors, not
    text-editing

Brutalism 0, Problems 1

> IV. Do everything yourself

This is not very brutalist, considering that brutalist architecture would never exist if it followed this rule.

> VIII. Avoid all ornaments

How about: "don't hide the way you made it"? Brutalist buildings often have the look of bare concrete and metal because they are not trying to hide the way they were built. This would mean disclosing sources and tools, making buttons look like buttons, showing the actual errors, shaping the UI to reflect the underlying process or model rather than trying to abstract it.

This is a mix of amazing and really bad advice. And the problem with it is that it is a series of advices / philosophy instead of explanation.

Reading the original Rise of Worse is better article ( https://www.jwz.org/doc/worse-is-better.html ) gave me a huge appreciation of programming implementariin simplicity, and improved my pace of coding a lot. It shows a real example of why C won over Lisp (a much cleaner interface) 50 years ago.

The funny part is that right now I'm programming in something that may be closer to Lisp (Python), but happy to rewrite parts of it in C in the future when it gets practical.

The amount of features I can add in a small time just because I always pick the smaller implementation surface (while still moving forward) is amazing.

Regarding dependencies: I may want to move to lower level libraries in the future when my project is in a more advanced state, but again they are great as training wheels (lower level would help with customization, but I'm waiting until I _need_ it).

This can be read to support just any position about programming for which you want to advocate. It's not even internally consistent.

> We do not use libraries

seems a definitive position at least, whether one agrees or not

> If you need additional libraries ...

Hold on, I thought we weren't using libraries. Shrug.

The whole piece is plagued with dissonant inconsistencies like that.

Seriously, don't wrap with line breaks, whether it's a git commit message or a freaking blog post.

I find appropriations of the term "brutalist" strange in software contexts. In the architectural sense of brutalism wouldn't it mean limiting software construction to a single material (type,class,whatever) and leveraging that limitation to enhance other parts of the design (flow, modularity). In this way I think shell scripts are the most brutalist way of programming, ironically the author would probably agree.

> We never take a software methodology, school of programming or some random internet dude's "manifesto" at face value. Rules must be broken, when necessary.

In this specific case it seems particularly necessary. I don't think I will take this manifesto at face value.

No mention of coupling or cohesion: https://www.geeksforgeeks.org/software-engineering-coupling-...

Anyone who has to put up with Brutalist architecture in London (Hayward Gallery for example, or the NT, but there are many, many others) may think that being brutal to Brutalists is the only answer.

As someone who strives for simplicity, some things from this resonate with me, but there are many others that are just bad advice or wishful thinking.

> Solve problems instead of creating them

Whenever you write code, you inherently create problems. For every line of code you write to solve any problem, you create bugs, technical debt and maintenance problems for someone in the future. The only way to not create problems is to not write code, and therein lies the challenge.

> Do everything yourself

Yeah... no. A modern developer relies on _mountains_ of code just to use an editor. Will you write your own editor, networking stack, kernel, firmware and OS as well? If the answer is "no", take the same approach with the software you write. Don't liberally import any dependency you find, and certainly try to reduce the amount of 3rd party code that you use, but also be pragmatic and don't reinvent the wheel if there's a perfectly good one someone else built for you. The best you can do is take a glance at how it was built, and try to follow and understand updates when they happen, but this DIY/NIH obsession is ludicrous.

> Code that we didn't write we do not understand.

Have you tried reading it?

> Avoid all ornaments. We eschew all visual gimmicks, animations and eye-candy.

Awful advice. Good UIs are accessible and enjoyable to use. Just because you prefer your UIs to be spartan, doesn't mean your users will as well. You are building software for other people, right? If anything, make your software configurable so that your users have the option of configuring it to their needs and preferences.

> Do not listen to others. We never take a software methodology, school of programming or some random internet dude's "manifesto" at face value.

I will gladly disregard this "manifesto" as well then. :)

Also, the least you could do is use a spellchecker for such an enlightening document, or maybe write your own?

- "we often evade our responsibilty"

- "True mastery transcendends"

- "Forcing others do upgrade"

If I'm so brutal and don't give a damn why do I care if I use every library under the sun? Simple you say? Then I'm rewriting code some other poor sods have written 100 times, which sounds a lot like not-invented-here ornamentation to me.

They should rename this screed Arrogant Programming :P

> We eschew all visual gimmicks, animations and eye-candy.

Restructuring text to fixed length is eye-candy, and one that causes problems (e.g. when zooming in). A less ornamental approach would be to serve free flowing text and let the user adjust the browser window to their preference. Better yet, return semantic html as opposed to a single pre block.

An alternative brutalist website template, one that promotes semantic html, is: https://motherfuckingwebsite.com

Cool, so this is nonsense through and through. These are either obvious or downright weapons grade idiotic:

1: Simplicity is better than complexity all things being equal. Guess how often that happens. (Hint: for any non-trivial problem it doesn't.)

2: Yes, it's better to solve problems than to create them. Also water is wet.

3: Spoken like someone who wouldn't recognize true mastery if it bit them on their bony behind.

4: Yeah design your own CPU while you are at it.

5: Just... no.

6: You can certainly make computing less secure though. By doing everything yourself for example.

7: Cool. And nobody except people who have a keyboard and a mouse will every use whatever shit you produce.

8: Welcome to North Korea. I'll stick to juicing things up and making sure people have a great experience.

9: Cool. Tools are tools. Whoever wrote this is a tool too.

10: Ok humblebrag Inc.

11: Wow. Really?

12: Cool. This is really a special kind of weapons grade stupid.