"Static methods are as big a mistake in OOP languages as NULL, or maybe even bigger. Static methods should never have been present in Java and all the other OOP languages in the first place, but they are there. We shouldn't have to know about such things as static keywords in Java, but alas, we have them. I don't know who exactly authored them in OOP, but they are pure evil. The static methods, not the authors. I hope." โ Elegant Objects, Volume 1 (2016)
๐๐๐ฒ๐ฟ๐ ๐ฒ๐ป๐ด๐ถ๐ป๐ฒ๐ฒ๐ฟ ๐น๐ฒ๐ฎ๐ฟ๐ป๐ ๐๐ผ ๐ฑ๐ฒ๐ฏ๐๐ด ๐ฐ๐ผ๐ฑ๐ฒ, ๐ฏ๐๐ ๐ฎ๐น๐บ๐ผ๐๐ ๐ป๐ผ ๐ผ๐ป๐ฒ ๐ธ๐ป๐ผ๐๐ ๐ต๐ผ๐ ๐๐ผ ๐ฑ๐ฒ๐ฏ๐๐ด ๐๐ต๐ฒ๐บ๐๐ฒ๐น๐๐ฒ๐
There is one trait every superintelligent person has: metacognition. It's just noticing your own thinking as it happens. You catch the thought instead of getting carried off by it.
The time flows, and you just go with it. Sometimes, you get defensive in a code review before the comment has even landed. Sometimes you're three hours into a bug, and something in you refuses to walk away from it. Someone floats an idea in a meeting, and you've shot it down before they finish the sentence.
None of that is a decision. It's a reaction that fired before you looked at it.
The whole skill is catching it while it's still firing. The second you think "wait, why did I react like that?", something shifts. You're not running the reaction anymore. You're watching it run.
That little bit of distance is everything you get to work with. It's the space between doing the thing on reflex and actually choosing to do it.
I've been building software and leading teams for 20+ years. The people who kept growing weren't the most talented ones. They were the ones who could catch their own patterns in the act, which is the only reason they could change them.
You do this for systems every day. Try turning it on yourself.
One good exercise is to practice meditation, 5-10 minutes every day. This can significantly improve your metacognitive skills. Also, try to have weekly reflection sessions. I do this every Friday at 17h, where I try to understand what I did during the week and what I can improve.
#SoftwareEngineering #Leadership #CareerGrowth #TechWorldWithMilan
Software is pure โthought stuffโ. One person can write code and billions can run it. If anything, our linear time produces exponential value.
Therefore, Iโve never personally believed that developer time is expensive, that we have a โtypingโ problem. Or that English is somehow a better way to express code than a language as explicit as Zig.
Granted, thereโs tons of (non valuable) bespoke software that LLMs can now create. But the valuable thought stuff? Great systems coders are becoming more valuable than ever.
In the land of the blind, the one eyed man is king.
The daily standup isn't a status meeting, it's a confession booth. Lining engineers up to recite yesterday, justify today, surrender tomorrow โ that isn't management. It's the ritual an insecure manager performs to disguise the absence of a real communication channel.
An obvious tip for software design with or without AI that's nonetheless easy to get wrong:
Purge all foreknowledge of implementation and edge case from your mind and imagine the platonic user-land API. Think first in terms of high-level intentions.
Then see if it's achievable.
Most developers think productivity comes from writing more code faster. In reality, productivity comes from writing less code with fewer consequences. Every line you add increases maintenance, complexity, and future risk. The best engineers are not the fastest writers, but the most selective ones.
Speed without structure doesnโt scale. I mean, what works for a team of five breaks at fifty without clear ownership and boundaries, and fast decisions turn into inconsistent ones. The challenge is building systems that remain coherent as you grow.
Refactoring is frequently postponed because it doesnโt deliver immediate business value. However, every postponed refactoring becomes a hidden cost in the system. Complexity accumulates silently, until simple changes require disproportionate effort. What is delayed today becomes a constraint tomorrow.
Most teams believe that speed comes from moving fast and iterating quickly. But speed in software is cumulative: decisions made early either accelerate or slow down everything that follows. A poorly designed system doesnโt become fast with time, it only becomes expensive.
Database table size impacts performance in more ways than one:
a) B-tree depth. Using 8k pages and a 16b uuid:
1 level = ~370 rows
2 levels = ~138k rows
3 levels = ~50m rows
4 levels = ~20b rows
The lookup cost on a table with 100k rows is not the same as one with 1b rows. This can apply both to the table itself (MySQL cluster index) as well as the indexes. Sometimes a single query requires many of them.
b) Small table โ fits in RAM โ fast reads. The larger the table, the more likely to read from disk plus churn the cache.
c) # of indexes. Each adds maintenance overhead for insertions, and for Postgres vacuum overhead as well.
Keep an eye on this! It's useful to take regular stock of your tables + indexes. Clean bloat. Remove unused indexes. Partition if needed.
eu sei que vocรช tava esperando por esse momento! vai ter live sobre system design com o @fidelissauro no canal.
vamos entender arquitetura de sistemas, falar sobre carreira, o livro do Matheus e muito mais. entรฃo jรก deixa salvo na agenda dia 14 a 16 ร s 19h no canal, te espero lรก