New Vs Improved
Do you love shiny new things? So do I. I'm always excited trying out new tools, IDEs, plugins, frameworks, languages. And often, there is a clear value add by going from an old model to a new one.
But sometimes, evolution isn't as straightforward. Let's look at examples!
Databases
NoSQL databases like MongoDB, Cassandra, and Redis are evolutions of relational databases like MySQL or PostgreSQL. But that does not mean you should use MongoDB as a drop-in replacement for all your database needs. NoSQL databases are vastly superior to relational databases in the use cases they were meant to cover, and vastly inferior in those they weren't.
Web frameworks
Single-page application (SPA) frameworks like React were developed to manage complex client-side states while decreasing network traffic. They are more modern than template-based web frameworks that send HTML back and forth from a server, like Django, and have become the de-facto standard for most frontend devs. "Nobody ever got fired for picking React", as they say. But for applications that don't need to track complex client-side states, HTML with a bit of JavaScript sprinkled in would turn out completely fine, at much lower complexity.
AI models
It all started with basic statistics...
Then we got machine-learning models like
logistic regression
support vector machines
k-means clustering etc.
Then we got deep neural networks (NNs) with varying architectures:
Multi-layer perceptrons for generic data
Convolutional NNs for image recognition
Recurrent NNs for analyzing sequences (like text, or time-series data)
The mighty transformers that turned out much better at dealing with sequences, though they still needed to be special-purpose trained on the task at hand
And finally, we made the transformers and the training sets we exposed them to so incredibly large that we got our Large Language Models (LLMs) with incredibly general capabilities. The same model will write you a poem about your cat, explain a section of the tax code in plain English, or write you some Python code.
Still, an LLM should not be thought of as the default go-to just because it is the largest, most powerful model. In fact, the question should always be: What's the least complex, least advanced, plain simplest thing we can throw at our problem that might actually work?
