i build things. sometimes they work. sometimes they teach me more than the ones that do.
i care about how code feels when you open it months later. about clarity. about tools that actually help instead of getting in the way. about learning the same idea in ten different languages just to see how each one thinks.
i'm not chasing trends. i'm chasing understanding.
-
working on 10-languages-crash-course
same topics. ten languages. side by side. python, javascript, go, rust, java, c++, typescript, ruby, php, csharp. personal notes style. no fluff. just the shape of each language when it solves the same problem. -
also maintaining ttl-storage
a small storage library with proper ttl support. nothing fancy. just something that does one job cleanly. -
learning deeply in rust and go. still writing a lot of javascript and typescript because that's where most of the real-world friction lives.
-
thinking about systems. about how data moves. about the quiet parts of programs that nobody notices until they break.
performance that doesn't feel clever.
code that reads like it was written by someone who will still be around in two years.
developer tools that respect your attention.
learning systems that force you to see patterns instead of memorizing syntax.
i like when a solution is almost boring. when it's so clear that the cleverness disappears.
i also like the opposite sometimes. the messy experiments. the half-finished ideas. the notebooks full of "what if".
both matter.
javascript / typescript — daily work, tools, experiments
rust — where i go when i want the compiler to argue with me
go — simplicity with teeth
python — quick thoughts and scripts
c++ / java / csharp — when the problem demands it or the course does
ruby / php — still learning their rhythms
i don't claim mastery in all of them. i claim curiosity. and enough hours to know where each one starts to feel natural and where it starts to fight back.
i write a lot. then i delete a lot.
i read code more than i write it some days.
i prefer small, focused pieces over big frameworks that promise everything.
when something is hard, i usually try to explain it to myself in the simplest words possible. if i can't, i don't understand it yet.
i keep notes. lots of them. some of those notes become public. most stay private. the public ones are the ones that survived the "would this still make sense to me in six months" test.
10-languages-crash-course
one idea. ten languages. no marketing. just the raw comparison.
if you want to see how the same thought looks when it's forced through different syntax and different cultures of code, this is it.
ttl-storage
a quiet little library. does what it says. expires things when they should expire.
sometimes the best code is the code that disappears into the background.
more will come. some will be useful. some will just be me figuring something out in public.
- clarity beats cleverness almost every time
- the best abstractions are the ones you forget are there
- learning the same concept in multiple languages is one of the fastest ways to actually understand it
- tools should feel like extensions of your thinking, not obstacles to it
- it's okay to ship something small and honest instead of something big and unfinished
- screen time is high. focus is higher. that's the deal right now.
- i can spend an entire evening rewriting the same function until the shape feels right
- i like reading other people's code more than most people admit
- i still get excited when a test passes for the right reason
- i think good documentation is a form of respect
- i believe the best way to learn a language is to solve the same set of problems in it that you've already solved in three others
thanks for looking.
feel free to open an issue, star something that helped you, or just lurk.
both are fine.
i'm usually building something.
sometimes it's useful.
always it's honest.