Please sign in to access this page
June 20, 2025
Worked on adding a deployment github workflow..
I only have one devlog because I wasn't planning on adding this to SoM, but here we are.
A look under the hood at my two-day AWS hackathon project! A customer retention website complete with a dashboard and actionable interventions from inside the website directly. It's mostly just UI now, but the dummy features still work! This used to be a dashboard for a telecom company.
Created and added the Sieve of Eratosthenes algorithm! Awesome name
Got a new algorithm up and running; euclid's algorithm! Pretty cool thing to discover in 300 bc
Created and added the bucket sort algorithm! Although its niche, its a cool concept to know, thats why i included it :>
Good project i liked it :)
Worked deploying the project! Finally out now :>
Create and add the interpolation search algorithm :D
Created and added the binary search algorithm!
Created and added the linear search algorithm. :>
Added the quick sort algorithm, particularly difficult to get all of the states i needed together for this one, and i had to do a TON of designing ;-;
Added validation :D the project is ready for deployment :>
Created the profile page, complete with working functionalities. :> just need to do some validation and I should be good to go!!
Cleaned up routes, added an icon for the website, fixed the titles, and a whole lot more maintenance stuff :D
Was busy designing a simple profile page for the MVP. :>
bishop and pawn learning page completed :> almost ready for production :0
Created and added the learning page for the queen and king! :> just the pawn and bishop left now
Add the rook learning page to the project !
First devlog on my new project :> well not new, I've been working on this for quite a while, but thought i should share it here!
Added the different tactic board displays, fully available with animations! Completed the knight's learning page.
A medieval-style website where chess legends are honored, puzzles forge sharper minds, and players rally for early access to an epic story-driven Chess Storymode. (P.S: The app may need up to a few minutes to startup due to limited computing resources on the server)
Worked on the merge sort algorithm, still a while to go before I get the visualizer up and running though
Added the insertion sort algorithm!!
Worked on adding the bubble sort algorithm to the project! also finally finished the search :>
worked on the search design and implementation x-x creating a working search panel should not need this much work lol but at least its working now, and looking good :> still a few more kinks to fix and we're uploading it
Planning on implementing a searchbar! Worked on generating a json file worth of algolia records and re-indexing them in my project using a github workflow (I love automation) :>
Added a tab footer for enhanced navigation between different tabs :>
Added the tab footer component to the algorithm pages, for enhanced navigation between tabs, still got work to do though, i need to make sure it's only visible if the main tab header is out of view.
and still need to make it responsive ;-;
Finally remodeled the banker's algorithm theory, complete with self-drawn diagrams and detailed explanations to create a strong understanding of the algorithm :D
Added a blurry loading screen to show users if changing pages takes longer than 50ms! Also began working on remodeling the banker's algorithm :>
Updated the theory with better diagrams, less text, and optimized explanations for the round robin, fcfs and priority scheduling algorithms :D
Still need to update two more algorithms though
Created and added the C-SCAN algorithm to the project, a variant of the SCAN algorithm :>
Added the LOOK algorithm and created visuals for the C-SCAN algorithm in figma :>
Worked on creating a dynamically generated seek time graph using an svg! Lead to some pretty cool animations :>
Worked on adding the theory needed for the FCFS disk scheduling algorithm.
Figma figure development for secondary disk scheduling algorithms!
Added the optimal algorithm to the project!
Updated the generate:algorithm script to include additional questions and a final confirmation at the end! makes it so much easier to create a new algorithm, so much less to worry about :)
Added the logic for the other page replacement algorithms today, and worked on cleaning up some obsolete logic by refactoring my code :)
Finally finished the algorithm, as well as the component needed for my FIFO page replacement algorithm (and also others), pretty happy with how the project is turning out now :>
Added the theory part under the FIFO page replacement algorithm, I spent a good amount of time (3hrs+) designing the diagrams in figma, but for some reason it doesn't register :<
still made lots of progress though
Designed tons of diagrams for virtual memory management in figma, to properly explain how it works :>
Updated the readme for contributors, as well as the .vscode extenstions.json and settings.json files :>
Forgot to do a devlog yesterday! Added the worst fit algorithm and then proceeded to create a tabswitcher component to manage which tab to show and when (separation of concerns is important :>).
And so far today, I've created a script to create an algorithm template so that adding new algorithms is much easier. It adds a new route in the router and also creates a view file for the algorithm content itself. Great for contributors!
added the first fit algorithm logic, as well as the best fit along with the theory needed for each one :)
Worked on implementing and designing the visuals for the first fit algorithm, almost done! :)
Worked on adding the first fit algorithm, complete with better visuals to make it easier to understand (images made by myself in figma!)
Created a tab header component to switch between algorithm theory and algorithm visualizer, it was too crowded earlier and difficult to see the visualizer, but now it has its own dedicated space. :>
Deploy the project on github pages! :D
created a different layout for the navbar and sidebar in the page, create the home page, added in a footer, and finally created CI/CD workflows on github to automatically upload the built dist files to github pages. :)
cleaned up some comp code, made the banner update the active algorithm, added titles to each page, and updated the group tree to render from router routes instead of a different variable.
Today i made the navbar responsive and prettified it to ensure it looked good, i also added a button linking it to my github.
i decided to make the navbar sticky since it looked better, and then i just spent the rest of the day cleaning up my code and removing unnecessary features, like minimizing all of the menus.
was working on adding the logo and fixing the sidebar, but i was also really busy splitting the code for the new algorithm into components
also moved the actual algorithm logic to a composable so that the view was cleaner
okay so today i updates the readme of the project, and then i added the step by step version of the bankers algorithm :>
Worked on adding the inputs and the algorithm logic to the project! Took some time but i got it working with clean code :> now i need to figure out how im going to display the results .-.
so far, i've added the theory knowledge needed for the bankers algorithm under deadlock management, basically what are deadlocks, how they happen, what the bankers algorithm is and how it works. i've also included a step by step procedure on how the algorithm can be executed manually, along with some pretty neat diagrams :>
next, ill be working on the actual algorithm implementation, still not sure how im going to display the result though :/ need to put some thought into that one
Ran into a weird bug when switching between different process arrival setups in the Gantt chart, when going from all processes arriving at time 0 to staggered arrivals like 1, 2, 3, 4. The UI broke because entry[1] became undefined during the switch, causing the process bar component to crash.
Tracked it down to 2 computed() statements, where i used a plain consts instead ;-;
Now the component handles consecutive runs without crashing, even if the data structure changes drastically.
i also added the shortest job first algorithm , pretty simple to do considering i already had the model for the fcfs and priority algorithms. but it was repetitive logic which ran in all 3 components so i created a composable to extract the logic and generalize it, much cleaner now :)
Started working on the Priority Scheduling algorithm today!
In this version, each process is assigned a priority number. The lower the number, the higher the priority. So instead of just going by arrival time like in FCFS, the CPU picks the process with the highest priority among the ones that have arrived.
It was fairly simple as I already had the FCFS algorithm, all I needed to do was sort the queue based on the priority given to it whenever a new process arrived.
Got the first come first serve (FCFS) algorithm working today!
The core of the algorithm is in, it loops through each millisecond of time, checks which processes have arrived, and runs them one by one in the order they showed up. Just like the name says: whoever comes first gets the CPU first, no interruptions.
One small bug I ran into was with the current process getting reset every loop, so each process was only running for 1ms before disappearing 😅. Turns out I was re-initializing currentProcess inside the loop and using an empty array instead of null, which made my condition checks fail. Once I moved it outside and properly tracked whether a process was still running, everything started falling into place.
Devlog: Gantt Chart Legend + FCFS Progress
First, I finally added a legend to the Gantt chart for the Round Robin scheduling algorithm. It was something I’d been meaning to do for a while to make the chart more readable. Now each part of the process is clearly identified, so it’s way easier to understand what’s going on at a glance.
After that, I started working on the next scheduling algorithm: first come first serve (FCFS). I’ve set up the main overview section, which explains how FCFS works and what makes it different from Round Robin. The UI and logic are still a work in progress, but the base is there and it's coming together nicely.
More updates soon once FCFS is fully wired up and visualized!
An open-source website explaining different types of algorithms, with step by step illustrations and results for any data you'd like to try the algorithm with!
This was widely regarded as a great move by everyone.