Dhicode: Envisioning a Dhivehi Programming Language

Sample project : https://github.com/siyamex/DhiCode
Imagine typing program feshun instead of main(), or yakeen nuvatha dhogu instead of boolean. Picture young Maldivians learning the fundamentals of logic and code not through English commands, but through instructions rooted in their own mother tongue: Dhivehi. This is the vision behind Dhicode, a hypothetical programming language designed entirely around the Dhivehi language and its unique Thaana script.

But the important question is: Is creating Dhicode actually possible?

The short answer is yes, technically, it is absolutely possible. Programming languages are human-made constructs with defined rules (grammar and syntax). There's no inherent technical limitation preventing the creation of a language based on Dhivehi keywords and structure.

However, the longer, more realistic answer is: Yes, but it's an incredibly complex, challenging, and resource-intensive undertaking. While possible in theory, building a practical, usable Dhivehi programming language involves overcoming significant hurdles in linguistics, computer science, and community building.

Let's explore what it would take to bring Dhicode from concept to reality.

1. Designing Dhicode: The Foundational Choices

Creating any language starts with design. For Dhicode, key decisions would include:

• Keywords: This is the most immediate aspect. We need to choose unambiguous Dhivehi words for core programming concepts. For example:
  • if: ތިބެންޏާ (thibenyyaa) / ނަމަ (nama)
  • else: އެހެންނޫނީ (ehen'nooniee) / ނޫންނަމަ (noon'nama)
  • while: ހިނދު (hindhu) / އިރު (iru)
  • function: ކަންތައް (kan'thah) / ވަޒީފާ (vazeefaa)
  • variable: އެއްޗެއް (ehcheh) / ނަން (nan)
  • print: ދައްކާ (dhakkaa) / ލިޔާ (liyaa)
  • true: ތެދު (thedhu)
  • false: ދޮގު (dhogu)
    These choices need careful consideration to avoid ambiguity and feel natural within a coding context.
• Syntax Structure: Should Dhicode follow the Subject-Object-Verb structure sometimes found in Dhivehi, or adopt the more common structure of English-based languages (like Python or Java) simply substituting keywords? The latter is far easier to implement with existing programming tools. How would operators (+, -, *, /, =) be handled? Keeping universal symbols is likely most practical.
• Script: Thaana (ތާނަ) vs. Latin Transliteration: This is a critical choice.
  • Using Thaana: The ideal scenario for cultural authenticity and readability for native speakers. However, this presents major technical challenges for text editors, compilers/interpreters (parsing RTL script with diacritics), and font support.
  • Using Latin Transliteration: (thibenyyaa instead of ތިބެންޏާ). Much simpler technically, as tools handle Latin characters easily. But it sacrifices the direct use of the native script.
• Language Paradigm: Would Dhicode be imperative (step-by-step commands like C), object-oriented (using objects and classes like Java), or functional? Starting with a simple imperative structure would be most feasible.

2. Bringing Dhicode to Life: The Technical Journey

Once the design is conceptualized, the technical implementation involves several standard stages of language creation:

• Lexical Analysis (Lexing): Breaking the raw Dhicode text (whether in Thaana or Latin) into fundamental units called "tokens". For example, identifying ތިބެންޏާ as a keyword, myVariable as an identifier, + as an operator, and 123 as a number. Handling Thaana script here is non-trivial.
• Syntactic Analysis (Parsing): Checking if the sequence of tokens adheres to the grammatical rules defined for Dhicode. This stage often builds an Abstract Syntax Tree (AST), which is a tree-like representation of the code's structure. The parser must understand the defined Dhicode grammar.
• Semantic Analysis: Checking the code for logical consistency and meaning. Does it make sense? Are variables used correctly? Do types match (e.g., not trying to mathematically add text)?
• Code Generation / Execution: This is where the Dhicode instructions become actions. There are two main approaches:
  • Interpreter: Reads the Dhicode (or its AST) and executes it directly, step-by-step. Often easier to build initially.
  • Compiler: Translates the Dhicode into another form – machine code that the computer's processor understands directly, bytecode for a virtual machine (like Java's JVM), or even into another high-level language like C or JavaScript. Compiling usually results in faster execution but is more complex to build.

3. Obstacles on the Path to Dhicode

The journey is fraught with challenges that explain why Dhicode doesn't exist yet:

• Thaana Script Handling: Robustly supporting a right-to-left script with complex vowel diacritics within code editors, lexers, parsers, and debugging tools is a massive technical hurdle. Standard tools are built primarily for LTR Latin scripts.
• Lack of Existing Tools: Building compilers and interpreters requires specialized tools (like parser generators - ANTLR, Bison) and significant expertise. Adapting these for Dhivehi/Thaana adds another layer of complexity.
• Ambiguity: Natural languages like Dhivehi are inherently more ambiguous than programming languages, which require absolute precision. Designing keywords and grammar that avoid confusion is vital.
• Right-to-Left vs. Left-to-Right Logic: While Thaana is RTL, the logical flow of most programming algorithms is conceived LTR. Representing this clearly in code can be confusing.
• Ecosystem Development: A language is more than just its compiler. It needs documentation, tutorials, libraries, error messages, and a supportive community – all potentially needing to be developed in Dhivehi. This requires substantial, sustained effort.

4. Starting Small: Practical First Steps

Instead of aiming for a full, general-purpose language immediately, more achievable steps could pave the way:

• Domain-Specific Language (DSL): Create a simple Dhivehi-based language for a very narrow, specific task relevant to the Maldives (e.g., calculating fishing yields, managing Islamic calendar dates, formatting addresses).
• Educational Language: Develop a visual block-based language (like Scratch) using Dhivehi commands, or a very simplified text-based language purely for teaching basic coding concepts to children.
• Transpiler: Create a tool that converts code written with Dhivehi keywords (perhaps in Latin script initially) into an existing language like Python or JavaScript. This leverages existing ecosystems while providing a Dhivehi "skin".

Conclusion: A Possible Dream

So, is Dhicode possible? Yes. Is it easy? Absolutely not. Creating a Dhivehi programming language would be a monumental task requiring dedicated expertise in computer science, linguistics, and significant resources.