Forem: Atomi J.D.

Python vs. a Modern BASIC Interpreter: When the “Toy Language” Actually Wins

Atomi J.D. — Sun, 08 Feb 2026 06:24:51 +0000

I like Python. A lot, actually. It is hard to argue against it: Python dominates data science, AI, and a large part of backend development.

But I am also a C++ developer, and over the last year I built my own interpreter: jdBasic.

Not as a Python replacement, but as an experiment in a different direction.

The question behind it was simple:

What happens if you design a language and an interpreter purely around reducing friction during everyday development and experimentation?

This article is not about hype. It is about very practical trade-offs.

Motivation: The Hidden Cost of “Just Import a Library”

Python’s strength is its ecosystem. At the same time, that ecosystem introduces a constant overhead:

virtual environments
package management
imports for even small tasks
tooling setup before you can actually think

That cost is usually acceptable. Sometimes it is not.

jdBasic explores a different idea:

Bake common, complex operations directly into the language instead of outsourcing them to libraries.

1. The "Always-Open" Utility Console

One of the most common interruptions in development is context switching.

open a terminal
start a REPL
import something
run a quick check
close everything again

jdBasic is small and fast enough that I simply keep it open all day. It works like a scratchpad.

Need to check if a text block fits in a 500-char database field?

? LEN("paste the massive string here...")

Quick hex arithmetic:

? $FF * 2

No setup, no imports, no ceremony.

2. Unique Random Numbers Without Loops

Generating something like “6 out of 49” sounds trivial, but in many languages it immediately leads to loops or helper libraries.

jdBasic supports APL-style vector operations.
That means you can treat numbers like a deck of cards:

generate 1..49
shuffle the sequence
take the first 6 elements

' IOTA(49, 1) generates 1..49, SHUFFLE randomizes, TAKE gets the first 6
PRINT TAKE(6, SHUFFLE(IOTA(49, 1)))
' Output: [12 4 49 33 1 18]

No loops, no duplicate checks, no additional code.

3. ASCII Visualization in a Single Statement

In Python, visualization usually means installing and configuring libraries like matplotlib or pandas.

jdBasic takes a different approach:
2D arrays and string matrices are native data types.

This makes it possible to calculate and render ASCII charts directly in the console.

The following example is a complete biorhythm chart (physical, emotional, intellectual) rendered in one statement:

' One-liner Biorhythm Chart
BD="1967-10-21":W=41:H=21:D=DATEDIFF("D",CVDATE(BD),NOW()):X=D-W/2+IOTA(W):C=RESHAPE([" "],[H,W]):PY=INT((SIN(2*PI*X/23)+1)*((H-1)/2)):EY=INT((SIN(2*PI*X/28)+1)*((H-1)/2)):IY=INT((SIN(2*PI*X/33)+1)*((H-1)/2)):C[H/2,IOTA(W)-1]="-":C[IOTA(H)-1,INT(W/2)]="|":C[PY,IOTA(W)-1]="P":C[EY,IOTA(W)-1]="E":C[IY,IOTA(W)-1]="I":PRINT "Biorhythm for " + BD:PRINT FRMV$(C)

It calculates the sine waves for three different cycles, maps them to a 2D grid, overlays axes, and prints the result—all without a single external library or loop.

It returns to the roots of the 8-bit era: the computer is a calculator that is always ready.

4. Persistent Workspaces

In Python, a REPL session is temporary.
Once you close it, everything is gone unless you explicitly serialize your state.

jdBasic reintroduces an old idea: persistent workspaces.

SAVEWS "debugging_session"

The next morning, I open my console and type:

LOADWS "debugging_session"

Variables, functions, objects, history – everything is restored.
I use this constantly for long-running investigations:

one workspace for database analysis
one for AI experiments
one for automation tasks

5. Working with Corporate Data (MS Access, ADODB)

Enterprise environments often come with “unfashionable” data sources.
MS Access databases are a good example.

In Python, this usually means:

ODBC drivers
pyodbc
platform-specific setup

jdBasic uses COM and ADODB directly, without external libraries.

I keep a workspace called "SQL_Console" that contains a simple 150-line script (acct.jdb). It wraps the complexity of ADO into a simple REPL.

The Implementation (Simplified):

' Connect to Access without external libraries
conn = CREATEOBJECT("ADODB.Connection")
conn.Open("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=Orders.accdb")

' Execute SQL and get results
rs = CREATEOBJECT("ADODB.Recordset")
rs.Open("SELECT * FROM Orders", conn)

' Print results
DO WHILE NOT rs.EOF
    PRINT rs.Fields("Customer").Value; " | "; rs.Fields("Amount").Value
    rs.MoveNext()
LOOP

Because I save this in a workspace, I never re-type the connection string. I just load SQL_Console and fire queries:

ExecuteSQL "SELECT * FROM Users WHERE ID=5"

It returns a formatted Map or Array immediately.
Because this lives in a workspace, I never reconfigure it.
I just load it and run queries.

6. Desktop Automation: Controlling Windows Native Apps

Automating Windows applications used to be easy in the VB6 era.
In Python, it is possible, but often feels bolted on.

In jdBasic, COM automation is a core language feature.

' Launching Microsoft Word...
wordApp = CREATEOBJECT("Word.Application")
wordApp.Visible = TRUE
doc = wordApp.Documents.Add()

' Select text and format it via COM
sel = wordApp.Selection
sel.Font.Name = "Segoe UI"
sel.Style = -2 ' wdStyleHeading1
sel.TypeText "My Generated Doc"

7. Vector Math Without NumPy

In Python, element-wise math requires NumPy.

Python:

import numpy as np
V = np.array([10, 20, 30, 40])
print(V * 2)

jdBasic:
In jdBasic, arrays are first-class citizens. The interpreter knows how to handle math on collections natively.

V = [10, 20, 30, 40]
PRINT "V * 2: "; V * 2
' Output: [20 40 60 80]

There are no imports. No pip install. The interpreter understands what you mean.

8. Learning AI with Transparent Tensors

For production AI, Python frameworks are unbeatable.

For learning how things actually work internally, they can be opaque.

jdBasic has a built-in Tensor type with automatic differentiation.
Gradients are explicit and inspectable.

' Built-in Autodiff
A = TENSOR.FROM([[1, 2], [3, 4]])
B = TENSOR.FROM([[5, 6], [7, 8]])

' Matrix Multiplication
C = TENSOR.MATMUL(A, B)

' Calculate Gradients
TENSOR.BACKWARD C
PRINT "Gradient of A:"; TENSOR.TOARRAY(A.grad)

This is not about performance.
It is about understanding.

9. Micro-Services Without a Framework

In Python, even a small HTTP API usually involves a framework.

jdBasic includes an HTTP server as a language feature.

FUNC HandleApi(request)
  response = {
    "status": "ok",
    "server_time": NOW()
  }
  RETURN response
ENDFUNC

HTTP.SERVER.ON_POST "/api/info", "HandleApi"
HTTP.SERVER.START(8080)

Define a function, return a map, get JSON.

The Verdict: Ecosystem vs. Immediacy

This is not a “Python vs. BASIC” argument.
It is about choosing where you want to pay the cost.

Feature	jdBasic	Python
Session State	Native	Manual
Vector Math	Built-in	NumPy
Automation	Native COM / ADODB support.	`pyodbc` / `pywin32`.
Setup	Single executable	Virtual envs, pip, package management.

For production systems and large teams: Python is the right choice.

For an always-on, persistent, low-friction development console:
sometimes, my jdBasic interpreter is surprisingly effective.

Basic never really disappeared :-)

You can explore the interpreter's source code, dive into the documentation, and see more examples over at the official GitHub repository: jdBasic

You can try the main features online at: jdBasic

My jdBasic Interpreter Just Got True "Edit and Continue" — In VS Code

Atomi J.D. — Thu, 30 Oct 2025 14:37:03 +0000

We've all been there. You're 15 minutes into a complex debugging session, you've finally reproduced the bug, your app state is perfect, your variables are all set... and you spot the error. It's a one-line fix.

The painful choice: stop the debugger, lose your entire state, re-compile, re-run, and spend another 15 minutes getting back to where you were?

Not anymore.

I'm thrilled to announce that my custom-built interpreter, jdBasic, now supports a true "Edit and Continue" feature, running directly inside Visual Studio Code.

This isn't just "Live Reload" that restarts your app. This is a full p-code (bytecode) hot-swap that preserves your entire application state (call stack, global, and local variables) while the program is paused.

See it in Action

Talk is cheap. Here are three demos of this feature in action during a single, uninterrupted debug session.

1. Changing Function Signatures On-the-Fly

This is the big one. Most hot reload systems balk at changing method signatures. With jdBasic, you can add new parameters to a function, save, and the new signature is live instantly.

Here, I'm paused in the debugger, I change FUNC Add2(a) to FUNC Add(a, b), and then call the new signature from the immediate window.

2. Defining New Data Structures Live

What if you realize mid-debug that you're missing a data structure? No problem.

In this demo, I'm paused, I write a brand new TYPE Fluppi ... ENDTYPE definition, save the file, and then immediately DIM a new variable of that type and assign values to it.

3. Mutating State in the Immediate Window

Of course, no debugging experience is complete without an immediate window. While paused, you can execute any jdBasic command. Here, I'm changing the value of a variable C and then printing it with ? (the shortcut for PRINT). This is perfect for testing edge cases or forcing a specific logic path.

How It Works

This "magic" is possible because jdBasic is an interpreter that compiles source code into an internal p-code representation.

I run my code in VS Code with the debugger (F5).
When I hit a breakpoint, the program pauses.
I can edit any of my .jdb source files and hit Save (Ctrl+S).
The jdBasic interpreter detects the save, recompiles the entire source file into a fresh block of p-code, and atomically swaps the old p-code with the new one.
It then intelligently remaps the current execution pointer to the equivalent instruction in the new p-code.
I press "Continue" (F10), and the new, corrected code is executed.

Best of all, this fully supports VS Code's "Jump to Cursor" feature. If I make a huge change and the old execution pointer doesn't make sense, I can just right-click any line in my program, select "Jump to Cursor," and the interpreter will resume execution from that exact spot.

This has been a game-changer for my own productivity.

You can explore the interpreter's source code, dive into the documentation, and see more examples over at the official GitHub repository: https://github.com/AtomiJD/jdBasic

Forget GPUs: Let's Render a Spinning 3D Cube in a Console

Atomi J.D. — Sat, 27 Sep 2025 07:36:45 +0000

By day, I manage large-scale software projects for a Fortune 500 company. By night, I get back to my roots. After decades of programming in C (since 1990) and C++, I decided to build my own programming language from scratch, just for the fun of it: jdBasic.

This led me to a classic nerdy challenge: could I render a solid, spinning 3D object using only the characters in a standard console window?

Challenge accepted. The result is pure, real-time, ASCII-based 3D rendering:

This isn't a pre-recorded animation. It's a program calculating 3D transformations and perspective for every frame. And it's all running in jdBasic.

The Tool: What is jdBasic?

I built jdBasic to fuse the simplicity of classic BASIC with the power of modern programming paradigms. It’s a hobby, but a serious one, written in C++20. Think of it as a language where FOR...NEXT loops can coexist with:

APL-Inspired Array Programming: This is the secret sauce for the cube. You can perform math on entire matrices in a single line, no loops required.
A Built-in AI Engine: It has first-class Tensor objects and automatic differentiation for building and training neural networks.
Modern Features: It has Maps (dictionaries), TRY...CATCH error handling, and can even be extended with C++ DLLs.

You can explore the interpreter's source code, dive into the documentation, and see more examples over at the official GitHub repository: https://github.com/AtomiJD/jdBasic

Deconstructing the Cube

The magic behind the animation boils down to four key steps applied in every frame:

Define Geometry: We start with two matrices: one for the 8 (X, Y, Z) vertices of the cube, and another defining the 6 faces by referencing the vertex indices.
Apply Rotation: Standard trigonometry rotation matrices are used to calculate the new position of every vertex as the cube spins. This is done with a single MATMUL (Matrix Multiplication) operation.
Project to 2D: We simulate perspective to make the 3D object look right on a 2D screen. The simple rule is: objects farther away appear smaller. This entire calculation is "vectorized"—performed on all 8 vertices at once without a single FOR loop.
Use the Painter's Algorithm: To make the cube solid and hide rear faces, we calculate the average depth of each face, sort them from back to front, and draw them in that order. This ensures that closer faces are drawn on top of farther ones.

The Full Code

Here is the complete source code. The power of jdBasic's array-oriented functions makes it surprisingly compact.

' ==========================================================
' == Fully Optimized ASCII 3D Cube
' ==========================================================

' --- Configuration Section ---
SCREEN_WIDTH = 40
SCREEN_HEIGHT = 20

' --- 1. Define Vertices, Faces, and Transformations ---
DIM Vertices[8, 3]
Vertices = RESHAPE([-1,-1,-1,  1,-1,-1,  1, 1,-1, -1, 1,-1, -1,-1, 1,  1,-1, 1,  1, 1, 1, -1, 1, 1], [8, 3])

DIM Faces[6, 4]
Faces = RESHAPE([4,5,6,7, 0,3,2,1, 0,1,5,4, 2,3,7,6, 1,2,6,5, 3,0,4,7], [6, 4])

DIM FaceChars$[6]
FaceChars$ = ["#", "O", "+", "=", "*", "."]

DIM ScalingMatrix[3, 3]
ScalingMatrix = [[1,0,0], [0,2,0], [0,0,1]]

' --- 2. Main Animation Loop ---
DIM ScreenBuffer[SCREEN_HEIGHT, SCREEN_WIDTH]
DIM ProjectedPoints[8, 2]
AngleX = 0 : AngleY = 0
FocalLength = 5

' --- 3. Functions for Rotation and drawing---
FUNC CreateRotationX(angle)
    RETURN [[1, 0, 0], [0, COS(angle), -SIN(angle)], [0, SIN(angle), COS(angle)]]
ENDFUNC

FUNC CreateRotationY(angle)
    RETURN [[COS(angle), 0, SIN(angle)], [0, 1, 0], [-SIN(angle), 0, COS(angle)]]
ENDFUNC

SUB DrawLine(x1, y1, x2, y2, char$)
    dx = ABS(x2 - x1) : dy = -ABS(y2 - y1)
    sx = -1: IF x1 < x2 THEN sx = 1
    sy = -1: IF y1 < y2 THEN sy = 1
    err = dx + dy
    DO
        IF x1 >= 0 AND x1 < SCREEN_WIDTH AND y1 >= 0 AND y1 < SCREEN_HEIGHT THEN ScreenBuffer[y1, x1] = char$
        IF x1 = x2 AND y1 = y2 THEN EXITDO
        e2 = 2 * err
        IF e2 >= dy THEN err = err + dy : x1 = x1 + sx
        IF e2 <= dx THEN err = err + dx : y1 = y1 + sy
    LOOP
ENDSUB

SUB FillFace(points, char$)
    y_min = MAX([0, MIN(SLICE(points, 1, 1))])
    y_max = MIN([SCREEN_HEIGHT - 1, MAX(SLICE(points, 1, 1))])
    FOR y = y_min TO y_max
        intersections = []
        FOR i = 0 TO 3
            p1 = SLICE(points, 0, i)
            p2 = SLICE(points, 0, (i + 1) MOD 4)
            IF p1[1] <> p2[1] AND ((y >= p1[1] AND y < p2[1]) OR (y >= p2[1] AND y < p1[1])) THEN
                intersections = APPEND(intersections, p1[0] + (y - p1[1]) * (p2[0] - p1[0]) / (p2[1] - p1[1]))
            ENDIF
        NEXT i
        IF LEN(intersections) >= 2 THEN
            FOR x = MAX([0, MIN(intersections)]) TO MIN([SCREEN_WIDTH - 1, MAX(intersections)])
                ScreenBuffer[y, x] = char$
            NEXT x
        ENDIF
    NEXT y
ENDSUB

CURSOR FALSE

F = 0

DO
    ' --- a) Rotate & Scale Vertices ---
    CombinedTransform = MATMUL(ScalingMatrix, MATMUL(CreateRotationY(AngleY), CreateRotationX(AngleX)))
    RotatedVertices = MATMUL(Vertices, CombinedTransform)

    ' --- b) Vectorized Perspective Projection ---
    X_col = SLICE(RotatedVertices, 1, 0)
    Y_col = SLICE(RotatedVertices, 1, 1)
    Z_col = SLICE(RotatedVertices, 1, 2)
    Perspective = FocalLength / (FocalLength - Z_col)
    ScreenX = (X_col * Perspective) * (SCREEN_WIDTH / 8) + (SCREEN_WIDTH / 2)
    ScreenY = (Y_col * Perspective) * (SCREEN_HEIGHT / 8) + (SCREEN_HEIGHT / 2)
    ProjectedPoints = STACK(1, INT(ScreenX), INT(ScreenY))

    ' --- c) Vectorized Painter's Algorithm ---
    FaceZCoords = RESHAPE(Z_col[Faces], [6, 4])
    FaceDepths = SUM(FaceZCoords, 1) / 4
    DrawOrder = GRADE(FaceDepths)

    ' --- d) Draw Faces from Back to Front ---
    ScreenBuffer = RESHAPE([" "], [SCREEN_HEIGHT, SCREEN_WIDTH])
    FOR i = 0 TO 5
        face_idx = DrawOrder[i,0]
        v_indices = SLICE(Faces, 0, face_idx)
        face_x_coords = SLICE(ProjectedPoints, 1, 0)[v_indices]
        face_y_coords = SLICE(ProjectedPoints, 1, 1)[v_indices]
        face_points = STACK(1, face_x_coords, face_y_coords)

        FillFace face_points, FaceChars$[face_idx]
        FOR p = 0 TO 3
            p1 = SLICE(face_points, 0, p)
            p2 = SLICE(face_points, 0, (p + 1) MOD 4)
            DrawLine p1[0], p1[1], p2[0], p2[1], "*"
        NEXT p
    NEXT i

    ' --- e) Render and Update ---
    CLS
    PRINT "Fully Optimized 3D Cube (Press any key)"
    PRINT FRMV$(ScreenBuffer)
    YIELD
    AngleX = AngleX + 0.05 : AngleY = AngleY + 0.08
    F = F + 1
LOOP UNTIL F > 200

CURSOR TRUE

Try It Yourself

You can run this code right now in your browser. No installation needed.

Go to the jdBasic Web REPL: https://jdbasic.org/live/index.html
Type EDIT and press Enter.
Paste the entire code block from above into the editor.
Click the "Save & Close" button.
Type RUN and press Enter.

Enjoy the show! Happy hacking.

My 49-Year Journey: From a 1976 IBM 5100 to Building an AI-Powered BASIC

Atomi J.D. — Mon, 08 Sep 2025 14:51:33 +0000

Hi everyone,

I wanted to properly introduce myself and share the project that's become my obsession. Let's start with the code comment version:

// Name: AtomiJD
// Coding Since: 1976 (APL on IBM 5100)
// Current Stack: C++, Python, C#
// Core Passion: Building programming languages

That tiny comment block spans nearly five decades. My first taste of programming was on a IBM 5100 in APL.

But this post isn't just about the past. It's about a question: What if BASIC hadn't stopped evolving? What if it had kept up, borrowing ideas from APL, Python, and LISP, and even embraced the AI revolution?

I decided to find out.

The Sprint: Building jdBasic with an AI Partner

This project, jdBasic, came to life in an intense, two-month coding marathon. It wasn't a solo journey in a dark room. It was a dynamic, modern process I can only describe as "vibe coding" with Google's Gemini and ChatGPT.

The result is a language that I believe is truly unique. It's a blend of retro simplicity and modern power.

What is jdBasic? A Tour of the Core Features

jdBasic is a modern interpreter designed to be easy to learn but powerful enough for complex tasks. Here are some of the things that make it special:

APL-Inspired Array Programming: At its heart, jdBasic is an array-first language. Most operations are element-wise by default. You can multiply a whole vector by a number or add two matrices together without a single FOR loop.
A Functional Core: It embraces functional concepts like higher-order functions, lambdas, and a pipe operator (|>) for creating elegant, readable data pipelines.
Object-Oriented Style: You can define your own complex data structures with methods using TYPE...ENDTYPE, allowing for a clean, object-oriented approach.
Built-in 2D Game Engine: It has a complete multimedia toolkit with a sprite system (including Aseprite animation support), tilemap integration (from the Tiled editor), collision detection, sound, and graphics commands.
Reactive Programming: Create variables that automatically update when the values they depend on change, using a simple -> operator for spreadsheet-like behavior.
An Integrated AI Engine: This is the big one. jdBasic has a built-in Tensor object with automatic differentiation. You can build and train complex neural networks, from simple models to Transformers, right inside the interpreter with high-level commands.

Show, Don't Just Tell: jdBasic in Action

Talk is cheap. Here’s what the code actually looks like.

1. Functional Pipelines
Here, we generate numbers 1-10, filter for values greater than 5, and multiply them by 10—all in one clean, declarative line.

' Start with a sequence of numbers from 1 to 10
numbers = IOTA(10)

' This pipeline:
' 1. Filters numbers > 5
' 2. Multiplies the remaining numbers by 10
result = numbers |> FILTER(lambda val -> val > 5, ?) |> SELECT(lambda v -> v * 10, ?)

PRINT "Result: "; result
' Expected Output: [60 70 80 90 100]

2. The Power of APL-Style One-Liners
The true power of the array-first design is that you can create complex visual output without loops. This single line of code calculates and plots a personal biorhythm chart directly in the console.

BD="1967-10-21":W=41:H=21:D=DATEDIFF("D",CVDATE(BD),NOW()):X=D-W/2+IOTA(W):C=RESHAPE([" "],[H,W]):PY=INT((SIN(2*PI*X/23)+1)*((H-1)/2)):EY=INT((SIN(2*PI*X/28)+1)*((H-1)/2)):IY=INT((SIN(2*PI*X/33)+1)*((H-1)/2)):C[H/2,IOTA(W)-1]="-":C[IOTA(H)-1,INT(W/2)]="|":C[PY,IOTA(W)-1]="P":C[EY,IOTA(W)-1]="E":C[IY,IOTA(W)-1]="I":PRINT "Biorhythm for " + BD + " | P=Physical(23) E=Emotional(28) I=Intellectual(33)":PRINT FRMV$(C)

3. Object-Oriented TYPEs for a Game
Define a Player type with its own data and methods, just like a class.

TYPE Player
    Name AS STRING
    Health AS INTEGER

    ' Method to take damage
    SUB TakeDamage(damage)
        THIS.Health = THIS.Health - damage
        IF THIS.Health < 0 THEN THIS.Health = 0
        PRINT THIS.Name; " takes "; damage; " damage! Health is now "; THIS.Health
    ENDSUB
ENDTYPE

' Create a player instance
DIM Hero AS Player
Hero.Name = "Arion"
Hero.Health = 100

Hero.TakeDamage(15)

4. The Magic of Built-in AI (Auto-differentiation)
No Python, no complex libraries. Just create Tensor objects, perform math, and call TENSOR.BACKWARD to automatically calculate all the gradients needed for training a neural network.

' Create two simple tensors
A = TENSOR.FROM([[1, 2], [3, 4]])
B = TENSOR.FROM([[5, 6], [7, 8]])

' Forward Pass (this operation's history is tracked)
C = MATMUL(A, B)

' Backward Pass (calculate gradients for A and B automatically)
TENSOR.BACKWARD C

' Check the calculated gradients
PRINT "Gradient of A:"; TENSOR.TOARRAY(A.grad)

So, Who is This For?

I designed jdBasic to be a "get things done" language for several groups:

Educators and Hobbyists: A simple, self-contained environment to teach programming, from turtle graphics to game logic.
Indie Game Devs: A fast way to prototype and build 2D retro games without the overhead of large engines.
AI/ML Students & Curious Programmers: An incredibly accessible way to learn the fundamentals of neural networks without getting lost in Python's ecosystem.
Power Users & Scripters: A powerful "glue" language for automating tasks, parsing files, and even creating simple web APIs with the built-in HTTP server.

I'd Love to Hear From You

This project has been a fusion of my entire career's experience with today's incredible technology. Now, I'm excited to share it with a wider community.

You can check out the project, download the latest release, and dive into the documentation on GitHub:

Main Repo: https://github.com/AtomiJD/jdBasic
Docs: Language Reference (https://github.com/AtomiJD/jdBasic/languages.md) and The Official Manual (https://github.com/AtomiJD/jdBasic/manual.md)

I have a few questions for the DEV community:

What was the first programming language that made you fall in love with code?
Looking at the features, what's the first thing you would be tempted to build with jdBasic?
Does a language like this have a place in 2025?

Thanks for reading. I can't wait to see what you think!

Cheers :- )