Day Summary

Rant Alert, sleep deprived and hangry, you have been warned :D

Right, so what we got today? Pretty shitty sleep for one. Concentration was shot. I tried to counteract with a couple energy drinks, but the effect was limited. Still got some work done for the job today. I also got an hour of work in for my Daily Quest before the job. Set an appointment for tomorrow with a moving company to fetch my washing machine, desk, and the last box that’s still left in the old apartment. Project progress: twelve pages, one hour.

The cadence I’m going through the chapters with is definitely faster, but it comes at the cost of coding time. I haven’t touched Rust practice for a few days now. My thought is once I hit 300 pages, I’ll start a practice project of real complexity, which will force me to revisit everything I’ve read. That’s not the worst way — I prime myself by extracting notes from the LLM, then I read the pages, and the actual learning happens when I code.

One thing that has crystallized is that I’m pragmatic to the core. Interfaces, abstract base classes, and OOP in general don’t serve much purpose beyond preference in most cases. You building a chain of inheritance to keep each childclass small only obfuscates the fact that you are building a "godclass" - it becomes quite apparent once you want to know what parameters are possible to be used and find 20+ total after adding up all from each inheritance. (a good bit above the recommended 3 ;D)

People often apply OOP styles to problems that don’t require them. The real case where OOP makes sense is when you need some kind of state localized/shared/reused between multiple logical units inside a class, so you don’t have to keep recreating it or passing it along function chains.
Basically classes should only be used if we want to tie together specific data and logic. Beyond that, classes are just grouping mechanisms, and grouping can be done just as well with functions and files.

Inheritance sounds nice, but in practice it fragments code. Abstract base classes enforce contracts, but beyond that I don’t see much value. I keep running into traits and generics and thinking: you introduced a problem by strictly enforcing types, and now you patch it with a hack. Generics are basically placeholders for types that the compiler expands into concrete code — just automated copy-paste. Traits are interfaces by another name - plugin-style.

Polymorphism is, in my opinion, one of the worst ideas. It leads to inheritance chains where any child can override the parents behavior, and you have to trace class after class just to figure out where something is defined. Annoying, not impossible, but far from clean. Monomorphism is advertised as “zero cost at runtime,” but really it just shifts the cost to compile time, because the compiler has to copy-paste the code for each type. “Zero cost” is a joke because strict types created the duplication in the first place and the cost is either developer time typing out the duplicate code or compiler time creating copies from your template and filling them in. "zero cost during runtime" indeed, it's like selling "rehydrating water" a weird marketing speak to inflate something that is simply normal to something "noteworthy" in the eyes of the uninitiated.

Rust is fast and memory-safe, but some of its design choices feel like lazy copy-paste from C and C++ rather than thoughtful language design. The hype has already started to move toward Zig. Rust does have readability wins in some areas, but then introduces overly complicated ways of doing the same thing. I’m pretty sure I won’t have to touch most of these concepts for my current project — it’s too small to need heavy abstraction and more than basic module/enum/struct level grouping. Anything else just bloats the code.

Well that is my rant for the day. In short - The rust book is introducing more abstract programming concepts rather than actual Rust Syntax. It's more of a tutorial to interfaces and deduplication as well as indoctrination with whatever the creator believes to be good style rather than actual "this is how rust can be used". More often than not it will be "this is how you can solve a problem that rust introduced via its own designchoices" rather than "this is how you can solve your real world problems using rust". You still see how rust is used but it's more as illustration for the concepts that are actually taught, not that you are taught rust syntax and happen to learn that this is OOP in Rust :D

To be fair for a complete beginner the official Rust book is a very comprehensive and holistic work and it does have a more structured approach than many high profile books trying to teach these I have seen before, take my praise for that one :D, but as for my personal usecase "fast rampup in rust as someone already knowing other languages and wanting an introduction to rust, not OOP" it is a bit longwinded in some places.

• Daily Quest: 60 minutes (shortened under tired protocol).
• Reading: 60m, +12 pages (p.248 → p.260).
• Coding: none.
• Cadence: not given.
• Protocols: Tired protocol active. Aim = protect sleep tonight.
• Side quest: plan for fresh air + caffeine before job work.

Context

Only ~6h of poor-quality sleep (little deep/REM), so energy was low. Adjusted by halving the usual focus block to avoid overexertion. Day kept at ~50% pace to preserve recovery.

Reading

• p.248 → p.260 (+12 pages), ~60m.
• Solid progress despite reduced session length.
• Blog post deferred for later.

Coding Practice

• None today.

Reflection

Not much energy, but still showed up and logged a clean hour of reading. Chose discipline without overextending. Priority now is recovery and consistent sleep.

Key Learning

• Even on bad sleep days, the tired protocol keeps progress alive without digging a deeper hole.
• Steady pacing > forcing max output when the body is off.

Total Time Spent

• Reading: 60m
• Coding: 0m
• Daily total: 60 m

PCT (Project Cumulative Time): 27h29m + 1h = 28h29m