My prediction for software engineering over the next 3 to 5 years.
Computer science and software engineering fundamentals will become far more valuable than knowing the latest frameworks.
If AI can write code in almost any language, knowing the nuance of another framework becomes less of a competitive advantage.
But understanding algorithms, data structures, networking, operating systems, databases, architecture and security?
That's a different story.
You still need to know:
- Why a particular architecture is appropriate.
- Why an API might fail.
- Why a database won't scale.
- Why an apparently working solution might be insecure.
A coding agent can build a solution.
But you need the knowledge to evaluate the trade-offs and recognise when it's wrong.
So, I think we'll see a renewed emphasis on the fundamentals of computer science and software engineering.
TL/DR: Learning how computers and software systems work will matter more than memorising how to use them.
What do you think?
Once upon a time there was an engineer who observed an SQL delete statement on a field called blah = x. That query was doing a full table scan and unnecessarily locks many rows in the execution path causing contention and sometimes deadlocks, mainly because blah didn’t have an index.
The engineer added an index and that made the query much faster.
Another engineer discovered that there was a bug in the code and that query shouldn’t have been executed to begin with. They removed the code that executed the delete and replaced with simpler delete on a more selective id field which was the primary clustered index on that table.
The index on blah remained on the table for decades, no one remembers why its there or questions it anymore.
The index lived happily ever after on that table, bloating storage, amplifying writes and WAL and slowing inserts.
The end.
The US government, citing national security authorities, has issued an export control directive to suspend all access to Fable 5 and Mythos 5 by any foreign national, whether inside or outside the United States, including foreign national Anthropic employees.
The net effect of this order is that we must abruptly disable Fable 5 and Mythos 5 for all our customers to ensure compliance.
Access to all other Claude models is not affected.
We apologize for this disruption to our customers. We believe this is a misunderstanding and are working to restore access as soon as possible.
Read our full statement: https://t.co/bwn0sximKZ
karpathy is showing one of the simplest AI architectures that actually works..
dump research into a folder, let the model organise it into a wiki, ask questions, then file the answers back in.
the real insight is the loop...every query makes the wiki better. it compounds.. now thats a second brain building itself.
i think this is so good for agents if applied right
instead of pulling from shared memory every session, they build a living knowledge base that stays.
your coordinator is not just coordinating tasks anymore.. it is maintaining institutional knowledge so every execution adds something back to the base.
the bigger implication is crazy tho.
agents that own their own knowledge layer do not need infinite context windows, they need good file organisation and the ability to read their own indexes.
way cheaper, way more scalable, and way more inspectable than stuffing everything into one giant prompt.
If babies understood embarrassment, most of them would never learn to walk or speak because of the amount of failure required to improve.
This was one of our first lessons in life but somehow, we forgot
𝗛𝗼𝘄 𝘁𝗼 𝘀𝗲𝗹𝗲𝗰𝘁 𝗗𝗲𝘀𝗶𝗴𝗻 𝗣𝗮𝘁𝘁𝗲𝗿𝗻?
Selecting the correct design pattern in software engineering is crucial for effective problem-solving.
This guide streamlines the process, enabling you to make informed decisions between patterns based on your specific needs.
It provides concise descriptions and valuable use cases for each pattern, making it easier to understand and apply them in real-world scenarios.
To select a pattern, we must first go through the problem identification. If the problem is related to:
🔸 Object Creation? → Creational Patterns
🔸 Object Assembly? → Structural Patterns
🔸 Object Interactions? → Behavioral Patterns
So, let's dive in.
𝟭. 𝗖𝗿𝗲𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Singleton: Use when a single instance of a class is needed. Some examples are logging and database connections.
🔹 Factory Method: Decouple object creation from usage. For example, you create different types of database connections based on configuration.
🔹 Abstract Factory: Create families of related objects. For example, I build parsers for different file formats (e.g., JSON, XML, CSV).
🔹 Builder: Constructing complex objects step by step. For example, if you need to create a complex domain object.
🔹 Prototype: Creating duplicate objects and reusing cached objects to reduce database calls.
𝟮. 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Adapter: Make incompatible interfaces compatible. For example, it integrates a new logging library into an existing system that expects a different interface.
🔹 Composite: Represent part-whole hierarchies. For example, graphic objects in a drawing application can be grouped and treated uniformly
🔹 Proxy: Control access to objects. For example, lazy loading of a high-resolution image in a web application.
🔹 Decorator: Dynamically add/remove behavior. For example, we are implementing compression or encryption on top of file streams.
🔹 Bridge: Decouple abstraction from implementation. For example, I am separating platform-specific code from core logic.
𝟯. 𝗕𝗲𝗵𝗮𝘃𝗶𝗼𝗿𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Strategy: Define a family of algorithms. For example, they allow users to choose different sorting or compression algorithms.
🔹 Observer: Maintain a consistent state by being notified of changes and, for example, notifying subscribers of events in a messaging system.
🔹 Command: Encapsulate a request as an object. For example, I implement undo/redo functionality in a text or image editor.
🔹 State: Encapsulate state-specific behavior. For example, we are handling different states of a user interface element (e.g., enabled, disabled, selected).
🔹 Template Method: Define the skeleton of an algorithm in operation, deferring some steps to subclasses and implementing a base class for unit testing with customizable setup and teardown steps.
Ultimately, we developed the pattern we needed for our problem.
#softwareengineering #programming #softwaredesign
Memory leaks in Node.js apps can kill performance.
I wrote about how Node.js + V8 manage memory, common leak patterns, and how to detect & fix them with heap snapshots and profiling.
Read here: https://t.co/OUipCuMKrh
You must know these 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗦𝘆𝘀𝘁𝗲𝗺 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 as an 𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿.
If you are building Agentic Systems in an Enterprise setting you will soon discover that the simplest workflow patterns work the best and bring the most business value.
At the end of last year Anthropic did a great job summarising the top patterns for these workflows and they still hold strong.
Let’s explore what they are and where each can be useful:
𝟭. 𝗣𝗿𝗼𝗺𝗽𝘁 𝗖𝗵𝗮𝗶𝗻𝗶𝗻𝗴: This pattern decomposes a complex task and tries to solve it in manageable pieces by chaining them together. Output of one LLM call becomes an output to another.
✅ In most cases such decomposition results in higher accuracy with sacrifice for latency.
ℹ️ In heavy production use cases Prompt Chaining would be combined with following patterns, a pattern replace an LLM Call node in Prompt Chaining pattern.
𝟮. 𝗥𝗼𝘂𝘁𝗶𝗻𝗴: In this pattern, the input is classified into multiple potential paths and the appropriate is taken.
✅ Useful when the workflow is complex and specific topology paths could be more efficiently solved by a specialized workflow.
ℹ️ Example: Agentic Chatbot - should I answer the question with RAG or should I perform some actions that a user has prompted for?
𝟯. 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Initial input is split into multiple queries to be passed to the LLM, then the answers are aggregated to produce the final answer.
✅ Useful when speed is important and multiple inputs can be processed in parallel without needing to wait for other outputs. Also, when additional accuracy is required.
ℹ️ Example 1: Query rewrite in Agentic RAG to produce multiple different queries for majority voting. Improves accuracy.
ℹ️ Example 2: Multiple items are extracted from an invoice, all of them can be processed further in parallel for better speed.
𝟰. 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗼𝗿: An orchestrator LLM dynamically breaks down tasks and delegates to other LLMs or sub-workflows.
✅ Useful when the system is complex and there is no clear hardcoded topology path to achieve the final result.
ℹ️ Example: Choice of datasets to be used in Agentic RAG.
𝟱. 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗼𝗿-𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗿: Generator LLM produces a result then Evaluator LLM evaluates it and provides feedback for further improvement if necessary.
✅ Useful for tasks that require continuous refinement.
ℹ️ Example: Deep Research Agent workflow when refinement of a report paragraph via continuous web search is required.
𝗧𝗶𝗽𝘀:
❗️ Before going for full fledged Agents you should always try to solve a problem with simpler Workflows described in the article.
What are the most complex workflows you have deployed to production? Let me know in the comments 👇
#LLM #AI #MachineLearning