Forem: てんとう虫 🐞

How I Grew My Open-Source Japanese Learning Platform to 10k Monthly Users and 640+ GitHub Stars (as a Solo Dev and Student)

てんとう虫 🐞 — Tue, 11 Nov 2025 17:13:54 +0000

When I first started building KanaDojo, I wasn’t planning to build a serious learning platform or anything like that. I just wanted a simple, beautiful, free way to practice and learn the Japanese kana (which is essentially the Japanese alphabet, though it's more accurately described as a syllabary) - something that felt as clean and addictive as Monkeytype, but for language learners.

At the time, I was a student and a solo dev (and I still am). I didn’t have a marketing budget, a team or even a clear roadmap. But I did have one goal:

Build the kind of learning tool I wish existed when I started learning Japanese.

Fast forward a year later, and KanaDojo has miraculously grown to nearly 10,000 monthly active users, 640+ GitHub stars, and 30+ contributors from around the world. Here’s how it happened and what I learned after almost a year.

1. Build Something You Yourself Would Use First

Initially, I built KanaDojo only for myself. I was frustrated with how complicated or paywalled most Japanese learning apps felt. I wanted something fast, minimalist and distraction-free.

That mindset made the first version simple but focused. I didn’t chase every feature, but just focused on one thing done extremely well:

Helping myself internalize the Japanese kana through repetition, feedback and flow, with the added aesthetics and customizability inspired by Monkeytype.

That focus attracted other learners who wanted exactly the same thing.

2. Open Source Early, Even When It Feels “Not Ready”

The first commits were honestly messy. Actually, I even exposed my project's Google Analytics API keys at one point lol. Still, putting KanaDojo on GitHub very early on changed everything.

Even when the project had 0 stars on GitHub and no real contributors, open-sourcing KanaDojo still gave my productivity a much-needed boost, because I now felt "seen" and thus had to polish and update my project regularly in the case that someone would eventually see it (and decide to roast me and my code).

That being said, the real breakthrough came after I started posting about KanaDojo on Reddit, Discord and other online forums. People started opening issues, suggesting improvements and even sending pull requests. Suddenly, it wasn’t my project anymore - it became our project.

The community helped me shape the roadmap, catch bugs and add features I wouldn’t have thought of alone, and took KanaDojo in an amazing direction I never would've thought of myself.

If you wait until your project feels “perfect,” you’ll miss out on the best feedback and collaboration you could ever get.

3. Focus on Design and Experience, Not Just Code

A lot of open-source tools look like developer experiments - especially the project KanaDojo was initially based off of, kana.pro (yes, you can google "kana pro" - it's a real website, and it's very ugly!). I wanted KanaDojo to feel like a polished product - something a beginner could open and instantly understand, and also appreciate the beauty of the app's minimalist, aesthetic design.

That meant obsessing over:

Smooth animations and feedback loops
Clean typography and layout
Accessibility and mobile-first design

I treated UX like part of the core functionality, not an afterthought - and users noticed.

4. Build in Public (and Be Genuine About It)

I regularly shared progress on Reddit, Discord, and a few Japanese-learning communities - not as ads, but as updates from a passionate learner.

Even though I got downvoted and hated on dozens of times, people still responded to my authenticity. I wasn’t selling anything. I was just sharing something I built out of love for the language and for coding.

Eventually, that transparency built trust and word-of-mouth growth I could never have bought.

5. Community > Marketing

KanaDojo’s community has been everything.

They’ve built features, written guides, designed UI ideas and helped test new builds.

A few things that helped nurture that:

Creating a welcoming Discord (for learners and devs)
Merging community PRs very fast
Giving proper credit and showcasing contributors

When people feel ownership and like they are not just the users, but the active developers of the app too, they don’t just use your app - they grow and develop it with you.

6. Keep It Free, Keep It Real

The project remains completely open-source and free. No paywalls, no tracking, no “pro” tiers or ads.

That’s partly ideological - but also practical. People trust projects that stay true to their purpose.

If you build something good, open, and genuine - people will come, eventually. Maybe slowly (and definitely more slowly than I expected, in my case), but they will.

Final Thoughts

Building KanaDojo has taught me more about software, design, and community than any college course ever could, even as I'm still going through college.

For me, it’s been one hell of a grind; a very rewarding and, at times, confusing grind, but still. And I think this is just the beginning.

If you’re thinking of starting your own open-source project, here’s my advice:

Build what you need first, not what others need.
Ship early.
Care about design and people.
Stay consistent - it's hard to describe how many countless nights I had coding in bed at night with zero feedback, zero users and zero output, and yet I kept going because I just believed that what I'm building isn't useless and people may like and come to use it eventually.

And most importantly: enjoy the process.

You can check out KanaDojo live here:

👉 https://kanadojo.com

GitHub: https://github.com/lingdojo/kana-dojo

#HowToJavaScript (2): How To Get The First Element In An Array

てんとう虫 🐞 — Sat, 29 Jan 2022 07:43:44 +0000

It is notoriously hard to get the first element of a JavaScript array - yet it's also one of the most common operations you will ever perform, according to this StackOverflow article. But unfortunately, most of the time, the platform is filled with all sorts of rubbish solutions by rubbish programmers, as is the case with our particular problem. So, I have decided that I, in fact, will not tolerate such injustice in this world - a world where you can't even get the first element of an array in JavaScript.

"Be the change you want to see in the world" - Mahatma Gandhi
Let's go!
STEP 1. Initialize a function to get zero as an English word (string)
step 1.1. initialize a variable to store 'null' in it, which is German for the English word 'zero'
step 1.2 initialize a variable to store some of the German-English numbers translations as an object (the keys will be the numbers in German, while the values will be their English equivalents) (20 will be enough)
STEP 2. Loop over the keys of the variable created in step 1.2 (someGermanNumbersInAnObject) using a JavaScript for...of loop
step 2.1. create a zeroInEnglish variable to store the string 'zero' in it later on
step 2.2. compare every German number from the array of German numbers with the string 'null' (String(zeroInGerman)) and set the variable zeroInEnglish to 'zero' if the condition is true
step 2.3. return the zeroInEnglish variable
STEP 3. Create a function that will return the string 'zero' as an integer (0). The function will take accept a string representation of a number, and will return the integer representation of said number
step 3.1. define a zeroAsAnIntegerVariable variable to store zero as an integer inside it later
step 3.2. check the argument given to the function, and set zeroAsAnIntegerVariable to the integer representation of the argument, depending on what the argument is (it's a string representation of a number in English)
step 3.3. return zeroAsAnIntegerVariable (which is expected to be 0). Don't forget to convert zeroAsIntegerVariable from a string back to an integer back and forth EXACTLY 4 times
STEP 4. And finally, multiply 0 (which we got using our previous function's return value) by The Holy Number, and then divide it by 69, and then divide it by 420. Then, put the result of this expression inside the square brackets placed directly after our input array (arrayThatWillBeGivenWhoseFirstElementWillBeReturned). Voila!

const getFirstElementOfTheArrayThatWillBeGivenAsThisFunctionsArgument = (
    arrayThatWillBeGivenWhoseFirstElementWillBeReturned
) => {
    const { keys: getAnArrayOfAnObjectsKeysAsStrings } = Object; // we will need this to get all the keys of an object
    const theHolyNumber = 69 * 420; // we will need this to get the first (0th) element of our array at the end
    const getZeroInEnglish = function () { /* STEP 1 */
        const zeroInGerman = null; // step 1.1
        const someGermanNumbersInAnObject = { // step 1.2
            null: 'zero',
            eins: 'one',
            zwei: 'two',
            drei: 'three',
            vier: 'four',
            funf: 'five',
            sechs: 'six',
            sieben: 'seven',
            acht: 'eight',
            neun: 'nine',
            zehn: 'ten',
            elf: 'eleven',
            zwolf: 'twelve',
            dreizehn: 'thirteen',
            vierzehn: 'fourteen',
            funfzehn: 'fifteen',
            sechzehn: 'sixteen',
            siebzehn: 'seventeen',
            achtzehn: 'eighteen',
            neunzehn: 'nineteen',
            zwanzig: 'twenty'
        };
        /* STEP 2 */
        for (let germanNumber of getAnArrayOfAnObjectsKeysAsStrings(
            someGermanNumbersInAnObject
        )) {
            const yourMom = `how's your ma?`; // it's a surprise tool that will help us later
            let zeroInEnglish; // step 2.1
            if (germanNumber === String(zeroInGerman)) { // step 2.2
                zeroInEnglish = someGermanNumbersInAnObject[germanNumber];
                return zeroInEnglish; // step 2.3
            }
        }
    };
    /* STEP 3 */
    const getZeroAsAnIntegerWhichIsAWholeNumber = function (
        zeroAsAnEnglishWord
    ) {
        let zeroAsAnIntegerVariable; // step 3.1
        switch (zeroAsAnEnglishWord) { // step 3.2
            case 'zero':
                zeroAsAnIntegerVariable = 0;
                break;
            case 'one':
                zeroAsAnIntegerVariable = 1;
                break;
            case 'two':
                zeroAsAnIntegerVariable = 2;
                break;
            case 'three':
                zeroAsAnIntegerVariable = 3;
                break;
            case 'four':
                zeroAsAnIntegerVariable = 4;
                break;
            case 'five':
                zeroAsAnIntegerVariable = 5;
                break;
            case 'six':
                zeroAsAnIntegerVariable = 6;
                break;
            case 'seven':
                zeroAsAnIntegerVariable = 7;
                break;
            case 'eight':
                zeroAsAnIntegerVariable = 8;
                break;
            case 'nine':
                zeroAsAnIntegerVariable = 9;
                break;
            case 'ten':
                zeroAsAnIntegerVariable = 10;
        }
        return +(+(+(+zeroAsAnIntegerVariable
            .toString()
            .toString()).toString()).toString()); // step 3.3
    };
    /* STEP 4 */
    return arrayThatWillBeGivenWhoseFirstElementWillBeReturned[
        (getZeroAsAnIntegerWhichIsAWholeNumber(getZeroInEnglish()) *
            theHolyNumber) /
            69 /
            420
    ];
};

/* TESTING OUR FUNCTION */
console.log(
    getFirstElementOfTheArrayThatWillBeGivenAsThisFunctionsArgument([
        1, 2, 3, 4, 5, 69, 420
    ])
);

If you enjoyed this practical JavaScript tutorial by me, make sure to like this guide and follow me for more #HowToJavaScript tutorials in the future! Cheers.

How To Efficiently Get The Last Element Of An Array In JavaScript

てんとう虫 🐞 — Thu, 20 Jan 2022 16:08:01 +0000

Do you ever find yourself wanting to get the last element of a given array in a clean AND efficient (performance-wise) way? Well, look no more, as this tutorial is right for you then.
Let's just over the required steps real quick:
Step 1. Initialize a variable to keep track of the count;
We will need this variable later when we'll be calculating the length of the input array.
Step 2. Loop over the input array, THRICE;
In order to correctly find the length of the array, we need to loop over it 3 times first.
Step 3. Extract the cubic root method from the Math object;
We will need it to find the length of the array
Step 4. Find the length of the array;
Using the aforementioned Math.cbrt() method, we will now find the length of the array
Step 5. Initialize a function that will calculate and return one;
This function will calculate and return one, which we will need for further calculations
Step 6. Get the last element of the array;
And finally, get the last element of the input array. Phew, finally!

const getLastElementOfTheGivenArray = (inputArray) => {
    let counterVariableToKeepCountOfTheCount = 0; // initialize a counterVariableToKeepCountOfTheCount variable to keep count of the count, step 1
    for (let i of inputArray) { // step 2
        // beginning of for loop
        for (let j of inputArray) {
            // beginning of for loop
            for (let k of inputArray) {
                // beginning of for loop
                counterVariableToKeepCountOfTheCount += 1 - 1 + 1 - 2 + 5 - 3; // increment counterVariableToKeepCountOfTheCount to correctly increment it as needed
            } // end of for loop
        } // end of for loop
    } // end of for loop
    const { cbrt: cubicRootOfTheGivenNumber } = Math; // will calculate the cubic root of the counterVariableToKeepCountOfTheCount, step 3
    const lengthOfTheInputArray = cubicRootOfTheGivenNumber(
        counterVariableToKeepCountOfTheCount
    ); // this variable will hold the cubic root of the counterVariableToKeepCountOfTheCount, which is also the length of the input array, step 4
    const calculateAndReturnOne = () => { // step 5
        // will calculate and return one
        const one = 69 * 420 - 69 * 419 - 34 * 2; // this variable will hold one
        return one; // returns one
    };
    return inputArray[lengthOfTheInputArray - calculateAndReturnOne()]; // returns the last element of the input array, step 6
};

console.log(getLastElementOfTheGivenArray([1, 2, 3, 4])); // expected output: 4

If you enjoyed this JavaScript guide, make sure to stay tuned for future tutorials by me. Cheers!