This post was formatted and re-phrased using AI, but was written by me originally. Please do not quit because I used AI to make the post better.
1. Introduction
Hi, I’m Anubhav Ghoshal, a 16-year-old developer from Jharkhand, India.
I’m currently building a programming language called San, entirely on an Android device using a Linux environment. This is a personal learning project focused on understanding how compilers and interpreters work from the ground up.
2. San — My Programming Language
San is named after the Korean word for mountain, something I’ve always been drawn to.
It is a dynamically and strongly typed language with a tree-walking interpreter architecture:
- Lexical Analysis (Lexer)
- Recursive Descent Parser
- Abstract Syntax Tree (AST)
- Tree-Walking Interpreter
The design is influenced by languages like Rust, Go, Python, and C, focusing on clarity and explicit control.
Here's the GitHub repository: https://github.com/anubhav-1207/san
Current design features:
- Explicit mutability vs immutability
- Explicit reassignment rules
- Short, minimal keywords
- Conventional syntax style (familiar structure)
- Optional semicolons
3. Development Environment
San is being built entirely on an Android device using a Linux environment (proot setup).
This is a constraint-driven setup, but it still supports:
- Code editing
- Running interpreter tests
- Iterative language development
The goal is not convenience, but learning how language internals actually work under real constraints.
4. Learning Journey
My early exposure to programming started in school, but it was initially limited to basic concepts like input/output, loops, and conditionals.
Later, I revisited programming more seriously and started understanding:
- How variables actually work in memory
- Why programming languages exist
- How interpreters and compilers execute code
- Why errors cannot always be “auto-fixed” by the language
That shift is what eventually led me toward building my own language instead of just using existing ones.
5. Building Alone & Learning Process
This project is entirely self-driven.
I did not have direct mentorship in compiler development, so I relied heavily on:
- Documentation
- Experimentation
- AI-assisted explanations while learning concepts
However, all implementation decisions and code are written and understood by me, and I often rebuild components from scratch to ensure I truly understand them.
6. What San Includes Right Now
- Basic lexer implementation
- Parser with recursive descent approach
- Immutability checks
- AST generation
- Early interpreter logic
7. What’s Next
- Better error handling
- Standard library basics
- Language stability improvements
8. Closing
San is still in early development, but the goal is simple:
to deeply understand how programming languages work by building one from scratch.
Feedback is welcome.
