Welcome to my personal archive of Exercism exercises.
For me these exercises are less about grinding through exercises and more about going deeper: writing better code, understanding the language, learning best practices, and actually engaging with the community around it.
The goal isn't to complete every single exercise — it's to take the most out of the ones I do.
The thing that sets Exercism apart is the feedback loop. You submit a solution, a mentor reviews your actual code and points out what could be better, you refactor, and you compare with how other people solved the same problem.
That cycle — write → get feedback → refactor → explore alternatives — is very close to how growth actually happens in a real team.
But it's also about writing cleaner and more readable code, removing unnecessary abstractions, and it's about writing code that other developers can read and understand without needing to decipher it.
- Language Depth: Going beyond syntax, learning good practices.
- Mentorship & Community: Using feedback from real developers and other solutions as part of the learning process.
- Deliberate Refactoring: Revisiting solutions after seeing other approaches, not just submitting and moving on.
My priority when solving these exercises is readability and maintainability over cleverness. I'm not here to write impressive one-liners or abuse obscure language features — unless I find one genuinely interesting, which I might explore out of curiosity.
Exercism organizes everything by language track. Each track gets its own folder, and inside it one folder per exercise — that's just how the CLI downloads them.
exercism/
├── typescript/
│ ├── exercise-name/
│ │ ├── README.md
│ │ ├── HELP.md
│ │ ├── exercise-name.test.ts
│ │ └── exercise-name.ts
│ └── ...
├── javascript/
│ └── ...
└── README.md
README.md— the original problem statementHELP.md— Exercism's guidance file for the exerciseexercise-name.test.*— the test file (important — more on this below)exercise-name.*— my solution, sometimes with inline notes
Exercism's own docs cover the basics, but there are a few things that aren't immediately obvious — especially if you're coming from other platforms. This is my attempt at a clearer walkthrough.
Follow the official installation guide. It's straightforward.
Before you start downloading exercises, though, configure where you want them to land on your machine:
exercism configure --workspace=/your/preferred/pathYou can also locate the file and edit it yourself:
exercism configureWorth doing upfront — otherwise everything ends up wherever the default is and you'll reorganize later anyway.
On each exercise page, Exercism gives you a command to copy and paste directly into your terminal. It looks like:
exercism download --track=language-name --exercise=exercise-nameBefore touching any code, read HELP.md. It tells you what commands are available, how to run tests, and any relevant context for that exercise. Skipping it tends to cause unnecessary confusion.
Inside the exercise folder, run:
corepack yarn installThis is the step that's easy to miss — and it matters a lot.
The test file (exercise-name.test.*) is where you find out exactly what the exercise is asking for: what arguments the function receives, what the expected return type is, what edge cases are covered. The problem description in README.md gives you the concept, but the test file gives you the contract.
Read through it before you write a single line. It'll save you from going in the wrong direction.
corepack yarn testWhen you run this, you'll notice most tests show as SKIPPED. That's intentional — Exercism expects you to enable them one at a time as you implement each case.
To enable a test, open the test file and remove (or comment out) the skip from the test you want to run:
// Before
xtest('some test description', () => { ... })
xit('some test description', () => { ... })
// After
test('some test description', () => { ... })
it('some test description', () => { ... })Enable them progressively as you solve each case.
exercism submit exercise-name.*After submitting, go back to the exercise page on Exercism and mark it as complete. Once you do that, you unlock the community solutions. Look at how other people approached the same problem, especially the ones that are very different from yours.
Exercism is genuinely good. The mentorship model, the community, the focus on clean code — it's one of the more thoughtful platforms out there for actually learning a language rather than just collecting points.
That said, the onboarding experience can be a bit rough.
If you just read the problem description and start coding, you might spend a while confused about what's actually expected. The test file is where the real spec lives, and that's not made clear enough upfront. For someone just starting out, that friction could easily feel discouraging rather than challenging.
The manual test enabling is another thing that feels like it has room to grow. I get that running one test at a time can help you stay focused on a single case — and maybe there's a reason for keeping it manual that has more to do with the exercise authoring side than the user side, who knows?
But from a user experience perspective, there's no reason why the test runner couldn't just tell you exactly which test failed and stop there. You'd still know where to look, you'd still open the test file, you'd still explore.
More clarity and automation here wouldn't take anything away from the learning process — it would just remove unnecessary friction and improve the overall user experience, even more for beginners.
And I say that because it bothers me, my mind automatically goes: how do you make the experience smoother for someone who's never used the platform before, without dumbing it down or removing the exploration that's core to how developers actually learn?
You can follow my progress directly on the platform: @psudo-dev