Gus Ramirez

Solo pasaba por aquí

[GalisLab 💻📊 @galislab]

Aprende SQL de una manera muy sencilla y dinámica.

→ Interactivo
→ Gratis
→ Sin descargar nada
→ Desde cero

🔗 https://t.co/FSHkMW2fv9

[Javier Lopez @javisan81]

Pensar que ahora el software no vale nada pero que antes si, es no haberse dado cuenta que el software lleva décadas que no vale nada.
Hace años más de 13 a una empresa donde trabajaba le robaron todo el código fuente de una aplicación.
Que pasó?. Daño reputacional, pero el código daba igual nadie le importaba.

[Arturo Villegas @ArturoVill7]

Imagina que tu esposo se convierte en un símbolo nacional de la lucha contra el crimen organizado. Está en el mejor momento de su carrera política y es el gran favorito para gobernar su estado. Entonces, una noche lo asesinan frente a ti y a tus hijos. Los principales sospechosos son precisamente los políticos a quienes incomodaba su lucha.

Lejos de rendirte, asumes la Presidencia Municipal de Uruapan y continúas defendiendo su legado. Desde el primer día enfrentas la hostilidad del mismo grupo político que permitió, perpetuó o se beneficio del crimen. Recibes amenazas, vives bajo presión permanente y aun así sigues adelante.

Como si no fuera suficiente, el régimen bloquea las candidaturas ciudadanas e independientes, cerrándote el camino para competir por la gubernatura, donde eras la favorita. Después te declaran persona non grata en el Congreso de tu propio estado.

Todo eso ha vivido Grecia Quiroz en apenas ocho meses.

Mi total solidaridad con esta mujer valiente, que se niega a doblarse frente al crimen y frente a los narcopolíticos morenistas. Podrán intentar silenciar su voz, pero hay millones de mexicanos en los que ya hizo eco y alzaremos la voz junto a ella.

¡El legado de Carlos Manzo vive!

[Melissa Ⓜ️ @Melissa_Bely]

¡ Brutal !

¿ Cuál soberanía ?

Los NARCOS son los que controlan el país y ellos son los que ponen el precio hasta de los productos básicos.

¡ Están cobrando 4 pesos por kilo de limón a los productores !

¡ Y cuotas a los transportistas !

Vean...

@AztecaNoticias

[Xóchitl Gálvez Ruiz @XochitlGalvez]

Por el bien de todos, que se investigue y castigue a los gobernadores y otros funcionarios morenistas ligados al narcotráfico, trátese de quien se trate.

[Karla Estrella @KarlaMaEstrella]

Personas que les escriben cartas al gobierno de EE.UU. pidiendo trato justo y presumiendo buenas acciones para México:

1. El señor Guzmán Loera
2. Andrés Manuel

[Cayetana Álvarez de Toledo @cayetanaAT]

Quien amenaza la soberanía de los mexicanos no es EEUU. No es España. Y desde luego no es la Historia: Hernán Cortés o Isabel la Católica.

Son tres flagelos.
Internos, coludidos y corrosivos.

1. El crimen organizado.
2. El populismo autoritario.
3. La mentalidad de dependencia.

[Xóchitl Gálvez Ruiz @XochitlGalvez]

¡Que no nos confundan!

Vendrán por los narcopolíticos que el gobierno de Morena se empeña en proteger, no por los mexicanos de bien.

[Millie Marconi @MillieMarconnni]

A Dutch computer scientist gave one lecture in 1988 arguing that programming is unlike anything humans have ever tried to do before, and the reason most software on earth is broken is that we are still teaching it as if it were a hobby.

His name was Edsger Dijkstra. He won the Turing Award in 1972. He invented the shortest path algorithm that every GPS on earth still runs on.

He wrote the paper that killed the goto statement in modern programming languages.

He spent 50 years quietly being one of the most consequential thinkers in the entire history of computer science, and he was in a very bad mood by the time he stood up at the ACM Computer Science Conference in 1988 to deliver the lecture that almost nobody at the conference wanted to hear.

The lecture was called On the Cruelty of Really Teaching Computer Science.

It is now one of the most cited papers in the entire history of computing education. It was filed in his archive as EWD1036, handwritten in his careful fountain-pen calligraphy because he refused to use a typewriter and famously refused to use email for the rest of his life.

The argument was simple and uncomfortable.

Programming, Dijkstra said, is a radical novelty. Not a new tool. Not a new skill. Not a faster version of something humans already knew how to do. A genuinely new category of intellectual activity that has no real precedent in the entire history of the human species, and our brains have not been built to handle it.

Here is what he meant by that.

When a programmer writes a line of high-level code and presses run, that single line might trigger a billion operations at the level of the silicon.

The ratio between the abstraction you are working in and the physical events you are actually causing is roughly one billion to one. No engineer in history before computing ever had to reason about a system spanning that kind of ratio inside their own head.

A bridge builder reasons about steel beams and the physics of weight. A surgeon reasons about organs and the physics of tissue. A chemist reasons about molecules and the physics of bonds.

All of them are working inside ratios of physical scale where the largest and smallest things they need to think about are within a few orders of magnitude of each other.

A programmer routinely writes one line that orchestrates a billion physical events on a chip, and is expected to predict the behavior of all of them in advance.

Dijkstra argued that the human brain was simply not built for this. Every intuition we have evolved over hundreds of thousands of years comes from a world of medium-sized objects behaving in continuous ways. Computing is the opposite. It is discrete, not continuous.

A program that runs perfectly a billion times can crash on the billion-and-first iteration because of a single bit. A single character missing from a line of code can take down a power grid. There is no margin. There is no graceful degradation. The system either works or does not, and the only way to know is to actually run it.

This was the part of the lecture where Dijkstra made everyone in the room uncomfortable.

He said the way computer science was being taught in universities was a quiet disaster. Professors were teaching programming the way carpenters teach woodworking. With examples. With metaphors. With analogies to things students already understood. Files are like folders. Memory is like a desk. A function is like a recipe.

Dijkstra said this was actively making it harder for students to think clearly. The whole point of a radical novelty is that there is nothing in your past experience to compare it to.

The moment you start reaching for metaphors, you are smuggling in old intuitions that do not apply, and those intuitions will betray you the first time you try to reason about a system the metaphor was not built to describe.

His exact line was this: the usual way in which we plan today for tomorrow is in yesterday's vocabulary. And yesterday's vocabulary, he argued, was killing the field.

The reason most software is broken is downstream of this single misunderstanding. Programmers are taught to think of code as a craft. Something you get a feel for.

Something you pick up through practice. Something where intuition gets sharper with experience.

Dijkstra said this is exactly backwards. Programming is not a craft. It is closer to mathematics than to carpentry, and the moment you treat it as a craft, you guarantee that the software you produce will be full of the kind of bugs that craftsmanship cannot catch.

The fix, in his view, was to teach programming the way mathematics is taught. You should be able to prove your program correct before you run it.

You should reason about your code formally, the way a mathematician reasons about a theorem, not the way a carpenter feels their way through a joint. The students who learned this way, he said, would walk out of their classes with a kind of confidence that no amount of typing practice could produce.

The lecture was published in Communications of the ACM in 1989. The field did not listen. Universities kept teaching programming the same way.

Software kept getting bigger. Bugs kept compounding. By 2026, almost every piece of software on earth has known security vulnerabilities, undefined behaviors, and edge cases that nobody has ever proven safe. The doom that Dijkstra warned about in 1988 is now the default condition of the digital world we have built.

The deeper lesson is the one most readers miss the first time through.

Dijkstra was not just talking about software. He was making a much bigger point about how humans learn anything that is genuinely new. The instinct to translate the unfamiliar into the familiar is the most natural thing in the world.

It is also the single biggest obstacle to actually understanding something that has no precedent. If you keep reaching for analogies, you will never see the new thing clearly. You will only see your old framework projected onto it.

This is happening right now with AI. The same instinct that made people learn programming through metaphors of files and folders is making people understand large language models through metaphors of brains and people.

Almost every framework being used to describe AI in 2026 is borrowed from a previous domain. None of them quite fit. The few people who are actually building useful intuitions about how these systems work are the ones who have done what Dijkstra recommended forty years ago.

They have set down the old vocabulary. They have looked at the new thing on its own terms. They have accepted that the radical novelty is radical for a reason.

You are not slow. You were taught a discipline as if it were a hobby. The cruelty is real.

The fix is still available.

[Fra, el hada de las vacantes ✨✨✨ @frasalazar]

Estoy festejando el segundo aniversario del ✨hada de las vacantes✨
Si quieren ✨Martes de vacantes✨ yo lo que quiero son 200 likes.

[trish @TrisH0x2A]

in 2008 James Molloy wrote a free tutorial that taught people how to build a UNIX like operating system from scratch in C and assembly

it is called "Roll Your Own Toy UNIX Clone OS" and walks through building a real kernel step by step

bootloader, GDT, IDT, interrupts, paging, heap management, filesystems, multitasking and user mode are all covered

this is not just theory every chapter includes code you can compile run and experiment with in QEMU

[Melissa Ⓜ️ @Melissa_Bely]

🚨 ESCÁNDALO

Estafa Maestra" de $7,600 millones y el amigo de Adán Augusto...
¡ queda libre !

Morena prometió acabar con la corrupción... y resultó ser su mejor protector.

En México la corrupción ya no se combate - se hereda.

👇

[Melissa Ⓜ️ @Melissa_Bely]

#ULTIMAHORA

Se filtra video de la llegada de los diputados, senadores y gobernadores de Morena que van a participar en el NARCOFEST en el monumento a la Revolución.

No le den RT ni FAV porque se enojan mucho los del NARCOPARTIDO.

[Carlos Vassan @Carlos_Vassan]

Amazon abrió su primera escuela de tecnología en México 💻

Inauguraron en Querétaro el Think Big Space, un laboratorio educativo gratuito donde estudiantes de prepa y universidad aprenderán robótica, impresión 3D, IA y cómputo en la nube 🤖

Los cursos están avalados por la UNAM, y quienes terminen recibirán una certificación oficial 🎓

Las clases arrancan en septiembre y tienen capacidad para más de 1,200 estudiantes al año en talleres y cursos gratuitos

[tetsuo @tetsuoai]

char (*(*x[3])(void))[5];

If reading that took you more than a few seconds, you want the right-left rule from Peter van der Linden's Expert C Programming.

Start at the name, look right, then left. When parentheses block you, pop out and keep going.

x
right: [3] → array of 3
left: * → pointers to
right: (void) → functions (no args) returning
left: * → pointers to
right: [5] → arrays of 5
left: char → char

So:

x is an array of 3 pointers to functions returning pointers to arrays of 5 char.

C declarations are weird. This book teaches you how to read them.

[Arpit Bhayani @arpit_bhayani]

Fun fact: Redis does not just rely on the standard operating system memory allocator. Even though it's written in C, it overrides the native `malloc` implementation with highly optimized third-party memory allocators like `jemalloc` (by Facebook) or `tcmalloc` (by Google) to achieve efficiency and low-fragmentation performance.

I firmly believe that understanding theory is fine, but things become interesting when you sit down to implement it. This is where you find gaps in your understanding and understand the nuances. and hence...

Today, we dive into the source code of Redis to look at how and why Redis overrides the default `malloc` implementation.

This is the 18th video in the Redis Internals series. Like always, we keep our focus on execution and not just theory, looking closely at how an in-memory database handles massive amounts of small object allocations and deallocations without crumbling under memory fragmentation.

In the video, I talk about memory pages, how native allocators interact with the OS, and the classic problem of fragmented memory. We also look directly at the Redis source code and see how they wrapped malloc with zmalloc to abstract out the implementation.

By the way, 18 videos are now live:

1. Why Single-Threaded Redis Is Fast
2. Writing a TCP Echo Server
3. Wire Protocols
4. Implementing RESP
5. Implementing PING
6. Understanding Event Loops
7. Implementing Event Loops
8. Implementing GET, SET, and TTL
9. Implementing DEL, EXPIRE, and Cleanup
10. Evictions and Implementing first-eviction
11. Implementing Command Pipelining
12. Implementing AOF Persistence
13. Objects, Encodings, and Implementing INCR
14. Implementing INFO and allkeys-random Eviction
15. The Approximated LRU Algorithm
16. Implementing the Approx LRU Algorithm
17. How Redis Caps Its Memory Usage
18. How and Why Redis Overrides Malloc

If you have ever wondered how scale-critical systems avoid performance degradation over time and handle advanced manual memory management with custom concurrency and defragmentation controls, this deep dive is for you.

Hope this helps you better understand database internals and spark that engineering curiosity.

Give it a watch.

[Dmitrii Kovanikov @ChShersh]

Okay, as promised, here's a better Binary Search.

If this post gets 500 likes, I'll write a complete tutorial on binary search and why this implementation is better.

[Xóchitl Gálvez Ruiz @XochitlGalvez]

No permitiremos que el gobierno morenista persiga a una gran gobernadora que solo ha hecho su trabajo y que ha combatido al crimen organizado.

Cuentas con todo nuestro respaldo, querida Maru Campos.

#YoConMaru

[Alan @bitforth]

the comment:
> priyansh, this sucks. pls fix

jk jk

The boring answer is this: first principles, incentives, and context.

L3/L4s typically work at feature level, and L6+ work at cross-org/company wide systems.

So when L3/L4s write a doc, they review it and think "yeah, this seems technically correct” and the load-bearing assumption is "within my local blast radius"

but when an L6+ reads the same doc, they ask themselves:

- “What failure mode is being hidden by the clean architecture diagram?”
- “This internal service is going to be deprecated in 12m”
- "X, Y org is working on a very similar project"
- “What happens when there's a re-org and nobody remembers why this was built?”

Also, senior comments compress years of experience in a few words. L6+ have seen the clean migration plan that turned into a 6mo incident factory, and the elegant abstraction that became a career-long tax, and the “temporary” fork become the real platform, and the metric improve while the business got worse.

So that small comment is very often less about that particular line/paragraph and more about the trajectory.

That is why it takes 10m to answer, only for 1hr later to realize the comment was deeper than it looked.

And yes, feeling "dumb" is expected (though I wouldn't use that word) mostly because you are close enough to someone operating at a higher level than your own (current) ceiling so the gap becomes visible and palpable.

[trish @TrisH0x2A]

in 1988 Jack Crenshaw wrote Let's Build a Compiler because most compiler books were impossible for beginners to follow

in 2017 Nora Sandler did something similar for C

while working through Abdulaziz Ghuloum's paper on incremental compiler construction she adapted the ideas from Scheme to C

the series starts with a compiler that can do exactly one thing return an integer from main

then adds one feature at a time until it becomes a real compiler generating x86 64 assembly

the entire series is free online

it eventually became a 750 page No Starch Press book in 2024

the original blog posts are still available and still work as a step by step guide