Log

If you've been following Grammario, you know it's been out in the world for a while now. But if I'm being honest, I've been struggling with where to take it next. I knew the vision—helping people truly see how languages work—but I felt like I was hitting a wall with the standard way of doing things.

The "chat with an AI about your grammar" approach just wasn't cutting it. It felt too loose, too prone to "guessing," and it didn't respect the deep, beautiful logic that makes a language like Turkish fundamentally different from Spanish.

I realized that to move forward, I had to stop treating sentences like simple text and start treating them like blueprints. This is why I'm introducing the Structural-First Analysis method. It's the "Aha!" moment Grammario needed, and it's how we're going to actually master these five languages together.

The Problem: The "Black Box" Wall

Most language tech works like a black box. You put a sentence in, the AI "thinks," and it tells you something that sounds right. But there's no map. No proof. When I was trying to figure out how to make Grammario better, I realized we needed a skeleton—a deterministic "Hard Truth" that the AI couldn't hallucinate.

The Solution: The Structural-First Pipeline

We've rebuilt the engine from the ground up. We're moving away from "chatting" and toward visual architecture. Here is how the new Grammario actually looks under the hood:

1. Dissecting the DNA (The Analyst)

We don't guess anymore. We use high-precision computational linguistics to break every sentence into its raw skeleton. We find the root (lemma) of every word and map the grammatical relationships (syntax) using the Universal Dependencies standard. If a word is an object, we know it's an object because the math says so, not because an AI guessed it.

2. Respecting the Family (The Strategist)

I've realized that a "one-size-fits-all" engine is a mistake. To move forward, Grammario now uses a "Divide and Conquer" strategy:

• For Turkish: We use an "X-Ray" view. Turkish is agglutinative—it stacks meanings like LEGO bricks. Our new method explodes words like evlerinizden into individual segments so you can see the plural, the possessive, and the case markers clearly.
• For German & Russian: We focus on "Governance." We show you exactly which verb is "demanding" that a noun be in the Dative or Accusative case.
• For Italian & Spanish: We map "Agreement Clusters," visually grouping the words that have to match in gender and number.

3. The Human Layer (The Tutor)

Only after we have the "Hard Truth" (the structure) do we bring in the AI. Its job is no longer to find the grammar—the engine already did that. Its job is to explain it to you in a way that makes sense. It's the difference between a teacher guessing what's in a book and a teacher having the open book right in front of them.

Moving Forward

I've been struggling to find the right path for Grammario, but this is it. By favoring Structure over Free Text, we're building something that isn't just another study tool—it's a high-definition map for your brain.

Grammar isn't just a set of rules to memorize; it's a structure to be seen. I'm excited to finally show you what that looks like.

Grammario is undergoing some backend changes so the API for sentence analysis is down currently.

In my previous post, I mentioned that I began learning the Go programming language. I am now a couple of weeks into the curriculum and I am thoroughly enjoying it. So, I would like to write a quick blog post about a rather small and maybe insignificant feature that I really enjoy about Go.

Go is a language that has pointers. Pointers are not a new concept to me, my previous experience with C and C++ has drilled pointers into me. However, I found the syntax of pointers in C and C++ to be cumbersome at times. Features such as null pointers for malloc(), dereferencing, and double pointers were annoying and sometimes were a strain to keep track of. So, when I was learning how pointers work in go, I came across this wonderful little feature that eliminates the aforementioned cumbersome syntax. Here is an example:

Lets create a super simple structure for a Bank:

type Bank struct {
  Balance int
}

Now, I want to create a function that takes the Bank structure and adds some amount of money to the balance. So lets write this:

func (b Bank) Deposit(amount int) {
  b.Balance += amount
}

This should work, right? No. Go is a pass-by-value language, meaning that this function does not take the original structure. It creates a copy and then modifies the "new" Balance value untouched. So, in order to modify the one true Balance value in the original structure, we must pass a pointer to the structure.

func (b *Bank) Deposit(amount int) {
  b.Balance += amount
}

Now, this function mutates the original Balance value. The syntax is nice and clean, whereas in C or C++ there would need to be a dereference. That would look something like this:

// this is not real code this is just if Go was like C/C++

func (b *Bank) Deposit(amount int) {
  *b.Balance += amount
}

Turns out, structs in Go are automatically dereferenced. This makes writing functions like this a tiny bit less of a headache. As I said before, it is a small detail, but to me it is extremely enjoyable.

For my company's debut software Wheelbase, I was recently faced with a challenge. In order to process a lot of data, there was going to be an inevitable need for a fast backend. One of the core features of the application, which populated the database with thousands of entries, was taking up to two minutes to complete. This was unacceptable. Such sluggishness would make the application feel outdated and amateur. After some searching, I found a problem in the backend that was coded in Python using FastAPI. Upon fixing, I managed to make the same process take ~5-25 seconds depending on the amount of cars that were being created in the database (it could be anywhere from 500 to 5,000). Meanwhile, in my spare time I was reading a lot about a programming language that I previously knew pretty much nothing about-Go. Go was supposed to be a language that is a backend heavyweight, capable of sustaining massive backend systems with a syntax that was easy to understand. Since then, I have been spending my time learning Go and investigating how it could be incorporated into Wheelbase's backend.

Over the past couple of months I made the decision to scrap the old UI with the connected cards that could be freely moved around on a gridded canvas. It seemed completely unnecessary for what I was trying to accomplish with the project. I wanted to create a more streamlined and user-friendly interface that would be easier to navigate and use. The new UI is far from perfect, but it is a step in the right direction. The input sentence is displayed at the top and then the if the user clicks on a word, it provides information on said word. Below are some screenshots to show the new UI which can also be seen live at Grammario.ai.

Due to certain hosting issues, I am unable to deploy the back end of Grammario which is responsible for the grammar breakdown. I am uncertain when this will be fixed as my job and work on Wheelbase take precedent.

On another note, I have decided to make some YouTube videos about the C programming language in my free time. I got this idea after watching some videos by a guy called Daniel Bourke, who has a PyTorch course up on YouTube. In one of his other videos, he claimed that trying to teach something will increase your knowledge in said subject. I believed him. Not knowing what to teach, I came to the idea that I should start from the basics, back to C. Where better to start? C teaches people about the guts of programming in the most intimate way possible that does not involve learning Assembly. Hopefully I will release my first video soon.

And with the new year, I present version 0.1.0 of Grammario! It's very bare and is not polished whatsoever, but I do want to show the basic functionality to the world. Once that is tried and tested, then I will move to making the website world class!

Utilizing some stuff I learned in the realm of prompt engineering, I was able to improve the prompt and we finally have an output that shows promises!

{
    "sentence": {
        "Ho": {
            "position": 1,
            "part_of_speech": "verb",
            "root": "avere",
            "noun_components": { "affixes": null },
            "noun_case": null,
            "noun_case_components": null,
            "verb_tense": "present perfect",
            "verb_tense_components": [ "ho" ]
        },
        "visto": {
            "position": 2,
            "part_of_speech": "verb",
            "root": "vedere",
            "noun_components": { "affixes": null },
            "noun_case": null,
            "noun_case_components": null,
            "verb_tense": "past participle",
            "verb_tense_components": [ "visto" ]
        },
        "una": {
            "position": 3,
            "part_of_speech": "article",
            "root": null,
            "noun_components": { "affixes": null },
            "noun_case": null,
            "noun_case_components": null,
            "verb_tense": null,
            "verb_tense_components": null
        },
        "bella": {
            "position": 4,
            "part_of_speech": "adjective",
            "root": null,
            "noun_components": { "affixes": null },
            "noun_case": null,
            "noun_case_components": null,
            "verb_tense": null,
            "verb_tense_components": null
        },
        "ragazza": {
            "position": 5,
            "part_of_speech": "noun",
            "root": null,
            "noun_components": { "affixes": null },
            "noun_case": null,
            "noun_case_components": null,
            "verb_tense": null,
            "verb_tense_components": null
        }
    },
    "relationship_matrix": [
        [ 0, 0, 0, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 0, 0, 0, 1, 1 ],
        [ 0, 0, 0, 0, 1 ],
        [ 0, 0, 0, 0, 0 ]
    ]
}

After the last update I have been playing around with prompt engineering in order to get the exact responses necessary to create the desired functionality, but as of right now it has proven fruitless. Sure, I could settle for inconsistent results that "kind of" work and get the basic ideas across but this is not what I want. However, this does not mean I am abandoning the idea of this project-far from it. I will continue to develop my machine learning skills and prompt engineering knowledge until I can create the functionality I so desire. Perhaps I shall even expand the project into a full language learning Web Application, instead of being exclusively to break down grammar. Since I have used every major language application that there is, whether it be Duolingo or LingQ etc.. I believe that I could create a structure that caters more to the enthusiast instead of someone who just keeps learning to keep their Duolingo streak going.

In my recent work with Grammario, I've conducted several tests using the OpenAI API to break down grammar in Italian and Turkish, as well as testing with the Stanza library for Turkish grammar breakdowns with my own suffix-extraction logic.

Test 1: OpenAI API - Italian

The first test is a POST request using the OpenAI API to break down an Italian sentence.

{
  "sentence": [
    {
      "part_of_speech": "verb",
      "root": "avere",
      "verb_tense": "present perfect",
      "verb_tense_components": {
        "auxiliary_verb": "ho",
        "past_participle": "L'"
      },
      "word": "L'ho"
    },
    {
      "part_of_speech": "verb",
      "root": "fare",
      "verb_tense": "past participle",
      "verb_tense_components": {
        "past_participle": "fatta"
      },
      "word": "fatta"
    },
    {
      "part_of_speech": "verb",
      "root": "imparare",
      "verb_tense": "infinitive",
      "word": "imparare"
    },
    {
      "part_of_speech": "noun",
      "root": "italiano",
      "noun_components": {
        "stem": "italian",
        "suffixes": "o"
      },
      "word": "italiano"
    }
  ]
}

Test 2: OpenAI API - Turkish

The second test is a POST request using the OpenAI API to break down a Turkish sentence.

{
  "sentence": [
    {
      "part_of_speech": "numeral",
      "root": "bir",
      "noun_components": {
        "stem": "bir"
      },
      "word": "bir"
    },
    {
      "part_of_speech": "noun",
      "root": "elma",
      "noun_case": "nominative",
      "word": "elma"
    },
    {
      "part_of_speech": "verb",
      "root": "yemek",
      "verb_tense": "present continuous",
      "verb_tense_components": "iyor",
      "word": "yiyorum"
    }
  ]
}

Test 3: Stanza Library with Custom Suffix-Extracting Logic (Turkish)

The third test uses the Stanza library for Turkish grammar breakdowns, paired with my own logic for extracting suffixes.

Word: yapilan
Lemma: yap
Features: Aspect=Perf | Mood=Ind | Polarity=Pos | Tense=Pres | VerbForm=Part | Voice=Pass
Extracted Suffixes: ['-an', '-1l']

Word: seçimlere
Lemma: seçim
Features: Case=Dat | Number=Plur | Person=3
Extracted Suffixes: ['-e', '-ler']

Word: Reform
Lemma: reform
Features: Case=Nom | Number=Sing | Person=3
Extracted Suffixes: []

Word: Partisi
Lemma: parti
Features: Case=Nom | Number=Sing | Number[psor]=Sing | Person=3 | Person[psor]=3
Extracted Suffixes: ['-u']

Word: baskan
Lemma: baskan
Features: Case=Nom | Number=Sing | Person=3
Extracted Suffixes: []

Word: aday
Lemma: aday
Features: Case=Nom | Number=Sing | Number[psor]=Sing | Person=3 | Person[psor]=3
Extracted Suffixes: ['-u']

Word: olarak
Lemma: olarak
Features: None
Extracted Suffixes: []

Word: katildi
Lemma: kat
Features: Aspect=Perf | Mood=Ind | Number=Sing | Person=3 | Polarity=Pos | Tense=Past | Voice=Pass
Extracted Suffixes: ['-d1', '-1l']

These tests demonstrate how the different methods approach language grammar breakdowns. While OpenAI offers impressive results for both Italian and Turkish, I've found that the Stanza library combined with custom suffix-extracting logic offers more flexibility for specific language features like Turkish suffixes.

Moving forward, I'll continue refining the custom logic to ensure accuracy and consistency in these breakdowns, with the ultimate goal of building a robust web application that simplifies grammar learning.

A core hobby of mine is language learning. Throughout the years I have used many different websites, applications, and tools in order to make learning easier.

Language learning has always been a hobby of mine, but over time, I realized that mastering grammar can often be the most challenging aspect. After scouring the web for tools that could simplify this process, I found that many fell short of providing the depth and clarity needed. Leveraging my knowledge of natural language processing (NLP), I decided to introduce a web app that specifically tackles the complexities of grammar learning, aiming to make this daunting task easier for language learners like myself.

One of the key features of my web app is its ability to break down complex sentences, making grammar easier to understand. For instance, take the Italian sentence: "L'ho fatta parlare in italiano."

• L': A pronoun meaning "her," used as the direct object.
• ho: The verb "have," used as an auxiliary in the present tense.
• fatta: The past participle of "fare" (to make), agreeing with the feminine pronoun.
• parlare: The infinitive verb meaning "to speak."
• in: A preposition indicating the language.
• italiano: A noun meaning "Italian," referring to the language being spoken.

This breakdown simplifies understanding each part of the sentence, showing how the words connect and form the meaning. With this tool, learners can tackle even the most challenging grammatical structures step by step.