RANT.DEV

TypeScript's type system is like a strict parent: always watching, always judging, and never letting you have any fun with any.

If TypeScript was a person, it would be the kid who corrects your grammar mid-sentence while also reorganizing your bookshelf by ISBN.

Why write JavaScript when you can write TypeScript and get twice the errors but in a prettier red color?

TypeScript developers love to argue about types more than actual features. "Should this be a union or an intersection?" echoes in Slack channels everywhere.

TypeScript's strictness is both a blessing and a curse. Like a helicopter parent for your code—you're safe, but also slowly dying inside.

TypeScript developers secretly enjoy the pain of type errors. It's like a badge of honor. "My code is SO type-safe."

Generic types in TypeScript: Because sometimes you need to feel like a wizard, even if no one else can read your spells.

as unknown as SomeType — The TypeScript equivalent of "trust me bro".

TypeScript: Because JavaScript needed a safety net, a helmet, knee pads, and a full lecture on why you should have listened to the compiler.

The feeling when your TypeScript finally compiles with no errors: Better than any drug. Also equally rare.

// @ts-ignore — The universal sign that a developer has given up on life but not quite on the project.

JavaScript was created in 10 days, and boy does it show. It's like a house built over a weekend that somehow became a skyscraper.

undefined is not a function — The JavaScript developer's lullaby. We've all been sung to sleep by this error.

this in JavaScript: The keyword that nobody understands, not even JavaScript itself.

Callback hell, promise hell, async/await hell. JavaScript just keeps finding new ways to make asynchronous code painful.

typeof null === "object". This bug has existed since 1995 and will never be fixed. It's now a "feature".

NaN !== NaN — Not a Number is not equal to itself. JavaScript: Where even identity is an existential question.

JavaScript hoisting: Because who needs their code to execute in the order they wrote it? That's so last century.

== vs ===: The eternal battle. Spoiler: Always use ===. Always. Unless you enjoy chaos.

JavaScript: The only language where adding a number to a string gives you a longer string, and adding a string to an array... still somehow works?

JavaScript prototype chain: Because OOP was too mainstream. Let's make inheritance as confusing as possible!

Python developers pretend they're better than everyone because they use "readable" code. Meanwhile: list(map(lambda x: x**2, filter(lambda x: x%2==0, range(10))))

"Python is slow" — Yes, but at least you can read the code while waiting for it to execute. It's a feature!

Pip install: The command that works perfectly until you need to install something with native dependencies. Then it's a 4-hour nightmare.

Virtual environments: Because Python can't manage its own packages, so you need 47 different ways to isolate them.

The GIL (Global Interpreter Lock): Python's way of saying "you want parallelism? That's cute. No."

Python: Where "import this" gives you The Zen of Python, and then you immediately violate half of it.

requirements.txt vs setup.py vs pyproject.toml vs Pipfile: Python's approach to "one obvious way" to manage dependencies.

"Python is easy to learn" — *Tries to explain decorators, metaclasses, and async/await to a beginner* — "Okay maybe not."

Type hints in Python: "We're not TypeScript, but we want to feel like TypeScript sometimes. Maybe. If you want. It's optional. Sort of."

The borrow checker: Rust's way of saying "you thought you understood memory? That's adorable. Let me explain 47 times why you're wrong."

"Rewrite it in Rust" — The solution to every problem, according to Rust evangelists. Slow website? Rust. Buggy code? Rust. Bad relationship? Believe it or not, Rust.

Lifetimes in Rust: fn foo<'a, 'b: 'a>(x: &'a str, y: &'b str) -> &'a str. Yes, this is considered "readable".

Rust: The language that makes you feel smart when it compiles and stupid when it doesn't. Which is 90% of the time.

unwrap() everywhere: The Rust equivalent of "I promise this won't crash" (narrator: it crashed).

"Zero-cost abstractions" — The cost is just your sanity and the 15 minutes it takes to compile a Hello World.

The Rust community: Incredibly helpful and welcoming. Also, they WILL tell you about Rust. You didn't ask? Doesn't matter. Rust.

Cargo is genuinely amazing though. Finally, a package manager that just works. *Glares at npm and pip*

async fn main() — requires a runtime, but which one? Tokio? async-std? smol? The ecosystem's idea of "stability".

if err != nil — The Go programmer's cardio. Write it 500 times a day, every day, forever.

Go's simplicity: "We don't need map, filter, or reduce. Just write a for loop." *Writes the same for loop 200 times*

Go's mascot is a gopher. This is the most personality the language has ever shown.

Unused imports and variables are errors in Go. Not warnings. Errors. Because Go doesn't trust you to clean up after yourself.

Go modules: Three different dependency systems later, we finally have something that mostly works. Progress!

interface{} — Go's version of any. "We have type safety!" *Immediately casts everything to interface{}*

No ternary operator in Go because "it's too confusing." But implicit interface implementation? Totally intuitive!

Go: Fast to compile, fast to run, fast to write. Slow to add features that other languages had in 1995.

The zero value of a boolean is false, of an int is 0, and of a Go developer's expectations is also zero.

"Write once, run anywhere" — and debug everywhere, because every JVM is slightly different.

Java boilerplate: public static void main(String[] args) just to print "Hello World". Python laughs in print("Hello").

NullPointerException: The national anthem of Java developers. We've all heard it. We've all sung it.

Checked exceptions: Java's way of saying "I don't trust you to handle errors, so I'll force you to." *Developers add empty catch blocks*

Getters and setters: Because directly accessing fields is too simple. Let's add 200 lines of boilerplate instead.

Java's generics: Type erasure means the types are gone at runtime anyway. But hey, at least the compiler is happy!

.equals() vs ==: The interview question that has eliminated more candidates than any technical challenge.

Maven vs Gradle: The eternal war. XML vs Groovy/Kotlin. Both are painful in their own special ways.

Oracle's Java licensing: The plot twist that made everyone suddenly interested in OpenJDK.

"Convention over configuration" — Until you need to do anything the Rails way didn't anticipate. Then it's configuration over sanity.

Rails: Where rails generate scaffold makes you feel like a 10x developer with 1x understanding of what just happened.

"I don't need to learn SQL, Rails migrations do it for me!" — Famous last words before the N+1 query apocalypse.

RubyGems: Where version conflicts are a daily adventure and bundle install is a prayer to the dependency gods.

ActiveRecord magic: has_many :problems, through: :metaprogramming

DHH energy: Writing an entire framework in a weekend and telling everyone about it for the next 20 years.

The Rails enthusiast: "Testing? Isn't that what the community is for?"

At least PHP and TypeScript developers can agree on one thing: Rails devs won't stop telling you how fast they built their last CRUD app.

Ruby blocks, procs, and lambdas: Three ways to do the same thing, but all slightly different. Just Ruby things.

Segmentation fault (core dumped) — The C++ way of saying "something went wrong, but I won't tell you what or where."

Template metaprogramming: Making your compile times longer than your runtime since 1998.

C++11, C++14, C++17, C++20, C++23: The language that never stops evolving because the previous versions were never quite finished.

Memory management in C++: new, delete, smart pointers, and eternal vigilance. Miss one and leak memory forever.

std::vector<std::pair<std::string, std::map<int, std::shared_ptr<Something>>>> — "Readable" C++ code.

Header files and source files: Because why have one file when you can have two that must be kept in sync forever?

CMake: The build system that's so complex, it has its own domain-specific language. For configuring builds. Of your simple project.

C++ exceptions: "Let's add Java-style exceptions to a language with manual memory management. What could go wrong?"

The Rule of Three, Five, or Zero: C++ special member functions—simple! *Writes 500 lines of boilerplate*