Polymath Engineer Weekly #77
RAG, Emacs, Developer Productivity, Heat Pumps, Go, South America and Life Reflections
Links of the week
With the advent of large language models (LLM), retrival augmented generation (RAG) has become a hot topic. However throught the past year of helping startups integrate LLMs into their stack I've noticed that the pattern of taking user queries, embedding them, and directly searching a vector store is effectively demoware.
For those who haven't used Emacs, it's something you'll likely hate, but may love. It's sort of a Rube Goldberg machine the size of a house that, at first glance, performs all the functions of a toaster. That hardly sounds like an endorsement, but the key phrase is "at first glance." Once you grok Emacs, you realize that it's a thermonuclear toaster that can also serve as the engine for... well, just about anything you want to do with text. When you think about how much your computing life revolves around text, this is a rather bold statement. Bold, but true.
We mocked up what we thought it should look like. We did some low-fidelity wireframes of the data, here’s how it will work.
We looked at other examples across the industry of people who had built DORA Metrics dashboards and what those look like. We started wiring it up, and then we dealt with the idiosyncrasies of our tool to sort of adjust to that and what’s possible and what’s not possible. Then got to the first concept. Then we started just spot-checking the data like, ‘Okay, here it is. does this look right?’ Digging into the data and seeing if everything was playing out the way we thought it should.
Heat pumps are unique in that they are a tool for fighting climate change, where we have the technology today. It's the same tech that we've been using in refrigerators and AC units for decades. Switching to heat pumps would reduce hundreds of MT of CO2 emissions per year. And yet, they are only present in 15% of US single-family homes.
The early compiler worked. It bootstrapped the language well. But it was a bit of an odd duck, in effect a Plan 9-style compiler using old ideas in compiler writing, rather than new ones such as static single assignment. The generated code was mediocre, and the internals were not pretty. But it was pragmatic and efficient, and the compiler code itself was modest in size and familiar to us, which made it easy to make changes quickly as we tried new ideas. One critical step was the addition of segmented stacks that grew automatically. This was very easy to add to our compiler, but had we been using a toolkit like LLVM, the task of integrating that change into the full compiler suite would have been infeasible, given the required changes to the ABI and garbage collector support.
It is pretty cool too watch seasoned engineers doing things out of the “modern best practices“ because they know what they are doing and will be better positioned for the future.
Most understand that the construction of the Panama Canal was necessary in order to significantly reduce the travel time of going around the tip of South America. While that is true, there are also much more treacherous and nefarious reasons why navigators wanted to explore the long way round. Today we’ll learn more about one of the most dangerous and infamous straits that exists in the world, a rite of passage for some of the most renowned explorers, adventurers, and scientists humanity has produced, and a region ordinary mariners and commercial ships avoid at all costs: The Drake Passage.
Book of the Week
Do you have any more links our community should read? Feel free to post them on the comments.
Have a nice week. 😉