DEV Community

Achim J.D.
Achim J.D.

Posted on

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

#programming #ai #basic #gamedev

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
Enter fullscreen mode Exit fullscreen mode

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]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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:

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

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

Cheers :- )

Top comments (0)