Project reviews
Review by Marina Pankova (computer science teacher)
Review of Ivan Kochergin's project «Algolume: a step-by-step visualiser of competitive programming algorithms»
In his project Ivan covered some of the most popular competitive programming algorithms. They require not only an understanding of the technical implementation of the code but, most importantly, a visual representation of how the algorithm works. For each of the algorithms covered, Vanya chose the visualisation form that best reflects the algorithm's mechanics. The navigation buttons implemented in the project let you «travel» through the algorithm, which helps in grasping the program code.
Besides visualising how the algorithm works, Ivan's project also visualises the code itself — namely the state of the variable stack: every variable used in the code is listed, and its state is described at each step of the program's execution. This makes the process of interpreting the code transparent.
The integration of various visualisation technologies deserves particular mention. For graph visualisation Ivan uses the additional module pyvis, which allows interactive graph visualisations to be built. These observations point to the substantial work Ivan has done researching visualisation interfaces and choosing the best solutions.
Ivan's project will make it possible to teach the algorithms it covers far more visually. Moreover, the ability to explore one's own code is an important step not only in mastering a particular algorithm but also in developing algorithmic thinking in general. I plan to use Ivan's project in the Competitive Programming Preparation 2 classes, since these algorithms are part of the syllabus.
Suggested improvements:
On the algorithm interfaces:
- When the algorithm is launched, the problem statement — including the input format — becomes unavailable to the user, which may lead to incorrect input.
- No intuitive way to change the data in the input field was found. So far the only way is to reload the page.
- After typing the last input line you have to press Enter, otherwise the data on the last line is either not read (as on the DFS page) or erased (as on the Dijkstra page).
On the site itself:
- The Feedback link opens in the same window; it would make more sense to open it in a new tab, as is done for the GitHub link.
- On the home page I recommend a more detailed description of the project, including a description of the interface and what exactly «visualisation» of the algorithms means.
Recommendations for developing the project:
- I recommend adding a visualisation of binary search over the answer, using one of the classic problems, for example «Wires».
- I recommend adding a visualisation of the BFS algorithm – breadth-first search.
- It would be useful to add, for each algorithm, links to sites with a judging system where these algorithms can be practised. For example, a site with a large set of training problems: https://informatics.msk.ru/.
Review by Vladimir Gurovits (computer science teacher)
The project presented is intended to visualise algorithms in order to help school students master this difficult area. The site written for this purpose has sufficient functionality and a pleasant, attractive design. The UX is generally clear, though there are individual suggestions for improving it. Unfortunately, only a few algorithms have been implemented so far to demonstrate the site's capabilities. Putting the project into practice will require considerable further effort to fill the site with content.
The project is executed to a high technical standard; a great deal of work has gone into implementing the library for executing code and into displaying the interface conveniently on mobile devices.
Review by Irina Avdeeva (computer science teacher)
The project is a website visualising popular algorithms (DP, DFS, Dijkstra) that lets users not only study the theoretical foundations of the algorithms but also watch them execute step by step. This approach makes complex algorithmic concepts more accessible and understandable.
The project has high educational potential and will certainly be used in the competitive programming group when studying the relevant topics.
Thank you, Ivan, for the work you have done!
Review by Nikita Tokalov (competitive programmer)
Algolume.ru provides materials for studying various competitive programming algorithms. First of all, the pleasant interface and its responsiveness to screen size are worth noting: the content stays readable on a phone, a tablet and a laptop alike. It is also worth noting that the resource has a feature unique among its peers: visualising algorithms with any input data. That is a big advantage in studying them, because writing out, say, a dynamic programming table by hand for better understanding can be laborious, and the resource provides that possibility. The resource is also excellent for debugging your own programs, because it lets you visualise your own code (!). All the visualisations are implemented neatly and attractively, and the tables and graphs are easy to read.
Among the shortcomings, some wordings or explanations may be unclear to newcomers to algorithms; with the current explanatory texts the resource is rather better suited to those who already have an idea of algorithms but want a deeper understanding.
I think that if the resource keeps developing — adding various algorithms and building visualisations for them — Algolume could become indispensable to many for studying competitive programming.
Review by Grigory Noskov (competitive programmer)
A wonderful site, the interface is extremely clear and everything is explained in accessible language. A very interesting idea with the visualisation, and the interactivity is well implemented – you can see how the algorithms work with different input data. Thanks to this site I managed to understand depth-first search on a graph, for which I am very grateful.
To develop the project further, more different algorithms could be added to the site.
Review by Yuri Zvyagintsev from the chat (competitive programmer)
The problem with Dijkstra is that the graph jitters.
Did you write the visualisation yourself?
Maybe it would be better to take the open-source one from algocode?
The problem with the DP «turtle» is that on launch it immediately throws an error, because I have not managed to type anything yet and it is already trying to execute the input line.
Also, apparently, if you do not press Enter but press «Next», the input is reset. Not nice.
With DFS the graph jitters the same way. When the whole drawing flips at every step, and it can be large, that is inconvenient.
But everything works well.
It would definitely have helped at the start of studying these algorithms, since with DP the hardest part is understanding how the answer resolves into a specific path. The site solves that. And for checking samples too, instead of drawing them by hand.