Why Algorithmics Still Matters
We live in a time when software can write code, explain code, translate code, search documentation, and suggest solutions. This changes what students should practice. It does not remove the need to understand algorithms. It makes that understanding more important.
AI tools can often produce an answer. The hard part is knowing whether the answer is correct, efficient, robust, appropriate, and honestly your own work. Algorithmics trains exactly that judgement.
What this course is really about
The visible topics are data structures, sorting, trees, graphs, hashing, dynamic programming, heuristic search, and text algorithms. Underneath those topics, the course trains a smaller set of habits:
- turning vague problems into precise computational tasks;
- choosing a representation that makes the task easier;
- estimating time, memory, and scaling behaviour before running code;
- recognising standard algorithmic patterns;
- testing an answer against examples, edge cases, and counterexamples;
- explaining not only what works, but why it works;
- reading technical material carefully enough to extract the main idea;
- writing concise reports that make the reasoning, method, results, and limitations clear;
- presenting your solution so another person can follow and question it;
- noticing trade-offs between correctness, speed, simplicity, and maintainability.
These habits are useful whether you write the code by hand, use a library, collaborate with people, or work with an AI assistant.
Why learn this if AI can generate code?
Because generated code still has to be judged.
An AI assistant may give a plausible implementation of Dijkstra's algorithm, a binary search, or a dynamic-programming recurrence. It may also mix assumptions, miss an edge case, use the wrong complexity, or solve a subtly different problem. If you cannot inspect the idea, you become dependent on surface fluency. If you can inspect the idea, AI becomes a powerful partner.
In this course, the goal is not to compete with AI at typing code. The goal is to become the person who can ask better questions, decompose the task, recognise useful methods, check the result, and explain the reasoning.
What good AI use looks like
You may use AI assistants as learning and programming support, unless a task explicitly says otherwise. Good use includes:
- asking for an explanation of a concept after you have tried to understand it;
- asking for examples, edge cases, or test cases;
- comparing two possible data structures or algorithms;
- asking for help finding a bug in code you can explain;
- asking for feedback on the clarity of your report;
- using AI to improve grammar, structure, or readability.
Weak use is copying a generated solution that you cannot explain. That may produce a submission, but it does not produce competence.
Reading, writing, and presenting are part of the course
In past years, many weak submissions were not weak because the code did nothing. They were weak because the report did not explain the problem, the method, the evidence, or the conclusion. A link to a Google Colab notebook or a Python notebook is not, by itself, a report.
In this course, a good report should be concise and to the point. It should be readable as a short technical argument:
- what was the problem;
- what did you try;
- what algorithmic idea or data structure did you use;
- what evidence shows that it works;
- what are the running time, memory use, and limitations;
- what did you learn from the result.
Do not include everything just because it happened during your work. Select the evidence that matters. Long output, unedited notebooks, screenshots without explanation, and pages of code rarely make a report stronger. A reader should quickly see your idea, your method, your result, and your conclusion.
The same applies to presentations. You do not present only code. You present the problem, the idea, the result, and the reasoning. This is how technical work becomes useful to other people.
What you remain responsible for
You are responsible for every submitted sentence, figure, result, and line of code. You must be able to explain:
- what problem you solved;
- what algorithm or data structure you used;
- why it is appropriate;
- what its complexity is;
- how you tested it;
- what help you used, including substantial AI help.
If AI, online sources, classmates, or books substantially shaped your solution, cite that help. Citation is not a punishment. It is how honest technical work is done.
A practical learning loop
For each homework or topic, use this loop:
- Try first: write down the problem, input, output, and constraints.
- Choose: name the likely algorithmic idea or data structure.
- Predict: estimate complexity and possible edge cases.
- Implement: write code, with or without tool support.
- Test: use small examples, random tests, and cases where you know the answer.
- Explain: write the reasoning, results, and limitations in your own words.
- Reflect: ask what you would do differently for larger input or stricter constraints.
AI can help in every step, but it should not replace the thinking in any step.
The course promise
After this course, you should be better at entering unfamiliar computational problems without panic. You should have a map of common algorithmic ideas, a sense of what scales, and enough critical judgement to use powerful tools without being fooled by them.
You should also be better at explaining technical work: briefly, honestly, and with enough evidence that another person can trust your conclusion.
That is the real point of Algorithmics in 2026: not memorising a list of algorithms, but learning how to reason, build, test, communicate, and keep judgement when the tools around us become more powerful.