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

Source: Dev.to

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

Python’s strength is its ecosystem, but 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 isn’t.

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:

1. open a terminal
2. start a REPL
3. import something
4. run a quick check
5. close everything again

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

Example: Length of a massive string

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

Example: Quick hex arithmetic

? $FF * 2

No setup, no imports, no ceremony.

---

2. Unique Random Numbers Without Loops

Generating something like “6 out of 49” often forces loops or helper libraries.
jdBasic supports APL‑style vector operations, so you can treat numbers like a deck of cards:

' 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 such as matplotlib or pandas.
jdBasic takes a different approach: 2‑D arrays and string matrices are native data types, making it possible to calculate and render ASCII charts directly in the console.

The following one‑liner produces a complete biorhythm chart (physical, emotional, intellectual) rendered entirely in ASCII:

' 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 three sine waves, maps them to a 2‑D grid, overlays axes, and prints the result—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

A Python REPL session is temporary; once you close it, everything disappears unless you explicitly serialize your state.
jdBasic reintroduces an old idea: persistent workspaces.

SAVEWS "debugging_session"

Later, you can restore everything with a single command:

LOADWS "debugging_session"

Variables, functions, objects, and history are all 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 involve “unfashionable” data sources such as MS Access. In Python this usually means:

• ODBC drivers
• pyodbc
• platform‑specific setup

jdBasic uses COM and ADODB directly, without external libraries.

Simplified Implementation

' 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.

---

6. Desktop Automation: Controlling Windows Native Apps

Automating Windows applications was easy in the VB6 era. In Python it’s possible, but often feels bolted on. In jdBasic, COM automation is a core language feature.

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

' Select text and format it via COM
sel = wordApp.Sel
sel.TypeText "Hello from jdBasic!"
sel.Font.Bold = TRUE

With a few lines you can drive any COM‑exposed application, making rapid prototyping and UI automation a breeze.

---

Closing Thoughts

jdBasic isn’t trying to replace Python; it’s a different philosophy: embed the most common, “pain‑point” operations directly into the language so you can stay in the REPL, avoid ceremony, and keep the friction to a minimum.

Give it a try for those moments when you just need a quick scratchpad that does everything out of the box.

Section

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.

• 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