DEV Community: Carlos Eduardo Git

[Boost]

Carlos Eduardo Git — Fri, 29 May 2026 12:56:49 +0000

GitHub “Finish-Up-A-Thon” Challenge Submission

Carlos Eduardo Git

May 29

Turning 2,000 Lint Errors into Zero: A Complete DSL Refactor Story

#devchallenge #githubchallenge

4 min read

Turning 2,000 Lint Errors into Zero: A Complete DSL Refactor Story

Carlos Eduardo Git — Fri, 29 May 2026 12:44:15 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

How 21 commits, 230 files, and 40k lines transformed a forgotten DSL into production-ready software - with GitHub Copilot as my pair programmer.

What I Built

JSSON is a human-friendly configuration language that transpiles to JSON, YAML, TOML, and TypeScript. Think of it as HJSON on steroids — featuring variables, templates, ranges, maps, conditionals, reusable presets, built-in validators ([@]uuid, [@]email, [@]datetime - ignore the brackets), and full schema support.

// A JSSON source file
@preset "server-defaults" {
  port = 8080
  host = "localhost"
  timeout = 30
}

users [
  template { id, role }
  map (u) = {
    id = u.id
    role = u.role
    active = true
  }
  1..100, "admin"
  101..1000, "user"
]

A single file like the one above can generate 1,000 user objects across four different formats instantly.

The project was my own creation, but I had completely abandoned it for 5 months. It was stuck in that "it works, but don't look at the source" phase: monolithic 800-line files, interface{} everywhere, zero integration tests, no linters, and manual build scripts.

So I did what any sane developer would do: I rolled up my sleeves, called GitHub Copilot to my side, and spent two intense days refactoring everything.

Demo

Here is JSSON in action. You can run these commands yourself using the examples provided in the repository.

Transpiling to JSON

# Build the binary
make build

# Transpile a basic example
./bin/jsson -i examples/basics/01-hello-world.jsson

Multiple Output Formats

# YAML, TOML, and TypeScript support
./bin/jsson -i examples/basics/03-objects.jsson -f yaml
./bin/jsson -i examples/basics/03-objects.jsson -f toml
./bin/jsson -i examples/basics/03-objects.jsson -f typescript

Advanced Features: Ranges & Formatting

# Expand ranges
./bin/jsson -i examples/basics/05-ranges.jsson

# Format your JSSON files (The new 'jsson fmt' command!)
./bin/jsson fmt examples/real-world/apiconfig.jsson

The Comeback Story: From Chaos to Clarity

When I picked up the project again, it was a mess of monolithic files:

File	Lines
`parser.go`	837
`evaluator.go`	355
`main.go`	631
`validate.go`	384
`lexer.go`	392

The entire AST was built on interface{}, meaning the compiler couldn't help me. If a node was the wrong type, I'd only find out through a runtime panic.

The Refactoring Journey

1. The Great Linting War (2,062 Issues!)

This was where GitHub Copilot truly shone. The project had zero linters. When I finally configured golangci-lint, it flagged 2,062 issues.
With Copilot's help, we used golangci-lint run --fix intelligently to resolve 1,527 issues automatically (wsl, nlreturn, wrapcheck, etc.). I then manually fixed the remaining 535 issues with Copilot suggesting the corrections. Today, the project has 0 lint issues.

2. Typed AST - Goodbye `interface{}`

I replaced the fragile if-else type assertion chains with a proper Node interface and type switches. This eliminated 100% of runtime type assertions in the hot path. Even the LSP (Language Server) became stable and warning-free.

3. Surgical Slicing

I broke down those massive files into cohesive modules. The 837-line parser became 4 focused files. The evaluator became 5 specialized modules. Now, no core file exceeds 200 lines.

4. E2E Testing with Golden Files

I implemented 136 "golden files" as a safety net. Every time I refactored a core component, I could run go test -tags=e2e -update to verify that the output remained identical. This gave me the confidence to perform aggressive architectural changes without fear.

The Numbers (Before vs. After)

Metric	Before	After
Test Suites	Unit only	Unit + 136 E2E Goldens + Stdin/Fmt tests
Release Pipeline	Manual scripts	Makefile + GoReleaser (Automated)
Action Pinning	Moving tags (`@v4`)	Commit SHAs (Secure)
AST Typing	`interface{}`	Concrete `Node` types
Max File Size	837 lines	< 200 lines
Formatter	None	`jsson fmt` with `-w` and `-check`

21 commits, 230 files modified, ~40k lines of changes, and zero regressions.

My Experience with GitHub Copilot

Using AI for this level of refactoring changed my perspective on "Pair Programming." I expected hallucinations given the complexity of a custom DSL, but GitHub Copilot proved to be a reliable partner.

It didn't "know" my architecture, but it understood my intent. I would provide the context — a file diff or a goal like "refactor this using a type switch" - and it would handle the mechanical parts: splitting files, updating imports, and renaming symbols across the workspace.

What would have taken weeks manually took only two days. This allowed me to focus on high-level design decisions while Copilot handled the "grunt work" of moving code around.

The result is a project I am finally proud to share. JSSON v0.1 is now stable, maintainable, and ready for the community.

Repository: github.com/jsson-lang/jsson
The Big Refactor PR: PR #4

JSSON (JavaScript Simplied Object Notation)

Carlos Eduardo Git — Mon, 24 Nov 2025 23:38:53 +0000

Today I'm officially launching JSSON (pronounced “djéisson”, write that down)

First things first: this is NOT trying to replace JSON.
The goal is simple: save you from the pain of writing JSON by hand.

I know, I know… I can already hear someone sighing:

“Oh boy, here comes another TOON-like format…”

Relax. I promise this is not the kind of format that makes you regret becoming a developer.

🤔 Why does JSSON exist?

Think about all those times you had to manually craft:

giant mocks
database seeds
repetitive structures
endless configs
massive arrays

…and then spent 30 minutes fighting commas, quotes, brackets, indentation, and a mild headache.

Yeah.
JSSON exists to end that suffering.

The most basic example

user {
  name = João
  age = 20
  admin = true
  roles = [ "admin", "editor" ]
  config {
    theme = dark
  }
}

No quotes on simple values.
No commas.
No drama.

Simple template (yes, it looks like CSV… calm down)

users [
  template { name, age, job, height }
  João, 19, Student, 1.75
  Maria, 25, Teacher, 1.65
  Pedro, 30, Doctor, 1.80
  Ana, 22, Nurse, 1.68
]

Yep, it resembles CSV.
And no, this alone won’t generate huge structures.

But breathe, and keep reading:

Templates + logic.

This is where JSSON starts changing your mind.

Okay, now: logic baked into the format

This example transforms every item automatically:

routes [
  template { path, method }

  map (item) = {
    path = "/api/" + item.path
    method = item.method
  }

  users, GET
  posts, POST
]

Output:

{
  "routes": [
    { "path": "/api/users", "method": "GET" },
    { "path": "/api/posts", "method": "POST" }
  ]
}

Generating huge structures with ranges

servers [
  template { id, port }

  map (s) = {
    id = s.id
    ip = "192.168.1." + s.id
    port = s.port
  }

  100..120,
  3000..3020
]

Yes, this generates 21 servers with matching IPs and ports.
Yes, without writing anything manually.
Yes, cue the victory theme.

Giving your data “intelligence”

users [
  template { name, age, department, yearsOfService }

  map (u) = {
    name = u.name
    age = u.age
    department = u.department
    yearsOfService = u.yearsOfService

    canVote = u.age >= 18
    isExecutive = u.yearsOfService >= 10
    accessLevel = u.yearsOfService >= 10 ? "senior"
                : u.yearsOfService >= 5  ? "mid"
                : "junior"
    salary = u.yearsOfService >= 10 ? 150000
            : u.yearsOfService >= 5 ? 100000
            : 60000
    benefits = u.yearsOfService >= 5 ? ["health", "dental", "401k"] : ["health"]
  }

  "João Silva", 35, Engineering, 12
  "Maria Santos", 28, Sales, 6
  "Pedro Costa", 22, Marketing, 2
]

You write a few lines and follow a pattern.
JSSON builds an entire smart object structure for you.

Generating dozens of users in minutes

users [
  template { id, department }

  map (u) = {
    id = u.id
    username = "user_" + u.id
    email = "user_" + u.id + "@company.com"
    dept = u.department
    role = "employee"
  }

  // Engineering
  100..104, Engineering

  // Sales
  200..204, Sales
]

Done. Automatically generated users, all neatly standardized.

Generating entire teams (logic + ranges)

The classic example:

employees [
  template { id, dept, level }

  map (e) = {
    id = e.id
    name = "Employee " + e.id
    email = "emp" + e.id + "@corp.com"
    department = e.dept
    level = e.level
    salary = e.level == "senior" ? 120000 
           : e.level == "mid"    ? 80000 
           : 50000
  }

  // Engineering
  1000..1004, Engineering, junior
  1005..1009, Engineering, mid
  1010..1012, Engineering, senior

  // Sales
  2000..2009, Sales, junior
  2010..2014, Sales, mid

  // HR
  3000..3002, HR, mid
  3003..3004, HR, senior
]

This is extremely useful for:

seeds
unit tests
prototyping
fake APIs
demos
internal scripts

Now THIS: Modularization with `include`

Yep — JSSON can include other .jsson files and merge them.

include "database.jsson"

How it works:

resolves path
detects cycles (A includes B, B includes A → error)
caching
transpiles the included file
merges into the root (with keep, overwrite, or error mode)

Example:

database.jsson

db { host = localhost }

main.jsson

app = "MyApp"
include "database.jsson"

JSON output:

{
  "app": "MyApp",
  "db": { "host": "localhost" }
}

Simple. Direct. Done.

Full JSSON feature list 😏

Basic Syntax

No quotes for simple values
No commas
// comments
Strings, numbers, booleans, arrays, objects

Template Arrays

users [
  template { name, age }
  João, 25
  Maria, 30
]

Map (transformation)

map (user) = {
  name = user.name
  active = true
}

Powerful Ranges

1..10
10..1
0..10 step 2
"192.168.1.100".."192.168.1.150"

Expressions

+ - * / %
Comparisons
Ternary
Concatenation
Member access
Precedence with ()

Modularization via Include

Merge modes: keep, overwrite, error
Cycle detection
Include caching

Extras

Zero-padding ranges (emp001..emp010)
Mixed-type arrays
Unlimited nested objects
Variables inside map

CLI

-i input
-o output
--merge-mode

Quick comparison

Format	Logic Support	Ranges	Templates	Modularization	Purpose
JSON	❌	❌	❌	❌	Data
YAML	❌	❌	❌	❌	Config
CSV	❌	❌	✔️ (partial)	❌	Tables
JSSON	✔️	✔️	✔️	✔️	Data generation

Want to try it? Documentation & tools

Documentation (still polishing sitemap, indexing soon):
👉 https://jsson-docs.vercel.app

I’m working on the online playground this week, but for now you can try the current CLI build (tested on Windows):

How to use it right now (super quick)

Download the CLI (tested on Windows, use version 0.0.2): https://github.com/CarlosEduJs/jsson/releases
Run in terminal: jsson -i input.jsson -o output.json
Done: instant JSON.

Full docs:
👉 https://jsson-docs.vercel.app

VS Code Syntax Highlighting extension:
👉 https://marketplace.visualstudio.com/items?itemName=carlosedujs.jsson

That’s it — you now know everything about JSSON.

Thanks for reading! 🙌

DEV Community: Carlos Eduardo Git

[Boost]

Turning 2,000 Lint Errors into Zero: A Complete DSL Refactor Story

Turning 2,000 Lint Errors into Zero: A Complete DSL Refactor Story

What I Built

Demo

Transpiling to JSON

Multiple Output Formats

Advanced Features: Ranges & Formatting

The Comeback Story: From Chaos to Clarity

The Refactoring Journey

1. The Great Linting War (2,062 Issues!)

2. Typed AST - Goodbye interface{}

3. Surgical Slicing

4. E2E Testing with Golden Files

The Numbers (Before vs. After)

My Experience with GitHub Copilot

JSSON (JavaScript Simplied Object Notation)

Today I'm officially launching JSSON (pronounced “djéisson”, write that down)

🤔 Why does JSSON exist?

The most basic example

Simple template (yes, it looks like CSV… calm down)

Okay, now: logic baked into the format

Generating huge structures with ranges

Giving your data “intelligence”

Generating dozens of users in minutes

Generating entire teams (logic + ranges)

Now THIS: Modularization with include

Full JSSON feature list 😏

Basic Syntax

Template Arrays

Map (transformation)

Powerful Ranges

Expressions

Modularization via Include

Extras

CLI

Quick comparison

Want to try it? Documentation & tools

How to use it right now (super quick)

That’s it — you now know everything about JSSON.

2. Typed AST - Goodbye `interface{}`

Now THIS: Modularization with `include`