Introduction
The Programming Task Library is a collection of practical exercises designed to improve problem-solving, analytical thinking, and software design skills.
The library is intended both for developers who are beginning their software development journey and for experienced developers who want structured technical practice.
Although the tasks were originally designed with Go and Rust in mind, the underlying problems are language-independent and can be implemented in other programming languages as well.
Purpose
The main goal of this library is not only to produce a correct result.
Each task should encourage you to think about:
- algorithmic efficiency
- execution performance
- resource consumption
- simplicity of the solution
- flexibility
- abstraction
- code organization
- reusability
A working solution is only one part of the exercise.
You should also consider whether the same problem can be solved with fewer operations, less memory, clearer abstractions, or a design that can be reused in other scenarios.
Think Before You Code
Before starting an implementation, analyze the problem first.
For more complex tasks, especially modeling tasks, it is recommended to draw the possible execution flows, relationships, states, or outcomes before writing code.
Do not immediately implement the first solution that comes to mind.
Instead:
- Understand the problem.
- Identify the inputs and expected outputs.
- Consider multiple possible solutions.
- Compare their complexity and resource requirements.
- Choose an approach.
- Implement it.
- Test and evaluate the result.
The objective is not to classify a task as easy or difficult.
The objective is to find an efficient and well-structured solution for the given scenario.
Library Structure
The library is divided into two major sections:
Algorithms
The Algorithms section contains seven groups.
Each group contains five tasks, for a total of 35 algorithmic exercises.
The tasks cover different types of problems involving data transformation, searching, filtering, grouping, sorting, combinations, validation, and other forms of algorithmic processing.
Modeling
The Modeling section contains six larger tasks.
These exercises focus on designing data structures, relationships, behavior, validation rules, queries, and complete domain models.
Compared with the algorithmic exercises, modeling tasks are intentionally broader and may require multiple types, components, and operations working together.
Programming Languages
The original task library was designed primarily for:
- Go
- Rust
However, unless a task explicitly depends on a language-specific feature, any programming language may be used.
When solving a task in another language, preserve the intended behavior, constraints, inputs, outputs, and validation requirements.
Approach
Treat every task as a small engineering problem rather than only as a coding exercise.
A good solution should aim to be:
- correct
- understandable
- efficient
- testable
- maintainable
- reusable where appropriate
Different implementations may solve the same task correctly.
The important part is being able to explain why a particular approach was chosen and what trade-offs it introduces.