DEV Community: Aswin M Rajeev

Beyond Syntax: What Really Makes a Programming Language?

Aswin M Rajeev — Sat, 01 Aug 2026 18:28:52 +0000

In this post, I want to explain how I approached the design of my own programming language, Light, and why some of its rules were designed the way they are.

When designing Light, I was not only deciding how programs should be written. I also had to define how those programs should behave, how different features should interact, and what rules should remain consistent throughout the language.

One question guided many of these decisions:

What rule should govern this, and how should it interact with the rest of the language?

This led to a design centered around explicit structure and dynamic flexibility.

Light defines structural rules for program entry, control flow, data access, and reusable program units. At runtime, variables remain dynamically typed while operations such as array access, expression evaluation, and type conversion follow defined rules.

The same principle applies to Purpose blocks and libraries. They are not isolated features; their behavior is designed to fit into the language's existing execution and data model.

A feature is not complete simply because its syntax works. Its behavior must remain predictable when combined with everything around it.

That is why I focus not only on what a feature can do, but also on where it belongs, what rules govern it, and how it interacts with existing constructs.

For me, this is the foundation of Light's design philosophy:

explicit rules, structured execution, and dynamic flexibility without sacrificing consistency.

Light is still under active development, including its standard libraries, so its design will continue to evolve as the language grows.

Your thoughts and feedback are appreciated.

Explore Light on GitHub: GitHub Repository

Building the Light Programming Language: What I Learned After 9 Months

Aswin M Rajeev — Sun, 26 Jul 2026 07:45:28 +0000

A few days ago, I shared the first public release of Light, a programming language I've been designing and developing over the past nine months.

Rather than introducing the language again, I wanted to share one of the biggest lessons I learned while building it.

Before diving into that, here's a small example written in Light.

user

Purpose Add[a,b]
{
    sum = a + b
    out:sum
    stop
}

x = 23
y = 34

out="'Add{x,y}'"

Before implementing the first working version of Light, I documented the core concepts, language rules, and the initial specification. At that stage, I believed the primary challenge would be transforming those ideas into a working implementation.

Development reinforced just how inherently iterative language design is.

As implementation progressed, practical experimentation exposed interactions that weren't immediately apparent during the initial design. Some features evolved, certain language rules were refined, and additional capabilities were introduced as the language matured. At the same time, performance, error reporting, and the implementation itself were continuously improved through repeated testing and refinement.

One observation became increasingly clear throughout the project:

The specification shapes the implementation, but the implementation also helps refine the specification.

Looking back, building a programming language has been as much about evaluating and refining design decisions as it has been about writing code. Every iteration strengthened the language, improved its consistency, and reinforced the foundation established by the current public release.

This release represents an important milestone in the development of Light. While there is still much to explore and refine, it establishes the foundation on which the language will continue to evolve.

Your feedback and insights are always appreciated.

If you're new to Light, you can read the introduction to the project here:
Introducing Light — A New Programming Language:

https://dev.to/aswinmrajeev/introducing-light-a-new-programming-language-ghd

To learn more about Light and explore its documentation, visit the official GitHub repository.

Official GitHub Repository:

https://github.com/aswinmrajeev/light

Introducing Light — A New Programming Language

Aswin M Rajeev — Sat, 18 Jul 2026 16:39:04 +0000

Over the past 9 months, I've been designing and developing Light, a programming language with the long-term vision of making script automation more structured, consistent, and easier to build and maintain.

The idea behind Light began with a simple question: what would a programming language designed around structured program organization and predictable execution look like? That question evolved into designing the language specification, defining its syntax and execution model, implementing the interpreter, and building the foundation of its ecosystem.

This first public release marks an important milestone. It includes the core language and two standard libraries, establishing the initial foundation of the project. Light is under active development, with additional language features, standard libraries, and developer tooling planned for future releases.

I'm sharing this first public release to introduce the project and gather feedback from the developer community. I'd appreciate your thoughts on the language design, syntax, documentation, and overall developer experience.

Hello Light

user

name = _Light_

out="Hello 'name'"

GitHub

https://github.com/aswinmrajeev/light