antirez

Security mindset: read the book Security Engineering (it is online), less for specific technical info than for the many war stories etc. which will help you guard against vulnerabilities and unforeseen consequences.

Basics of cryptography: there are many dumb errors to avoid.

Antirez's general advice about "10x programmers" is good: http://antirez.com/news/112

Thorough (not just basic) knowledge of SQL, if you don't count that as a language. The sqlite.org "technical and design documents" about sqlite's virtual machine and its query planner are well worth reading, and apply to other databases as well. ORM's are less important than SQL, and are usually language specific as someone mentioned.

Reasonable clue about socket programming, even if you're doing everything with libraries that wrap the details.

Comfort using debugging and profiling tools.

Lots of other stuff, I'm sure.

There's many examples of exactly what you're asking for, such as Kenton Varda's Cloudlfare oauth provider [1] and Simon Willison's tools [2]. I see a new blog post like this with detailed explanations of what they did pretty frequently, like Steve Klabnik's recent post [3], which while it isn't as detailed has a lot of very concrete facts. There's even more blog posts from prominent devs like antirez who talk about other things they're doing with AI like rubber ducking [4], if you're curious about how some people who say "I used Sonnet last week and it was great" are working, because not everyone uses it to write code - I personally don't because I care a lot about code style.

[1]: https://github.com/cloudflare/workers-oauth-provider/

[2]: https://tools.simonwillison.net/

[3]: https://steveklabnik.com/writing/a-tale-of-two-claudes/

[4]: https://antirez.com/news/153

Many of us are programmers. Some of us are also trying to be writers. Trust me: writing is like programming. Reading code is very useful to become a better programmer, but you learn programming mostly by writing code. Similarly you mostly learn how to write prose by writing prose, tons of it. Reading is especially useful if you identify certain books that are very high in style (for me one of such books was "Vite di uomini non illustri" by Giuseppe Pontiggia), for your taste at least, for what you beleive the best writing is. You read these books many times, to understand what's going on, what are the patterns, how to do the same magic. As a casual reader you can read 200 books every year and yet remain a terrible writer.

EDIT: more about that on my blog if you care -> http://antirez.com/news/136

My observations after reading https://bugs.ruby-lang.org/issues/14718:

- Shyouhei Urabe did a marvelous job of resisting pressure from several well-known developers representing multiple high profile ruby companies/projects.

- Everyone eventually came to their senses in https://bugs.ruby-lang.org/issues/14718#note-89, and concluded that the best way forward is to use glibc with MALLOC_ARENA_MAX=2.

My personal feeling is that while the "Jemalloc FTW" section in http://oldblog.antirez.com/post/everything-about-redis-24.html might have been correct back in the jemalloc 3.x days, a lot has changed on both jemalloc and glibc since then. Furthermore, there is also musl in the equation these days.

Yes, in Tcl everything is basically a string, but has Lisp-like recursive structures: An expression like `
{foo
{bar baz}}` evaluates to the string "foo
{bar baz}" at first, but then that might be split into two strings "foo" and "bar baz" by the interpreter.

I recall Tcl being described as a Lisp without the parenthesis many years ago, which I still think is somewhat apt.

Antirez' article "Tcl the Misunderstood" [0] is well worth a read if you want to know more.

He also has an interpreter, Picol [1], in 500 lines of C code that is very easy to read and to understand.

[0] http://antirez.com/articoli/tclmisunderstood.html

[1] http://oldblog.antirez.com/post/picol.html

A couple of my favorite technical blogs

- https://openai.com/blog/

- https://ai.googleblog.com

- http://antirez.com/

- https://research.facebook.com/blog/

- https://martin.kleppmann.com/archive.html

- https://devblogs.microsoft.com/oldnewthing

- https://www.allthingsdistributed.com/

- https://jvns.ca/

- https://www.johndcook.com/blog

- http://feross.org/

- https://ridiculousfish.com/blog/

- https://blog.andrewcantino.com/

- https://nickcraver.com/blog/

- https://blog.codinghorror.com

I have been also building an engineering blog aggregator called https://diff.blog to make it super easy to disover and follow blogs. Would love if you folks can give it a try :)