Algorithmic workshop, escaping AI sludge, vibe code for PMs, 10 UX evolutions for 2026

Understanding algorithms is essential for any digital professional. This practical workshop introduces you to algorithmic thinking through concrete and progressive exercises.

What is an algorithm?

An algorithm is a finite sequence of precise instructions for solving a problem. It's a recipe that the computer can follow step by step.

Characteristics of a good algorithm

• Accurate Each step is unambiguous.
• Finished It concludes in a limited number of steps.
• Effective : it uses resources optimally
• General It works for a class of problems

Exercise 1: Cooking Recipe

Issue

Write the algorithm to cook pasta.

Solution

START 1. Fill a saucepan with water 2. Place on the stove 3. UNTIL the water is boiling, turn off the heat 4. Add salt 5. Add the pasta 6. Start the timer (time indicated on the package) 7. UNTIL the timer is finished, turn off the heat 8. Taste the pasta END

Concepts introduced

• Sequence of instructions
• WHILE loop
• Variable (cooking time)

Exercise 2: Find the maximum

Issue

Find the largest number in a list.

Pseudocode solution

FUNCTION findMax(list) max ? first element of list FOR each element of list DO IF element > max THEN max ? element END IF END FOR RETURN max END FUNCTION

Concepts introduced

• Accumulation variable
• FOR loop
• IF condition
• Comparison

Exercise 3: Selection Sort

Issue

Sort a list of numbers from smallest to largest.

Principle

1. Find the minimum value in the list
2. Place it in first position
3. Repeat with the rest of the list

Solution

FUNCTION sortSelection(list) FOR i FROM 0 length(list) - 1 DO indexMin ? i FOR j FROM i + 1 length(list) - 1 DO IF list[j] < list[indexMin] THEN indexMin ? j END IF END FOR swap list[i] and list[indexMin] END FOR RETURN list END FUNCTION

Complexity

This sorting method has a complexity of O(n²). For large lists, more efficient algorithms exist (merge sort, quicksort).

Exercise 4: Dichotomous search

Issue

Finding an element in a list sorts.

Principle

Divide and conquer: compare with the middle element, then search in the relevant half.

Solution

FUNCTION searchDicho(list, target) left ? 0 right ? length(list) - 1 WHILE left ≤ right DO middle ? (left + right) / 2 IF list[middle] = target THEN RETURN middle ELSE IF list[middle] < target THEN left ? middle + 1 ELSE right ? middle - 1 END IF END WHILE RETURN -1 // Not found END FUNCTION

Efficiency

Complexity O(log n): for 1 million elements, a maximum of 20 comparisons!

Application: Avoiding algorithmic sludge

Ethical algorithms

The same principles apply to interface design: an algorithm that intentionally complicates a user journey is coded sludge.

Design checklist

• Is my algorithm fair to all users?
• Does it treat actions and their inverses in the same way?
• Is it transparent about how it works?

Key points to remember

1. An algorithm is a sequence of precise and finite instructions.
2. Basic structures: sequence, condition, loop
3. Complexity measures efficiency (O(n), O(n), O(log n))
4. Sorting and search algorithms are fundamental
5. Thinking in terms of algorithms helps in designing logical interfaces.