From: Lucian Mogosanu Date: Sat, 14 May 2016 17:22:03 +0000 (+0300) Subject: posts: 048, 049 X-Git-Tag: v0.9~12 X-Git-Url: https://git.mogosanu.ro/?a=commitdiff_plain;h=931155c35f7e8c1c8d709b4992cc53a5c6ea2223;p=thetarpit.git posts: 048, 049 --- diff --git a/posts/y02/048-slither-io-unfairness.markdown b/posts/y02/048-slither-io-unfairness.markdown new file mode 100644 index 0000000..97a07b1 --- /dev/null +++ b/posts/y02/048-slither-io-unfairness.markdown @@ -0,0 +1,121 @@ +--- +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 diff --git a/posts/y02/049-the-myth-of-software-engineering-ii.markdown b/posts/y02/049-the-myth-of-software-engineering-ii.markdown new file mode 100644 index 0000000..e6777e8 --- /dev/null +++ b/posts/y02/049-the-myth-of-software-engineering-ii.markdown @@ -0,0 +1,152 @@ +--- +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