DEV Community: Bryantad

Sona v0.7.0 Is Live — Object-Oriented Power Unleashed

Bryantad — Wed, 25 Jun 2025 23:50:49 +0000

I Built a Language Where Objects and Dictionaries Are the Same Thing

After two years of compiler development, I just shipped Sona v0.7.0—a language built around one core insight: objects and dictionaries should be unified, not separate concepts.
The Problem I Kept Running Into
I was constantly switching between languages for different parts of the same project:

Python for data processing (great dicts, verbose classes)
JavaScript for logic (great objects, weird edge cases)
Go for performance (verbose everything)

Each language had the right pieces, but never quite fit together. I wanted something that felt as natural as JavaScript's object model but with Python's clarity and none of the historical baggage.
The Core Innovation: Unified Object/Dictionary Syntax
In Sona, there's no distinction between object properties and dictionary keys:
sona// This is a dictionary
let config = {
"app_name": "MyApp",
"version": "1.0.0",
"features": {"auth": true, "analytics": false}
}

// But you can access it like an object
config.debug = true
config.features.logging = true
print(config.app_name) // "MyApp"
Classes work the same way:
sonaclass GamePlayer {
constructor(name) {
this.name = name
this.stats = {"hp": 100, "level": 1}
this.inventory = []
}

method levelUp() {
this.stats.level = this.stats.level + 1
this.stats.hp = this.stats.hp + 10
return this // Enable chaining
}
}

let player = GamePlayer("Alice")
player.levelUp().levelUp()
print(player.stats.level) // 3
Why This Actually Matters

No context switching between syntaxes sona// Same syntax for everything user.profile.settings.theme = "dark" config.database.host = "localhost" api.endpoints.users.timeout = 5000
Natural method chaining sonaplayer.spawn() .move(10, 5) .attack("fireball") .collectLoot()
Seamless data modeling sonalet library = Library("City Central") library.books = [ {"title": "1984", "author": "Orwell", "available": true}, {"title": "Dune", "author": "Herbert", "available": false} ]

// Add methods to existing data
library.findAvailable = function() {
return this.books.filter(book => book.available)
}
The Technical Implementation
This isn't just syntactic sugar. The language is built with:

LALR(1) parser with proper AST design using Lark
Lexical scoping with full closure support
Method resolution order for inheritance
Unified property access across all object types
Python ecosystem integration without Python's syntax quirks

The object model treats everything as a dictionary with methods, but with proper OOP semantics for inheritance and method dispatch.
Real-World Examples
Configuration management:
sonalet config = loadConfig("app.json") // Returns a dict
config.validateRequired() // But has methods
config.database.reconnect() // Nested objects work naturally
Game development:
sonalet enemy = Enemy("goblin")
enemy.ai = {"aggression": 0.7, "patrol_range": 50}
enemy.ai.decision_tree = DecisionTree()
enemy.think().move().attack()
Data processing:
sonalet data = parseCSV("sales.csv")
data.forEach(row => {
row.profit = row.revenue - row.costs
row.margin = row.profit / row.revenue
})
What's Next
v0.8.0 roadmap:

Enhanced class system with multiple inheritance
Pattern matching for data structures
LSP support for IDE integration
Package manager for module distribution
Performance optimizations

Longer term:

Bytecode compilation for performance-critical code
Web assembly target for browser deployment
GUI framework leveraging the unified object model

Why I Built This
I didn't build Sona because the world needed another language. I built it because I kept hitting the same friction points:

Switching between obj.prop and dict["key"] syntax
Verbose class definitions for simple data structures
Inconsistent method chaining across different object types
Context switching between languages for different parts of the same project

Sona is my attempt to create a language that feels consistent and predictable while still being powerful enough for real work.
Try It Out
The language is mature enough for real experimentation:

GitHub: https://github.com/Bryantad/Sona
Documentation: Comprehensive examples and language guide
REPL: Interactive development environment
Standard library: Math, string, I/O, HTTP client, JSON parsing

The Bigger Picture
This project taught me that small, consistent design decisions compound into something that feels completely different. Sona doesn't have any revolutionary features—it just makes a few things work the way you expect them to.
If you've ever found yourself fighting with a language's object model or wishing for more consistent syntax, I'd love your feedback. The goal isn't to replace your production stack, but to offer a cleaner tool for prototyping, scripting, and learning.
What do you think? Does unified object/dictionary syntax solve real problems, or is this just elegant complexity?

Follow the project on GitHub and let me know what you build with it. The best way to validate a language design is to see what people create when they're not fighting the syntax.

I Built a New Programming Language for Neurodivergent Creators — Meet Sona (v0.7.0)

Bryantad — Tue, 13 May 2025 14:04:57 +0000

Why I Built Sona

I’m tired of jumping through hoops just to get “Hello, world!” on the screen—especially when syntax errors feel like hidden trapdoors for neurodivergent brains. After years of wrestling with tooling that wasn’t built for me, I created Sona: an open-source language designed to remove friction, spark creativity, and let you code with confidence from day one.

What Makes Sona Stand Out

Minimal, readable syntax (think Python + Rust + Go without the baggage)
REPL-first—iterate in milliseconds (v0.4.3 brought multiline functions, :env, :clear)
Native modules—import fs; stdin.input() just works
Accessibility by design—empathy baked in for neurodivergent devs
100% open source—interpreter in Python + Lark, so you can inspect and contribute

⚡️ [June 2025 Update]: Sona v0.7.0 has officially launched!

This release brings complete object-oriented programming, property access, method chaining, and much more.

📘 Read the full v0.7.0 release post here →

🚀 v0.5.1 Highlights (2025-05-23)

🛠️ REPL Diagnostics

:debug → dive into last error, parse tree & scopes
:profile → benchmark your commands in real time
:watch <var> → peek at variable value, type & defining scope
:trace → toggle live function-call logging
New helper module: sona/utils/debug_tools.py (docs included)

📂 Project Layout

Streamlined directories for source, tests & release scripts
Tests grouped by feature area for faster onboarding
DIRECTORY.md—find anything in seconds
release-tools/ folder with cleanup scripts

🔒 Security Hardened

No more shadowed params—function scoping tightened
Import paths validated to block traversal attacks
Input-size limits to guard against DoS

🐛 Bug Squash

Triple-quoted strings now span lines correctly
Numeric types behave in if/else blocks
Edge cases in while loops patched
Error messages now include exact location info
Import-alias quirks fixed
Memory leaks exterminated
:test command runs the full diagnostic suite reliably

✨ REPL QOL

Mini :calc & :quiz apps right in the shell
Type exit or quit (no colon) to close the REPL
Polished :test for one-shot test runs

📚 Docs

SECURITY.md updated with real-world best practices
Examples synced with the latest fixes

What’s Next

v1.0 Public Alpha—rock-solid docs, examples & tutorials
IDE plugins—syntax highlighting & LSP support
AI-powered tooling—SonaCore LLM integrations incoming

TL;DR: v0.5.1 is all about diagnostics, security, cleanup & polish—your feedback is gold.

If you found this useful, I’d love your support:

⭐ Drop a star on GitHub: github.com/Bryantad/Sona

👥 Follow me on Dev.to for more low-friction language tooling deep dives

Your stars and follows keep Sona moving—thanks for being part of the journey!