--- /dev/null
+---
+postid: '048'
+title: slither.io, and a few thoughts on the unfairness of nature
+date: May 3, 2016
+author: Lucian Mogoșanu
+tags: gaming, cogitatio
+---
+
+[slither.io][slither] is quite possibly one of the best multiplayer
+games I have had the chance to play in the last months[^1]. Come on,
+give it a try, it's free[^2].
+
+It's a game where you play some sort of worm whose goal is to gather
+small balls which help you grow, where the worm's size is more or less
+the same thing as the score. The best part is however that you get to
+compete with other worms by killing them by getting them to bump into
+you. Once the player does that, he and/or other players may consume the
+dead worm's remains and thus grow eve[rn] larger.
+
+This also makes slither.io a very unfair game[^3], because the beginning
+player, i.e. the small worm, will always share the same arena with the
+big guys, who can (very easily) and *will* consume him if they get the
+chance[^4]. There is no way to escape this simple rule other than
+running like hell, just like in that Pink Floyd song.
+
+And now is the perfect time to give the whole thing a few considerations
+of a more philosophical nature.
+
+One. The game (that is, nature) provides resources for players (that is,
+entities with agency[^5]) to use them to grow. Growing itself is both
+good (as it makes one less fragile) and bad (as it makes one slower, and
+possibly lazier), but regardless, the quantity of resources provided by
+nature is finite, and thus necessarily limited.
+
+Two. Despite the socialist propaganda you may have been fed with in the
+last few decades[^6], within nature there will always be small worms and
+big worms. Never "equal" worms.
+
+Three. All worms are born small. Some may inherit their growth from
+consuming greater dead worms; some will work their way up to becoming
+great; some will die before growing to a satisfactory[^7] level of
+greatness. Regardless, all worms that have been born will at some point
+cease to be.
+
+Four. All worms are born small, but greater than nil. They all bring
+with them a small potential of turning nature's resources into something
+great; however, potential necessarily does not equal achievement.
+
+Five. Working one's ass off to collect resources in order to achieve a
+certain level of greatness is a necessity. Fast slithers in order to
+turn fellow worms into an edible mass of resources is however
+unavoidable at times.
+
+Six. The meek shall inherit nothing, just like in that Frank Zappa
+song[^8].
+
+So remember, nature's unfairness is a good thing, because it might just
+give you that chance to get satisfactorily fat. Or, well, maybe not.
+
+[^1]: From the moment of writing, at least. Who knows, you will have
+ read it years later maybe.
+
+[^2]: Minus the "share on social media" retardation. That aside, it's
+ simple enough to be easily reimplementable by anyone who wishes to
+ do so. This alone makes the concept behind it very valuable,
+ although y'know, it's still more or less "free to play". All that in
+ spite of all the years of "intellectual property" brainwashing
+ Western media's tried to abuse people with. Oh well.
+
+[^3]: Although probably not in any game theoretical sense. The only
+ interesting observation that can be made from this point of view --
+ and I will leave the astute mathematician who reads this essay to
+ verify my statement, if it's even demonstrable -- is that the game
+ doesn't have any sort of equilibria.
+
+[^4]: Just like in real life; who would have thought?!
+
+[^5]: Human or not. To further elaborate on this; a lion may for example
+ have agency in the sense that it can easily wipe out a population of
+ sheeple if left to roam freely through the streets of insert city
+ name here. However, it has the exact opposite of agency when I carry
+ the damned gun. Or, to quote Dreamfall Chapters' Mr. London:
+
+ > A travelling salesman was advertising his wares. He sold weapons
+ > and armour. One day he came to a village where a great soldier
+ > lived.
+ >
+ > "This shield" said the salesman "is so strong that nothing can
+ > pierce it. It will protect a warrior from all harm."
+ >
+ > "This spear" said the salesman "is so sharp that it will pierce
+ > any armour, killing your opponent instantly."
+ >
+ > "How can it be" answered the great soldier "that you have a shield
+ > that cannot be pierced, and a spear that can pierce anything? The
+ > two cannot possibly coexist."
+ >
+ > So the salesman grabbed the shield and the spear. "It doesn't
+ > matter if the two can or can not coexist, motherfucker," he said,
+ > running the great soldier through, killing him.
+ >
+ > "When I'm the one wielding both."
+
+ Do ponder a bit on the above.
+
+[^6]: You "millenial", you.
+
+[^7]: It's up to everyone to define what "satisfactory" means. In fact,
+ if you're wondering why socialism is inherently evil (and doesn't
+ work) is that it fools the poor into believing that being poor is
+ ok. No it's not, not now, not ever, regardless of whether you're
+ exploited by other men or by states.
+
+ But more importantly, no one's ever going to give you anything for
+ free. Everything -- fucking -- costs -- something. Absolutely
+ everything!
+
+[^8]: Here's a [youtube][meek] for the curious reader.
+
+[slither]: http://slither.io/
+[meek]: https://www.youtube.com/watch?v=_M2sX5gwafE
--- /dev/null
+---
+postid: '049'
+title: Further on the myth of "software engineering"
+date: May 14, 2016
+author: Lucian Mogoșanu
+tags: tech
+---
+
+"Software" sucks[^1].
+
+This is a direct consequence of the fact that all physical systems
+suck. Atoms suck, they can be split by nuclear fission. Molecules are
+even more unreliable, as your average joe can destroy them via chemical
+reactions. Living beings die of stuff which we don't even understand
+properly: we all know why kidneys fail, why the heart fails, heck, even
+something in the nature of cancer, but we're scarcely able to provide
+strong solutions for these entirely *systemic* problems.
+
+Agriculture sucks, as crops engineered to feed the masses are infested
+by various little fuckers en masse.
+
+All crafts suck. Even with sophisticated physical models, buildings will
+most certainly fail because of structural degradation. Bridges have been
+a bitch to build from Apollodorus of Damascus to date, and not much has
+changed; spaceships fail more often than they work; your car will run
+into a tree; heck, even your knife doesn't cut that bread the way you'd
+like it to. In short, nature is imperfect, and man-made things even more
+so, and to rub salt in the wound, it takes a shitload of work to make
+all these imperfect things.
+
+Despite the happy unicorns uttered by Western media, computers haven't
+"gotten better" in time[^2]. Even if we were to take just the hardware,
+in time it's gotten bigger in terms of design, more complex and more
+esoteric, so if anything, modern computers suck a lot more than the
+first ones made using integrated circuits[^3]. I won't even bother to
+mention all those (micro)architectural "features" hardware vendors are
+throwing at the market nowadays, each such feature marks another pain in
+the proverbial[^4] ass.
+
+And thus, all software sucks. [It's been said before][cat-v].
+
+I'm not talking about the beautiful, platonic mathematical-logical
+abstractions that some people call software. Those are indeed elegant
+and sound and nice, but they are only so in theory[^5], that is, until
+someone starts implementing them on a physical computing machine. And
+that's not even counting non-deterministic phenomena such as random bit
+flips, just take the inherently unsound hardware-software interface that
+is the instruction set architecture and you have a set of basic
+abstractions that are a hell to build software on.
+
+Since all software sucks, the list of illustrations of how it does is
+too ample to enumerate exhaustively, so we'll just limit ourselves to a
+very few examples, a good one being the Unix-C duo that is still
+haunting the world today. According to its author, Linux is a Unix
+that's not even Unix, while C has spawned dozens of dialects, each one
+more broken than the other, each one in its own way, in the name of
+solving this-problem-or-the-other.
+
+There have been futile attempts to make software not suck, the most
+notable being the so-called "free software" movement started by Richard
+Stallman in the '80s. The core principles of this movement are
+ideological in nature, stating that people should have the freedom to do
+whatever they like with their computers[^6]. From this thus follows that
+people may take their software as it is and try to improve it in an
+[unambiguously useful][myth-i] manner, that is, in a manner more related
+to common sense than to the "cool factor". Why or how this didn't work
+are entirely different stories, but the fact is that nowadays the GNU
+people are consistently failing to adhere to their own principles.
+
+On the other side of the ideological fence are the armies of "rockstar"
+programmers fueled by childish enthusiasm and hired specifically to make
+software suck. This can be grounded on the simple observation that
+Microsoft's latest software, or Google's, or some startup's for that
+matter, isn't getting any simpler. Quite the opposite in fact; any new
+"feature" added in some product only serves, or has the side effect of
+increasing "complexity", which in this case is another word for entropy.
+
+Last but not least, software sucks harder than other engineering
+disciplines because programmers "like to" write code, but very few
+actually read it[^7]. This way, programming is done for the sake of
+programming, not for the sake of making software suck less[^8], and for
+the sake of adding more code instead of adding more simplicity, the
+latter being after all the ultimate sophistication. The world is already
+full of billions of lines of badly written source code, so why do we
+need to write more? Ask yourself this question the next time you sit in
+front of your text editor.
+
+Quite simply put, we can only start discussing software engineering
+after we stop just writing code and start trying to make software suck
+less. This much all other engineering disciplines have figured out[^9].
+
+[^1]: I wanted to make sure that this essay would get rejected from any
+[respectable academic venue][academic-hogwash] out there, so I made the
+abstract as abstract as possible, without however stripping it of its
+essence. What do you mean, that's the definition of an abstract? It
+doesn't even have any obscure technical words!
+
+[^2]: Unless you take "better" in its nowadays' Newspeak meaning, so
+"worse".
+
+[^3]: One might be tempted to say that the vacuum tube ones made back in
+the '40s were better due to the fact that they were simpler. Well,
+actually not necessarily: the first ICs, way before the whole VLSI
+craze, were far simpler and easier to maintain than the tube stuff. So
+*that* was a huge step forward for computer engineering; today's
+so-called advancements not that much.
+
+[^4]: Literal too, given the time most computer people spend sitting on
+their asses.
+
+[^5]: Although the theory itself is rather flimsy, and I'm talking about
+the fundamental theory of computing, not academic hogwash. Bear in mind
+that Turing and Church's thesis is just that, a mere thesis. Also bear
+in mind that via Gödel, the theory of computation has hard limitations
+such as the halting problem, and since Turing few truly relevant
+discoveries have been made in the field.
+
+ So that's like, what? The last seven to eight decades? Not to
+ mention that reasoning and proving facts about computer programs --
+ or rather mathematical-logical models of computer programs -- simply
+ doesn't scale unless you go down the abstraction rabbit hole.
+
+[^6]: In hindsight, the man's ideas were way, way ahead of their time,
+and many of them are still not properly understood by people claiming to
+adhere to "Free Software". Claiming that "open source has taken over the
+world" is very inaccurate, if not downright deceitful, given that a lot
+of today's computers running "open source" are usable only if and how
+some company or other lets them be usable. Not to mention the
+[systemd][systemd] bullshit that's slowly permeating
+[other projects too][ghc].
+
+[^7]: In all honesty, because reading code is damn hard. But you know
+what else is hard? Thinking. So go ahead and read the crap you or others
+have written. Communication is a two-way lane, so learn to talk to your
+computer already.
+
+[^8]: In case you haven't been reading properly up until now, we oughta
+be making software suck less, but not in terms of "code is
+poetry". Sure, code readability is very important, but equally important
+to making software actually work -- in the sense of reliability, not in
+the retarded sense of "please restart your computer".
+
+[^9]: Although some of the "computer science" idiocy is starting to seep
+in there as well. Look at the internet of things, self-driving cars and
+other products of [failed marketing][failure-marketing].
+
+[academic-hogwash]: /posts/y02/045-academic-hogwash.html
+[cat-v]: http://harmful.cat-v.org/software/
+[systemd]: /posts/y01/02b-how-and-why-systemd-has-won.html
+[ghc]: /posts/y02/03e-ghc-teaching.html
+[myth-i]: /posts/y02/03c-the-myth-of-software-engineering.html
+[failure-marketing]: /posts/y02/043-on-the-failure-of-marketing.html
projects / thetarpit.git / commitdiff