Have you ever encountered the travesty that is Object Pascal aka Delphi?

oh boy it’s time to play how fucked up is this programming language going to be (god damn it)

pascal is a bad language and was the java of yesteryear. it was the first in a long line of languages born out of the same premise: “i don’t fucking understand what the fuck a pointer is, god damnit what does the * do this is stupid”

it’s sort of famous for being a cop-out language

i have no idea what the hell ‘object pascal’ is but i can only assume it’s an even stupider, baby’d dialect of pascal. anyway, ITS TIME TO PLAY


model: compiled to machine code – well, at least they got this right. i would bet money this was because it was written in the 80s and they didn’t have the performance to make it anything stupider, so you can’t really give em credit


type tangibility: static AND dynamic – ??? why do people think this is a good idea? “we don’t know exactly what makes a programming language good, so we’re going to give it every possibility so that nobody can ever know what’s going on”.

there are two ways to handle typing. you either have static types (sane, good) or you have dynamic types (stupid, bad). people will try and convince you the difference between static & dynamic types is not a clear line in the sand, and there’s a ‘fuzziness’ in modeling types, but they are lying to you. either every type has a unique identifier, fixed size, and is absolutely discrete (which causes the absolutely positive side effect of every variable needing a type described at compile time), or they don’t. in the case they don’t (dynamic typing), your language now has to define an entirely new model describing how your “types” (which could be of any size, of any class; could be discrete values or containers like arrays OR abstract containers like tuples) interact with each other. this is an enormously complicated endeavor which will certainly increase the scope of your language by orders of magnitude.

for the sake of discussion, let’s say static typing has a complexity of 10 and dynamic typing has a complexity of 100. it’d be cool if they just made it a dynamic language, but they had to go ape and make it both. you’d think that would result in a complexity 110 (10 + 100), but now you have to define how static types interact with dynamic types. i’d argue that the complexity now becomes 1000 (10 * 100)


type interaction & safety: strong, safe – these are good choices, but don’t be fooled! they mean nothing in the context of a dynamically-typed language where types are already gooey and ineffable to begin with. just like you can’t use reinforced steel rivets to hold together a house made of wet cardboard, you aren’t really doing much by enforcing the correct use of types when “types” no longer have any reliable meaning, definition or even rules stating what the “correct” handling of them is. at best, this makes the compiler force you into writing code that at least has some semblance of direction or sanity within the scope of the already-insane and error-prone type system. your code now runs a little tiny bit longer before hitting a runtime exception and blowing up.

p.s.: when you’re writing a statically-typed language, having strong, safe types actually means something & is infinitely better than loose types which i won’t even begin to get into here


paradigms: (oh god here we go)

imperative - nothing to say here, exactly what you’d expect. not really good nor bad, i guess i can give them a little credit for being consistent in their attempted goal of having an easy programming language and not trying to make this mess a functional PL too

object oriented - jesus christ god in heaven i hate OOP so much. pascal was bad enough as it is, but to make it object-oriented is like diarrhea icing on a shit cake. now, our already way-too-overcomplicated model has to fit within ANOTHER overcomplicated model where you can’t just write code anymore, you have to shoehorn your code into a “class”, destroying any sense of organization you had before and forcing you to a dumbed downed schema composed of “objects” born from classes (don’t confuse these with actual objects, which are product of assemblers and the input for linkers) and strung together with whatever whacky inheritance system you decided to use, as well as “interfaces” and “abstract classes”. discussing what makes OOP so bad is worthy of its own wall of text someone should ask me about later when my blood pressure has had a chance to settle

functional - oh wait i was wrong! they made it functional too! remember what i said about how dynamic typing was bad enough, but mixing static & dynamic typing disciplines together amplified that mistake substantially? mixing imperative & functional programming models follows the same effect in a much more complicated way. again, blood pressure, not getting into this one

event-driven - oh boy! now you can’t even write clear code anymore. they decided to preempt the javascript nightmare we have today by a handful of decades and now you can’t even expect your code to execute sequentially, you have to string a 40 line web of callback functions to handle case that could have been handled with a god damn semicolon. and for what benefit? slower code. lose-lose

component-based: - you can ignore this one, it doesn’t mean anything

generics: this is why you eschewed using a sane typing system, so that you could, in some cases, write generic functions. generic functions aren’t actually the worst thing in the world, but they’re not worth the bloodshed it takes to get to them.


thank you for your question. i am going to go put some dents in my wall and make an appointment with a therapist now.