Coder Social home page Coder Social logo

emilepharand / babilonia Goto Github PK

View Code? Open in Web Editor NEW
5.0 1.0 0.0 9.37 MB

πŸ“š Vocabulary-focused language trainer that empowers polyglots 🌎 to practice faster βŒ›, remember more 🧠 & boost their learning πŸš€

License: MIT License

JavaScript 1.94% TypeScript 73.82% HTML 0.38% Vue 20.79% Shell 3.01% Dockerfile 0.05%
language-learning languages polyglot vocabulary vocabulary-builder

babilonia's Introduction

Logo

build status Maintainability codecov

Babilonia is an innovative tool for language enthusiasts who want to expand their vocabulary and reinforce their memory of foreign languages. It seeks to unlock the power of vocabulary as a means to express your thoughts and understand languages. As your vocabulary improves, so do your language skills!

Babilonia helps you learn more words, faster. Also, unlike traditional methods, Babilonia lets you practice multiple languages at the same time! 😍

Features

  • Enables you to memorize a maximum amount of words in a minimum amount of time ⏳
  • Leverages muscle memory and visual memory as a mental boost 🧠
  • Contains clever tricks to help you remember words as you're typing πŸ’‘
  • Builds on top of partial knowledge of words πŸ“š
  • Tracks how many words you know in each language πŸ“ˆ
  • Allows you to focus on words you haven't mastered yet for personalized learning 🎯
  • Uses a novel method based on universal ideas ♾️
  • Lets you practice any set of languages all at once! 🀯

Powerful, targeted help

Learning works best when it's interactive. Babilonia works with what you know and builds up from there. It gives you instant feedback as you're practicing and helpful hints when you need them. In other words, it's like your own personal teacher!

As you're typing, Babilonia highlights your answer in red or green to let you know if you're on the right track. By steering you in the right direction, you assimilate information more easily. In fact, as you are the one who types the correct answer, it becomes part of your muscle memory.

Babilonia's approach is to help you remember on your own. Often, even if you don't recall a word, you still remember parts of it. It may be its first letter, its ending, or how it sounds. If you get a hint, the memory may well spring back to your mind. There's a good reason for the idiom "it's on the tip of my tongue"!

Instead of revealing the entire word, which would prevent you from remembering it by yourself, Babilonia gives you the next letter. Going from getting a hint, to typing what you know, to getting another hint is much more interactive and fun. Most importantly, this way of practicing makes you significantly more likely to remember more parts of the word the next time.

That is why we say that Babilonia rewards and builds upon partial knowledge. If you know some letters in a word, you can still get it partially correct. Remembering more letters means progress, even if you don't recall the entire word. That is very motivating, and it also lets you focus more on the letters that you actually didn't get right.

Of course, sometimes, you simply don't know. No need to go through hints then: you can get the complete word. After all, you do have to start somewhere!

A GIF is worth a thousand words

A polyglot's paradise

Babilonia lets you practice any number of languages at the same time. Most language learning tools only allow you to practice one language at a time. But what if you want to master multiple languages? It would be incredibly convenient to practice them at the same time, right? Babilonia enables you to do just that!

That comes with many benefits. For one, you get to exercise the mental gymnastics of quickly switching between languages, which is an invaluable skill for a polyglot to have. Also, you learn to associate between them the words in different languages to convey the same idea, which helps you remember them more easily. Plus, it's an incredibly efficient way to practice when you want to learn multiple languages.

Of course, even though you could practice tons of languages at the same time, it doesn't mean you have to! You can always choose which languages you would like to study. It could be one, two or any combination of languages. Flexibility is key.

Personalized learning

Mark expressions as "known" as you encounter them. Doing so allows you to get personalized learning, as you can tell Babilonia to make you practice only words that you have not yet mastered. That means you can focus on practicing what you actually need to learn and not repeat words you have already acquired.

Track your progress

Another benefit of marking expressions as "known" is that Babilonia can track your progress and show you statistics on how many words you have learned. Tracking your progress is key for staying motivated because you can see how much you have improved.

Seeing those numbers go up is, on its own, a worthwhile goal to pursue. It is also an excellent measure of your progress in any language and helps you compare which languages you know better than others and where to direct your efforts.

Ideas and expressions

Two interesting and helpful concepts that Babilonia uses are ideas and expressions. They are very simple yet powerful notions.

Ideas are universal

The concept of ideas is that words in one language are grouped with words in other languages that express the same idea.

While dictionaries organize vocabulary by words, Babilonia organizes vocabulary by ideas. There are as many ideas as there are meanings for a word.

For example, in English, you play music like you play a sport. Spanish conveys those two meanings with two different words: tocar and jugar. While an English-Spanish dictionary would list those two words under to play, Babilonia views them as two separate ideas. Learners practice them separately as they are two distinct entities.

That's because, in Babilonia, no language is the single point of reference. Every language has its quirks, similarities and differences. Thus, practicing multiple languages at the same time requires a universal system. In Babilonia, that system is the concept of ideas.

Expressions are more than words

Often, an expression is simply a word, like beer, cold, very, or to drink.

But it could also be a phrase, an expression, an idiom, a saying, or any other useful sentence. For example, these are all expressions:

  • how are you?
  • what's your name?
  • watch out!
  • the cost of living
  • it's raining cats and dogs

Expressions are the actual language elements that you type and practice in Babilonia.

Simplified keyboard input

When simultaneously practicing multiple languages that use different alphabets, typing the right letter with the correct accent in every word of every language can be impractical and add friction to your learning. Not only does that require you to change your keyboard settings a lot, but also to learn what specific combination of keys on your keyboard allows you to type each letter and accent.

That can add a lot of friction to your learning. Sure, mastering spelling is important, but if your goal is to practice as many words as possible, getting each accent right might not be your priority. Furthermore, many people find it valuable to first learn a new language without the added difficulty of accents.

To help with this, Babilonia allows you to disable "strict mode," which allows you to type the unaccented form of a letter instead of its accented form. This feature can save you time and effort, especially if your goal is to practice as many words as possible. Please note that this feature currently only supports languages using the Latin alphabet, but future releases will include ways to enable it for more scripts.

Use included vocabulary or add your own

As of version 2.1, the application comes with a set of 2751 expressions and 518 ideas in 5 languages: English, French, German, Spanish and Italian. More get added over time.

You can also easily add your own expressions, ideas and languages.

Keep in mind that while ideas and expressions in Babilonia may change in future updates, your database will remain unchanged. This means any additions, deletions, or modifications you make to the database will be preserved. However, to access new ideas and expressions, you'll need to use the new version of the database.

An important caveat

Vocabulary is only one part of language learning. That's why Babilonia does not seek to be the be-all and end-all of language learning tools. Nothing is. Learning languages requires a variety of sources. However, we believe that acquiring vocabulary is the single most important aspect of learning languages, which unlocks a world of possibilities.

How to use

Prerequisites

Make sure you have Node.js installed on your machine. Go to nodejs.org to download and install the latest version.

Installation steps

  1. Install Node.js if you haven't already.
  2. Download the latest release of Babilonia.
  3. Extract the archive.
  4. Open a terminal and navigate to the extracted folder.
  5. Run npm install.
  6. You can now use the application!

Running Babilonia

Once you have installed Babilonia, you can run it by following these steps:

  1. Start the application by running node index.cjs or npm start.
  2. Open your web browser and navigate to localhost:8000.

That's it! You're now ready to use Babilonia. If you encounter any issues, make sure to check the project's documentation or report them on GitHub.

The database is a SQLite file called db.db. It is created automatically if it does not exist. If you want to start with a fresh database, simply delete the db.db file and restart the application.

License

This project is licensed under the terms of the MIT License.

Can I contribute?

Of course! Feel free to open an issue or make a pull request.



People often say that motivation doesn't last. Well, neither does bathing β€” that's why we recommend it daily. - Zig Ziglar

babilonia's People

Contributors

dependabot[bot] avatar emilepharand avatar snyk-bot avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar

Watchers

 avatar

babilonia's Issues

Parentheses (context)

Add support for using parentheses in expressions to provide context when needed.

For example, to play (soccer) vs to play (music).

  • Content inside parentheses is completely ignored when practicing
  • Hidden expressions must show their context
  • Adding/editing ideas must not allow adding expressions that have
    • An unmatched opening parenthesis
    • An unmatched closing parenthesis
    • A second opening parenthesis before the first one is closed
    • An expression with only context
    • Empty context content
    • Reflect those changes in the UI
  • Adding/editing ideas should trim context (remove spaces after opening parenthesis and before closing parenthesis)

Searching needs to take into account context, but that will be done in #20.

Language layouts/templates

Implement language layouts when adding ideas.

For example, fr, fr, en, en, es, es could be one template, and fr, fr, cn, cn could be another one.

Partially revealing expressions

Instead of completely hiding an expression, asterisks would reveal its length and give away some letters.

For example, if the word is strawberry, s*r**b*r*y or s_r__b_r_y could be displayed.

  • Show asterisks of hidden expressions to know their length
  • Hint middle/last/random letter (not necessarily the next one)
  • Automatically reveal random parts of expressions when it appears
    • Customizable: 100% random, minimum/maximum revealed letters, only first/middle/last
    • How should that impact stats (#2)?
  • For one idea, button to reveal all expressions, some, random, letters, etc.
  • Show context in hidden expressions
  • Allow to enter any letter of an expression

More contextual help

There should be more help provided to the user across the application.

Each page should contain tool tips.

Users should not be required to read the docs to use the application.

It should be intuitive, self-explanatory and provide enough help.

We also need a FAQ.

Shortcuts

The application should have shortcuts to improve usability and efficiency, for example:

Practice

  • ctrl+h to get a hint
  • ctrl+s to show the expression
  • ctrl+n to focus nth row
  • ctrl+r to reset
  • ctrl+c to copy the current expression to the clipboard

Navigation

  • ctrl+shift+s to go to settings

Mobile

Similarly, on mobile devices, we could use things like gestures, swiping, pinching, tapping, double-tapping, shaking, long-pressing. or even voice commands.

We may even have a mode where you can use the application fully by speaking.

Extra information on expressions

Add extra information on expressions.

They could be fetched from an open-source API or an AI, on-the-fly or stored.

For example:

  • Dictionary definition (including part of speech: noun, verb, adjective)
  • Pronunciation
  • Synonyms and antonyms (if that expression exists in the app, link to it)
  • Part of speech (e.g. noun, verb, adjective)
  • Inflections (e.g. conjugations for verbs, declensions for nouns)
  • Etymology (i.e. the history and origin of the word)
  • Alternate spellings or forms
  • Translation into other languages
  • Images, pictures or illustrations
  • Related words or phrases
  • Word frequency or popularity data
  • Word classifications or categories (e.g. slang, colloquial, formal)
  • Information on how the word or expression is used in different regions or dialects (e.g.: UK vs USA)
  • The difference between two expressions in the same idea. For example, similarities and nuances between all and every.
  • Further explanation and information on a word
  • Mnemonic devices, such as acronyms or rhymes
  • ...

Alternatives within expressions

Some expressions could contain alternatives within them. The advantage between that and having two distinct expressions is when the difference is small, e.g. only on one word.

For instance, (this is maybe not a very good example), extracciΓ³n de una diente//muela, where // denotes the alternative spelling.

In that case, diente would be accepted just as well as muela.

If we do this, we might need to find a better syntax than // because an alternative might be multiple words.

As of now, I am not sure if this feature is useful enough to be implemented, but I am opening this issue for future reference.

Also, the user only practices one alternative, which is not ideal.

Less rows button

Add Less rows button on the add idea page (instead of only More rows).

Make the app mobile-friendly

The app needs better mobile support.

It should work reasonably well in all resolutions.

Add tests accordingly.

Autocomplete hint

Add an option when practicing to have an expression already revealed but in a lighter tone, like a "placeholder" on an input.

The placeholder stays as you type.

For example, the expression is hola and you type h. ola appears but in a lighter tone. You can then type o, l, and a.

image

  • The green/red feedback still works the same
  • Customizable per language

Very useful when you are just starting out in a language.

Statistics

Provide detailed statistics.

All of this must be very customizable.

Those stats could be used to tailor the practice to the user. For example, an expression that was failed many times could be shown more and an idea that was completed without help could be shown less.

  • Total known ideas (global + per language)
  • Total known expressions (global + per language)
  • Expressions fully written in practice mode in the last X days
    • Excluding hints? Tolerance of one letter, two letters?
    • Tolerance for errors too (wrong letter)
    • Handle resets: if a user gets an expression right, resets the table, and gets it right again, it counts as one.
    • Reset after X days without writing it
  • Percentage of correct letters to incorrect letters, hints given, etc.
  • Seen
    • Total "seen" ideas and how many times
    • Total "seen" expressions and how many times
  • Performance stats
    • Average time per letter, per expression, per idea, per language in practice mode
    • Timed practice
    • Turn it on and off on demand
  • Some ideas could be opt out from stats
  • Charts of all sorts
  • For each idea and expression:
    • How many times it was seen, practiced, gotten right and wrong
    • How many times it was completed without help
  • Overall accuracy and error rate, across all languages
  • Accuracy and error rate per language, to compare performance between languages
  • Time to completion, to measure how quickly the user is able to complete an expressions or an idea
  • Total number of hints, solutions, and other aids used, to track the user's reliance on support mechanisms
  • Total number of errors and corrections made, to identify areas for improvement
  • Overall score or rating, based on a combination of the above metrics, to provide an overall assessment of the user's performance
  • Trend analysis, to track changes in the user's performance over time and identify areas of improvement or decline

There needs to be some definition of having an expression partially right. If it's 10 letters long, and you need the first 2 or 3 to remember the rest, you clearly know it more than one for which you need 8 or more of them.

Set up continuous delivery and deployment

Continuous delivery

The pipeline should be able to build releases and add them to GitHub with each push to the release branch (the version should be in the commit name).

Continuous deployment

When #27 is done, the pipeline should be able to deploy each push on the development branch to the dev environment.

When #6 is done, the pipeline should be able to deploy each release to the demo environment.

More powerful search

The search feature needs to have more options.

  • Use fuzzy search or approximate matching algorithms, such as edit distance or n-grams, to allow users to search for words even if they are spelled slightly differently or contain errors
  • Starts with, ends with, contains
  • Filtering and sorting (#18)
  • Synonym search
  • Stemming search
  • Phonetic search
  • Omnibar/Omnibox (natural language search commands)
  • Wildcard characters, regular expressions, boolean operators
  • Better paging
  • Provide suggestions for alternative or similar words or phrases
  • Use machine learning algorithms and techniques, such as word embeddings or vector space models, to provide more intelligent and relevant search results, based on the user's previous searches and interactions with the app.
  • Allow users to save, bookmark, or tag their search results
  • Save search history

Explore Elasticsearch and OpenSearch.

UI improvements on the practice page

  • Reset only one expression instead of whole idea
  • Don't allow typing letters before already confirmed letters
    • For example: word is hola and you have hol. you can't add a letter at the beginning and type ahol.
  • Better handling of multiple expressions for one language
    • When there are multiple expressions in a language for an idea, when you type a letter, it should automatically check each row to find a match, not just the row you are on. If there are multiple matching expressions, they all show in green.
  • Block cursor going left or clicking in the middle of an expression (it should go straight to the end). It doesn't make sense, and right arrow focuses hint and show buttons.
  • Block double-clicking on an expression to select it, but add an option to copy it to clipboard
  • Longer expressions don't fit completely
    • Scrolling or sliding input? Enter a longer expression by scrolling or "sliding" through the input field
    • Multi-line input field (textarea)?
    • Resizable input field? Allow the user to adjust the size of the input field. Drag handle or other interface element that allows the user to easily resize the field.
    • #36 will likely need this
  • The hint and show button should not type, but instead show in lighter tone (like #14 ) so the user can type it themselves
  • Add a setting to automatically go to next idea instead of having to click next
  • #13
  • #14
  • #19

Idea drawing settings

Add more modes for which ideas are drawn in practice mode.

  • RANDOM is actually RANDOM_REMAINING, so it needs to be renamed.
  • Completely RANDOM
  • When #1 is done, the user can select from which set(s) ideas are drawn.
  • Incrementing the index should be done on next fetch so that if the user refreshes the practice page without practicing it, they should see the same one

Improve error handling

As much as possible, the back-end should do all the validation and return errors when there are.

Front-end and back-end should not duplicate validation.

Explore the possibility of throwing exceptions (errors) directly in the validation function with the right message to show to the user.

The back-end would catch those errors, send its message with a status corresponding to the type of error and the front-end would just show them.

Also, unexpected errors need to be better handled by showing a generic system error message to the user.

Errors need to be clear for the user, especially how to fix them. For example, parenthesis handling.

Vulgar and offensive words

Vulgar and offensive words are a special problem.

On the one hand, learners usually want to know about them. They are very likely to encounter them and need to know what they mean.

Therefore, such words have their place in Babilonia, as they are part of the language ecosystem.

On the other hand, some users may be offended by such words. Seeing them would degrade their experience and we need to respect that.

Therefore, they need to be handled in a different manner. First, they need to be flagged as such. Then, a setting (off by default) allows the user to enable them if they want to see them.

Also, a visual cue needs to be put next to the idea, letting the user know it is vulgar. (#18)

#1 may help with this.

More interactive and helpful add/edit ideas feature

Adding ideas should be more interactive and helpful.

  • Spellchecker
  • Synonyms (and whether they already exist in the database)
  • Automatic translation (suggest expressions in other languages)
  • Similar expressions
  • Similar ideas (hard to determine, may not be reasonably feasible)
  • Pre-filling using some API or AI (#409)

Once we have implemented a way to identify potential idea duplicates, we should open another issue to identify potential those already present in the database. This could take the form of an option on the search page.

A way to implement this would be to show a warning or tooltip next to expressions.

More control for practiceable languages

  • Choose which languages to practice, which to show and which to hide completely
    • Currently you can choose which languages you want to practice.
    • For a given idea, that will make you type expressions in that language, and show all other expressions.
    • That becomes a problem as there are more and more languages
  • Add a Random button in languages page
    • Languages are reordered randomly and practice languages are random too
  • Random practice
    • When practicing, each Next yields random results (practice languages, etc.)

Non-latin scripts

Non-latin scripts need better support in Babilonia.

The practice feature needs to fully work with non-latin scripts.

Non-strict character mode

Normalization in relaxed character mode doesn't work properly for some characters. For example, Ε“ (oe should be accepted) and ß (ss should be accepted). ? should be accepted for ΒΏ.

Keyboard layout

The keyboard layout poses two problems. First, people may not necessarily know how to use their keyboard to type non-latin scripts, nor do they necessarily own a keyboard providing that layout. Also, even if people did, they may not always want to switch keyboards constantly when practicing, especially when practicing a large number of languages at the same time.

Here are some solutions to this problem.

Virtual keyboard

Develop a virtual keyboard with the necessary layout for each non-latin script. This keyboard could be accessed within the app, allowing users to easily type in the correct script without needing to switch physical keyboards or learn a new keyboard layout.

Romanization

Non-latin scripts often have a romanization form, which is more or less standardized.

For example, Chinese has pinyin, Arabic has arabizi, etc.

  • The user could start typing a romanized latin letter and get a suggestion of matching non-latin letters, which they could then select.
    • Google Translate has a nice implementation :
      image
  • Each expression could have a native form and a romanized form. Both would be accepted forms. This would allow learners to type in the romanized form of the words and phrases they are practicing, and see them automatically converted to the correct script as they type. Since one symbol in a language may correspond to many letters when romanized, the latin letters could appear in green as long as they match and then be converted when the full symbol is matched.
  • It is important to have both the native character and the romanized version so as to practice the pronunciation.
  • An Arabic keyboard using that technique can be found at http://www.arabic-keyboard.org/

Give instructions

We could provide clear instructions on how to type in the correct script using the user's physical keyboard, including any necessary special characters or key combinations.

Logograms (ex.: Chinese characters)

Partial matching

Implement a system for displaying logograms in a way that allows for each individual component to be marked in green or red, providing feedback to the user as they type. This could involve dividing the logogram into its individual components and highlighting them individually, or using other visual cues to indicate which parts of the logogram are correct.

For example, 爱 can be decomposed into 爫, ε†–, 𠂇, ㇇ and ㇏. Stroke order must be respected.

Drawing

Offer a handwriting recognition feature, allowing users to practice writing the characters by hand and receiving feedback on their accuracy.

Articles, grammatical gender, plural, conjugation and tone

How to handle articles (the/a), grammatical gender, plural, conjugation and tone?

They are all forms of the same basic expression. We don't want to count, for example, all conjugations of a verb as distinct expressions.

However, it definitely needs to be practiced. Muscle memory is a core part of Babilonia, so all forms need to be practiced. For example, after practicing der Apfel many times, Apfel becomes mentally bound with der.

Since not all languages have them or use them the same way, it's hard to have a generalized solution.

An important use case for articles is to know the grammatical gender (la pomme in French). For example, la pomme makes it obvious that the word is feminine. However, some words such as l'eau don't reveal the gender. une eau might work, but that's only for one language and for one word.

If we sometimes show the definite and sometimes the indefinite article, it still doesn't cover all cases. In Spanish, there is an example where none reveals it: el agua/un agua (actually feminine). One possibility is to add an indication for gender, for example l'eau [f]. The user then has to enter somehow the gender. For muscle memory, example sentences (issue to be opened) will help a lot.

Another use case is that the definite and indefinite articles mean two different things. Showing sometimes the definite and sometimes the indefinite is probably the best approach.

Articles (the/a), grammatical gender, plural, conjugation and tone could be "metadata". They are considered forms of the same expression and any form can be practiced at any moment. All forms must be accessible through any other form of the same expression.

Somewhat related is the question of how to handle the English infinitive. Repeating to in each one is a little repetitive. But it may not feel natural to translate aller with go and not to go.

Refactor tests

Tests need to be refactored.

  • Fix tight coupling. Each test should be self-contained and not share data with other tests.
  • Better scope tests (do more tests with each test doing less) which will also increase readability.
  • Reduce duplication and increase reusability by combining similar logic in adding and editing ideas. When a feature or a check is added to adding/editing ideas only one place should have to change.
  • Use component testing where it is more appropriate than E2E testing.
  • Enforce stricter ESLint rules in tests

Use best practices

Confirmation modal when deleting a language

There should be a confirmation modal when deleting a language.

It should make very clear that it is a destructive action.

All expressions of that language are deleted and that action is irreversible.

Bulk edit / delete

Add a feature to edit or delete ideas in bulk.

That could make it faster to add new languages.

Extra/Advanced expressions

Some ideas and some expressions should be treated differently.

Here are some examples :

  • A less used, more literary expression, that makes sense only in a language
  • A specific idiom that exists in a specific language, and doesn't need to be practiced in other languages
  • Words don't have a direct translation in other languages

To address this:

  • Add an option to tag an expression as extra/advanced (opt-out from practice).
  • Add a flag for ideas that say Only show this idea in language X

In the options, you can either:

  1. Hide them
  2. Show them as non-practice expressions (don't hide)
  3. Practice them

Backup/restore, import/export all data

Backup (import / export all data): languages, ideas, settings, stats, etc.

A page lists previous backups and allows to to restore from a snapshot or create a new backup.

UI improvements for adding/editing ideas/languages

  • Up/down/Left/Right arrow navigation between inputs and buttons like on the practice page
  • Pressing enter should save
  • Always focus first input
  • When adding rows, focus next empty expression
  • When deleting an idea or a language, the modal that opens should focus the cancel button and right/left arrows navigates between confirm and cancel buttons

Let the user mark an idea as known

With this feature, a user can mark an idea as known, meaning they will not be shown it for a period of time (or never, this could be customizable).

This is useful for a learner that is advanced in a language and does not want to practice basic expressions.

The idea will appear in stats as completely mastered (#2).

Also related to #17, as we do not want those ideas to be drawn.

Passive mode

When the user sets all languages as not practiceable, the practice page says no practiceable ideas were found.

We should offer a "passive mode", a setting where all ideas are simply shown and you don't have to write them.

Tags / Sets / Themes / Categories

Data sets are groups of ideas and languages. Ideas can be in multiple sets.

Sets could be themes (useful while travelling), categories (animals), or pretty much anything.

They could also be used to create beginner, intermediate and advanced expressions sets.

It may be helpful to think of sets as tags on ideas. Some could have no tag at all, and others many.

It might be better to have tags on expressions themselves. But a quick way to tag all expressions in an idea.

Some tags can only be associated with some languages (ex.: Core German Expressions), and need to be unlocked for other languages for the user to be able to tag expressions in other languages with it.

  • Create and update sets
  • Each set could have a description
  • Add ideas from any set to any other. Merge sets. Try to minimize the risk of duplicate ideas.
  • Composite sets ("supersets" composed of multiple sets)
  • Switch between sets. When the user switches, only data in that set is shown.
  • Many sets can be selected (i.e.) ideas from all those sets are shown
  • Sets can be disabled, which means they are not shown
  • Tags can be enabled or disabled on a per-language basis, which means they are only shown when practicing specific languages
  • Add starter sets (idea packs?): data sets the user can choose when first installing Babilonia
  • (Brainstorm idea) When all expressions in a set (ex: beginner set) are set as "known", you "unlock" other expressions for more advanced sets
  • Statistics per data set
  • Import / export
  • Analysis to find patterns (auto-tagging?)
  • Organize sets: search, sort, filter, etc.

One way to handle this is to have tags.

Tags may offer more flexibility when organizing ideas, as some could have no tag at all, and others many.

Meta-tags could contain a set of tags. If you assign an idea to a meta-tag, all of its sub-tags are automatically assigned to that idea.

Gamification

Some elements of gamification could be added to the app.

  • A point/coin/token system, where points are won by getting expressions right
  • Time boxing, where a countdown appears and you get rewarded based on your time performance
  • Awards, badges and achievements
  • Storytelling that showcases a word
  • Engaging or funny content, such as jokes, memes, videos, audio recordings, images, or animations
  • Mini-games, quizzes, puzzles, lessons, exercises, or challenges
  • Social features, such as sharing progress and accomplishments on social media
  • Personalized feedback, suggestions, and recommendations, based on the user's progress and preferences

Related to #2.

Slowness in Cypress tests on the practice page

When running Cypress tests for the practice page, there is a lot of lagging, especially when pressing hint, show and reset buttons, which significantly slows down tests.

This might be fixed by #3.

Clean up config files

  • package.json
    • Check if some dependencies are not needed anymore and remove them.
    • Update all required dependencies to the latest version.
    • Validate whether --experimental-* flags are still needed and if so, document the reason why.
  • eslintrc
  • ...

Paging in search

Search needs to have paging.

Currently search will return arbitrarily large number of results, which is non-practical.

Categories, tags, themes

Maybe that use case is already covered by #1.

Tags may offer more flexibility when organizing ideas, as some could have no tag at all, and others many.

Meta-tags could contain a set of tags. If you assign an idea to a meta-tag, all of its sub-tags are automatically assigned to that idea.

Badges

Related to #29 and #26.

Add relevant badges to the README.

Write a README

Write a complete README that should serve as a good presentation of what Babilonia is and how to use it.

This should be a living document that evolves as new features are added and modified.

Set aside some ideas

When the user feels like an idea is too advanced and wants to focus on more basic words, they can set them aside (so they are not practiced) and reactivate them later.

Might not really be needed if we add a feature with beginner sets (#146).

Conversely, users could mark a specific expression as "Please show me this expression again soon." if they feel like they need to practice it again.

Maybe when #1 is done, we could add those to a special set that would be excluded from practice.

Context saving when changing page

There should be more context saving when switching between pages.

For example, if you are creating an idea, and you change the page, and come back, what was there should still be there.

This should also work when using the browser forward and back button.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    πŸ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. πŸ“ŠπŸ“ˆπŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❀️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.