Code Discordianism

Welcome to the. Place. Where I try to. Conjure. Up a software engineering principle. That's inherently anti-clean by accepting and internalizing the. Omnipresent chaos.
Of the universe fnord and as. A result of this crazy. Show of nothing. But jokes and metajokes and. All kinds of random stuff that is related. (Or not; i don't actually care too much about.
The accuracy and stuff.) to discordianism or. Things that are not discordianism but you know what. I forgot what. I was. Going to write. After I've decided to do this π bullshit.
So just wing it. You got nothing to lose or. Gain anyway.

The hell's a Discordianism??

_Read ^this. (← this is a link! it won't bite you so feel free to click!!)

And the hell's your principle??

^Read _below.

Principle... on writing code

• Just. (read: Hail)
• Write. (read: Eris)
• The. (read: All)
• Damn. (read: Hail)
• Thing. (read: Discordia)

• It's called the Law of Fives in Discordianism, not the Law of Fours, so the "4-lines-or-less" thing is not valid here.
• Seriously, you fvckers try doing anything meaningful in less-than-4-line functions without regressing into some insanity of fragmentation, I double - no, π-ple dare you.
• Also, next time try not to trust anyone with an ego big enough to blatantly use a "certified clean code" thingy as their social media account icon, okay? Try to trust your gut feeling more often, because your gut is smart enough to let you know when it's hungry and requires more input, but your brain is not smart enough to warn you when you're being jebaited. (?)

• Ask yourself. What makes you so afraid of throwing away code?
• Also, have you ever thought about this: that the act of coding itself is also a form of thinking and designing (or at least accompanied by thinking and designing), so you've done the thinking and designing anyway and throwing away code isn't actually as much waste as you would think?

• What readability? You're solving similar problems, you're similar beings (in the sense of you both are humans), you share similar backgrounds (in the sense of you both learned similar things), it's only natural that you think similarly and only the minutiae is different, and the code should be similarly readable. Yes, people could write extremely wrong code, but almost all of those cases are design problems, not code readability problems.
• I have never seen a shit codebase that's neither degraded because of old age (?) nor disfigured by someone following some rigid principles like a satanic ritual. Natural intent rarely fvcks things up, it's almost always the unnatural intent that does. You see, nature truly is one true way of human enlightenment. (this is not an endorsement of organic and/or non-GM foods.)
• I never understood this thing where people claimed that your code should read like a story (out of all the things it could have been, like for example an assembling manual for a piece of IKEA furniture - a story!) as if it's totally sane to believe that the pattern on a newly-made ball of yarn should somehow reflect the pattern on your hand-knitted pullover.

Principle... on *trust*

• Trust words written, not words spoken. If it isn't on paper (or whatever the thing you see and read with your eyes), it doesn't exist. (So write your documentation lads!)
• Only trust yourself, don't trust anyone else.
• You know what?
• Don't even trust yourself.
• Trust God instead (or whatever higher being that you believe in).

(this is bad. i'm running out of jokes (jokes? ^{are you sure those are jokes? as in they're supposed to be actually funny?}) and shock-inducing gimmicks. welp, let's see what i can come up with...)

Fnord. Fnord. Fnord. Fnord. Fnord.
[You can't just repeat the word "fnord" five times and call that a Discordian joke mate, it doesn't work that way. -- K]
Screw you, this is my place, and I will fnord whatever I wanna fnord. -- SRH

Principle... on attitude when dealing with existing code

• Your code is shit.
• Everyone else's code is also shit.
• Don't look at me, my code is shit too.
• Does the code do what you have intended? If yes, then it at least has a chance to be called "good" code; non-working code is out of the discussion at any time of the day.
• If you feel there's some kind of mystical energy piling up in the codebase, then it's probably at the best quality it ever will be and it's all downhill from here.

• Sometimes a re-design is needed instead of refactoring. Sometimes a codebase looks bad because someone was trying to refactor their way out of a design problem; those attempts almost never have a good ending, so try to avoid that. I know it involves throwing away working code, but sometimes you need to do it.

Someone (that doesn't exist (but probably will after I made this webpage available to the public)): Your opinion is shit because it doesn't scale.
Me:

• At least I'm willing to admit it if my opinion won't scale up; those software aRcHiTeCtS high up in the sky won't be as friendly as yours truly when you told them their opinion won't scale down.
• Also- "scale" you say? Do I look like lizard people to you? (Haha get it? Because it's "scale" as in scales on the skin of fishes and reptiles. Yeah okay I know it's not funny shut up)

Enough of this bullshit, can you actually be serious for once??

No, because this isn't Clean Code or Agile or whatever, this is not written so that newly-minted developers could dogmatically follow, this is not written so that those first-world dwelling "tech" hipster fvcks could diarrhea out a truck load of shitty turtorials so that the former group of unassuming fools could pay their unassuming $5 or whatever price a month for a fvcking subscription, this is written as a joke, it was meant to agitate your brain so that you could think for yourself for once. Guys - I have no intention to become a snake oil merchant. I have no snakes, I don't breed snakes, and I don't plan on making oil out of snakes. Please don't accuse me of something I'm not doing.

Alright alright, here's the serious version if you want a serious version of an inherently not-so-serious thing...

• Intent-oriented action: whatever you do should reflect your intent (or motive, or whichever word that's applicable under concerned context). Just like magick (yes that's the correct spelling for the supernatural kind of magic), you have to put in your intention for it to actually work. Try to prevent anything that doesn't serve your intent. 2024.1.5 Addendum: Remember: Anything that does not directly serve your intent is a compromise, and a good part of compromises are bullshit.
• Re-design over refactor: what's the difference? Refactor is solely a code thing, while re-design is a mental process that acts upon concepts and it could be carried out as a refactoring, a rewriting or something else. Or to put it this way: re-design is re-thinking, while refactor is re-doing. Way too many people confuse these two way too often, and there's way too little re-thinking being done in everywhere.
• Intent-artifact counterposition: no matter what you do, you must know there's a difference between these two and methods & solutions for one realm cannot be expected (as in "you cannot rely on the fact that it is true and proven") to work in the other realm. Some people say that if your code is somehow "good enough" you don't need to write documentation; this is wrong because code is artifact and artifact is not guaranteed to (and often doesn't) reflect the intent. Do not trust these people. Remember: design is intent but code is artifact (UML is also artifact no matter what the UML apologists say), specification is intent but tests are artifacts.

These three are the absolute basics that all self-proclaimed Code Discordianism practitioners should adhere to. There are also some other principles that, while being enlightening (in my opinion), aren't necessarily as important as the ones listed above.

Think metaphysically, ^{m y f r i e n d ~}