3,194 karma · joined April 28, 2014
The key is that we all have an intuitive sense that this behavior is wrong - building a project means working within the established patterns of that project, or at least being aware of them! Going off half-cocked and building a solution without considering the context is extremely bad form.
In the case of human developers, this can be fixed on the code review level, encouraging a culture of reading not just writing code. Without proper guardrails, they can create code that's dissonant with the existing project.
In the case of LLMs, the only recourse is context engineering. You need to make everything explicit. You need to teach the LLM all the patterns that matter. Their responses will always be probabilistic token salad, by definition. Without proper guardrails, it will create code that's dissonant with the existing project.
Either way, it's a question of subjective values. The patterns that are important need to be articulated, otherwise you get token salad randomly sampling the solution space.
The prior raster tiles have the style baked in; if you want a new look, you need to generate a new image. So each map publisher ends up running their own data and server infrastructure just to tweak the style.
The vector tile approach means a single (cacheable) asset can be used in many different maps. Huge win. If you don't like the style, you can make your own without having to literally download the planet.
One solution to this is to write structured and testable documentation. Easier said than done, but if your docs get regularly integration/e2e tested against reality, they stand a much better shot at staying up to date. I always recommend moving the docs as close to the development work as possible - ie docs get checked into git alongside the code and make sure tests fail if anything changes.
But where real decisions need to be made by those with "skin in the game", LLMs are a disaster. Vibe coding quickly falls off a cliff. They create code architectures that no human would given the context, and as a result no human can feasibly understand or maintain them long term.
I would say this is boon to real software developers - tons of apps that need an expert to maintain, it's job security, right? Well, no. I suspect, rather than maintain these LLM-generated monstrosities, most organizations will just let them rot. That was the default in the golden age of zero-interest engineering, that's the default in the golden age of vibe coding too.
You'll be interested in the changes in 3.11, a single `gdal` entrypoint with a modern CLI. https://gdal.org/en/stable/development/rfc/rfc104_gdal_cli.h...
Installation is still a beast, mainly because it's one monolithic thing. It's a spatial analysis library, dozens of applications, and hundreds of filetype drivers - all in a single build process. Each driver has its own quirks and the abstraction leaks like a sieve. In retrospect, I think the spatial logic, the drivers, and the apps should have been broken up into loosely-coupled components. But the convenience of an all-in-one megalith was hard to beat.
However, there's a huge difference between dismissing the severity of the evidence vs. going out of your way to hide evidence. The first is born of arrogance. The later is naked cowardice - they know exactly how wrong they are. If they wanted to project strength, they could simply leave the reports up and say "we don't care". Instead they scurry around behind the curtains trying to cover their tracks. Fucking pathetic.
data isn't indexed so queries other than select-by-uuid will be slow (unless you're putting indexes on special keys which is just an ad-hoc schema with extra steps)
data migrations will be painful and require full table scan/rewrite (hope you can afford downtime)
No relationship between any of your data; it's all just independent blobs of data that may or may not be related. No referential integrity means you need another out-of-band process to make sure everything is pointing to valid data.
I get the temptation to nope out of schemas and do schema-on-read. Worked for Mongo, right? (did it?) However, postgres allows an even better option: create an actual schema for your business domain THEN add a jsonb column to every table. If you need to add extra stuff, you can just shove it into the data column. You get all the benefits of a static schema plus an option to jump ship and do JSON in a pinch.
Can anyone comment on the methods used here? Seems they don't have the same issues.
FWIW, I switched from zsh default to starship and didn't notice any perceptible difference. But I certainly notice when I mess up my git commits!
Many reasons: you need more control, specialized hardware, testing newer versions of the library, maintaining an internal fork of a library, security, performance, the dev team maintains both the native library and python package and needs to keep them independent, or simply preference for dynamic linking against system libraries to avoid duplication.
Worth mentioning that using Hurl in Rust specifically gives you a nice bonus feature: integration with cargo test tooling. Since Hurl is written in Rust, you can hook into hurl-the-library and reuse your .hurl files directly in your test suite. Demo: https://github.com/perrygeo/axum-hurl-test
Not exactly. The leading explanation is the "Kelp Highway" theory - the complex coastal geography of SE Alaska and ocean currents could have created a small pockets of ice-free land and given access to rich marine resources. You could effectively island hope down the inland passage until you hit the Columbia river. Having made it to Australia 50kya, we know at least some prehistoric humans had the maritime technology to pull it off.
My take is, it seems likely that at least some of the Beringians made it south of the ice wall during the glacial maxima. If the ice wall was indeed impenetrable 25kya (ie the kelp highway theory is wrong) , the White Sands footprints must have come from people who migrated even earlier.
Sort of. The process of working through the question is what drives learning. If you just receive the answer with zero effort, you are explicitly bypassing the brain's learning mechanism.
There's huge difference between your workflow and fully Agentic AIs though.
Asking an AI for the answer in the way you describe isn't exactly zero effort. You need to formulate the question and mold the prompt to get your response, and integrate the response back into the project. And in doing so you're learning! So YOUR workflow has learning built in, because you actually use your brain before and after the prompt.
But not so with vibe coding and Agentic LLMs. When you hit submit and get the tokens automatically dumped into your files, there is no learning happening. Considering AI agents are effectively trying to remove any pre-work (ie automating prompt eng) and post-work (ie automating debugging, integrating), we can see Agentic AI as explicitly anti-learning.
Here's my recent vibe coding anecdote to back this up. I was working on an app for an e-ink tablet dashboard and the tech stack of least resistance was C++ with QT SDK and their QML markup language with embedded javascript. Yikes, lots of unfamiliar tech. So I tossed the entire problem at Claude and vibe coded my way to a working application. It works! But could I write a C++/QT/QML app again today - absolutely not. I learned almost nothing. But I got working software!
You believed in that. And it worked. The placebo effect is still an empirically measured effect. Vitally, it requires the consent of the one being "placebo'd".
You healed your RSI with your mind bro. Stop fighting it.
In any case, this is a far cry from what I was discussing. At best, this shows an ability for LLMs to "learn" within the context window, which should already be somewhat obvious (that's what the attention mechanism does). There is no global knowledge base or weight updates. Not until the content gets published, rescraped, and trained into the next version. This does demonstrate a learning feedback loop, albeit one that takes months or years, driven by external forces - the company that trains it. But it's way too slow to be considered intelligent, and it can't learn on its own without help.
A system that truly learned, ie incorporated empirical data from its environment into its model of the world, would need to do this in millisecond time frames. Single celled organisms can do this. Where you at AGI?
Contrast that with Hickey's notion of simplicity as an objective count of interleaved concerns or "folds". The quibble with this is, how do you delineate the concerns? Depending on your style and knowledge of the system, you'll get a different number. So it's hard to call it objective.
Tellman's definition is nice because it acknowledges the subjectivity, and puts it front and center. IOW the "style and knowledge of the system" form a mental model of the software system. What's important is not the cardinality, OR the interleaving. It's the ability for that model to make good predictions about the software's behavior. Accurate model held in the minds of humans that operate it == simple software.
The learning and inference process are entirely separate, which is very confusing to people familiar with traditional notions of human intelligence. For humans, learning things and applying that knowledge in the real world is one integrated feedback process. Not so with LLMs, we train them, deploy them, and discard them for a new model that has "learned" slightly more. For an LLM, inference is the end of learning.
Probably the biggest misconception out there about AI. If you think LLMs are learning, it's easy to fantasize that AGI is right around the corner.
When anyone can take an idea and re-create it from scratch in seconds, the original code artifact is irrelevant. So increasingly, the quality of the idea matters. There are obviously details required to make successful software - but that's the point. Those other challenges now become front and center.
Knowing the domain, internalizing a model of the system, communicating, planning for change, writing code, shipping it - that's always been how software gets built. None of that really changes except for the "writing code" part which is quickly becoming the least valuable skill in the bunch.
I've heard the phenomenon called "Neuroplastic Pain" and this general technique for solving it as "Pain Reprocessing Therapy". The pain is real but it's signal processing problem, not a mechanical injury! It changes the way we approach chronic pain. "The Way Out" by Alan Gordon is my go to book for this.