From Stone Age to AI

New weekly direction begins. Students review the week introduction, watch or listen to material, and complete the first small assignment on their own time.

Students continue with the next lesson and assignment by reading some kind of documents. This could be in the form of PDF, a Web page, a text file, a source code file or any combination. But the focus of this course is steady daily progress without requiring everyone to be online at the same time.

Midweek work continues with another focused lesson, practice task, or reflection question tied to the course outline.

Students build on the earlier lessons and prepare questions for the optional live Q&A or recorded support material.

The week wraps up with a review assignment, checkpoint, or summary activity so students can see what they learned before moving forward.

The course is planned at $25 per week. Coursework is assigned daily, Monday through Friday, and students complete it in their own time.

A live question-and-answer meeting may be offered once per week. Attendance is optional, and recordings will be made and shared when possible.

Additional live help may be arranged when needed using chat, voice, video, or desktop sharing for troubleshooting and deeper explanation.

Tally sticks, the abacus, astrolabes, slide rules, and the Antikythera mechanism show that computing began long before electronics.

Students learn that computing is not just modern programming; it is the long human effort to automate counting, comparison, and decision-making, often used in navigation, surveying, and timing celestial or seasonal events. This section includes a more detailed look at the astrolabe, circular slide rule, and the evolution of clocks up to pendulum clocks.

Optional expansion can include analog fire-control computers, navigation tools, and mechanical calculators. Examples include submarine and U-boat torpedo calculators, missile trajectory calculators, and bombsights. The textile industry also used programmable machines such as the Jacquard loom (1804) for weaving cloth, rugs, and carpets.

Mechanical analog, mechanical digital, electrical analog, and electrical digital systems. How are values and states stored in each type? How are values input and output? This study also covers the development of clocks up to Babbage, just prior to electrical and later crystal-controlled clocks.

Example prompts: What was the Antikythera (100 BC) mechanism, and why do people call it an ancient computer? What were the Pascaline (1642) and Curta (1948) mechanical calculators?

Students compare decimal, Babylonian base-60, Roman numerals, and other counting systems to see that number representation is a design choice. Humans use base 10, while everyday systems often use mixed bases such as 12 inches per foot, 24 hours per day, 60 minutes per hour, 360 degrees in a circle, and 5,280 feet in a mile. Other civilizations used systems such as Roman numerals, Babylonian base-60, and Mayan base-20. Fictional aliens might use base 3, 52, or 77. Computers primarily use base 2 (binary), while programming languages often use base 16 (hexadecimal), base 10 (decimal), and occasionally base 8 (octal).

Students learn bits, bytes, binary, hexadecimal, simple conversions, and how numbers and characters are represented inside a computer. Binary can be compared to a combination lock with only two positions on each tumbler. A byte has eight tumblers, giving 256 possible combinations. This section also explains number storage and simple arithmetic. How negative numbers are stored Two's Compliment. Data sizes Bit, Byte, Kilobyte, Megabyte, Gigabyte, Terabyte.

Optional topics include signed numbers, floating-point representation, error correction, ternary computer experiments (such as the Soviet Setun in 1958 and Setun-70), and why binary became dominant. Mainframe storage in words, double words etc.

Students can connect number systems to logic gates, digital electronics, ASCII, Unicode, color codes, file sizes, and memory addresses. This section also explores electronic components that represent on/off states, including relays, transistors, and voltage levels, as well as components such as capacitors that can store information. Tapes, Disk, Optics, SD.

Example prompts: Show me step by step how decimal 255 becomes FF in hexadecimal. Show me a side-by-side table of decimal, binary, and hexadecimal values from 0 to 16. What kinds of computers exist other than the CPUs we commonly use? What are biochemical, optical, DNA, atomic, and quantum computers? What is a quantum computer, and will it replace conventional computers?

From Babbage to Lovelace to Turing to von Neumann to the 8-Bit Era and Beyond

This week explains the core ideas that make all computers work. Relays, vacuum tubes, transistors, and integrated circuits evolved into modern processors. Once a machine can store data (memory), make decisions (if/else), repeat instructions (jumps and loops), and perform calculations (expressions and variables), it becomes capable of universal computation. This property is called Turing completeness. We trace the historical development of computing from Charles Babbage's mechanical designs, to Ada Lovelace's insight that machines could manipulate symbols, to Alan Turing's theoretical foundations and wartime work, to John von Neumann's stored-program architecture, and finally to the 8-bit personal computers of my early days that introduced computing to millions of people. We then work our way from the 1980s to today.

Founding Fathers and Mother (First Programmer)

• Charles Babbage (1791-1871)
  Designed the Analytical Engine, a mechanical computer concept with a "mill" (CPU), a "store" (memory), and punched-card programming.
• Ada Lovelace (1815-1852)
  Wrote what is widely regarded as the first published algorithm intended for a machine and recognized that computers could process more than numbers, including music and symbols.
• Alan Turing (1912-1954)
  Developed the concept of the Turing machine and helped break German Enigma codes during World War II. His story is dramatized in the film The Imitation Game. Turing also contributed to the design of machines used at Bletchley Park. Colossus, the first large-scale programmable electronic computer, was used to break the Lorenz cipher of the German high command.
• John von Neumann (1903-1957)
  Formalized the stored-program architecture, in which instructions and data reside in the same memory. Mainstream languages such as C, C++, Java, and JavaScript are often described as von Neumann languages because they emphasize statements, loops, variables, if/else logic, and expressions.
• 8-Bit Era (1970s-1980s)
  Computers such as the Apple II, TRS-80 Model I, Atari 400/800, and Commodore 64 brought computing into homes, schools, and small businesses. I grew up on the Commodore 64 and used it for nearly a decade.
• Modern Computing and AI
  Today's systems are enormously faster and more complex, but they still follow the same core principles envisioned by these pioneers. What has been added are layers of optimization and abstraction. Performance has increased exponentially rather than linearly. AI applications can be viewed as software libraries built from objects, which are built from functions and subroutines, which are built from machine instructions. Bits -> Bytes -> Instructions -> Subroutines -> Objects -> Libraries -> AI Applications. Modern AI also depends on massive datasets and, often, the internet for training and information retrieval.

Students learn CPU, RAM, storage, input, output, and clock cycles; what a program is made of; commands (instructions) or statements; loops and branching; decisions; expressions; variables; and algorithms. Briefly: machine language vs. assembly language vs. C vs. higher-level languages. Machine subroutines are used to repeat code. Machine subroutines can also function as routines that return values. 4-bit, 8-bit, 16-bit, 32-bit, and 64-bit architectures. Clock speeds: 1970s - kilohertz (kHz) 1980s - megahertz (MHz) 1990s - hundreds of megahertz 2000s - gigahertz (GHz) 2010s to today - multicore processors.

Optional topics include registers, flags, interrupts, and the differences between subroutines, functions, procedures, and methods. Larger architectures may use 128-bit, 256-bit, 512-bit, or even 1024-bit registers for specialized operations. Could a CPU be designed to process fewer bits per clock cycle? Yes. In principle, a 2-bit or even 1-bit CPU is possible. A 1-bit processor is essentially a serial processor, and such designs have existed.

Relay logic began in industry to control automated machinery. This has continued into the computer age as PLC (Programmable Logic Controller) programming. Students can connect this section to CompTIA A+, PC hardware, motherboard diagrams, embedded systems, and troubleshooting. Ask: What was the architecture of the Apollo Guidance Computer used during the moon landings?

Example prompts: Explain how a CPU executes one instruction step by step using a simple pretend computer. Explain caches, pipelines, memory maps, and simple CPU diagrams. What is bytecode, and what are virtual machines? What is Java bytecode and the Java Virtual Machine? Java has bytecode, but do all virtual machines have "bytecode"? Show me simple examples of Java bytecode. Show me simple examples of machine language. Show me simple examples of assembly language. What's the difference between an algorithm, a program, and a subroutine?

Early programmers worked very close to the machine. Programs were entered through front-panel switches, plugboards, punched cards, paper tape, and later assembly language. Regardless of the medium, the programmer was still specifying a sequence of basic instructions for the computer to execute.

At the lowest level, nearly every instruction set can be broken into a small set of fundamental operations:

Load data
Store data
Perform arithmetic and logic
Compare values
Make decisions (conditional branching)
Repeat operations (loops)
Call subroutines
Handle input and output
Stop or halt


The earliest computers had relatively small and simple instruction sets. ENIAC (1945), for example, was programmed by setting switches and rewiring cables. EDSAC (1949) and early IBM systems began using stored programs, where instructions were kept in memory and could be changed without rewiring the machine.

When we enter the age of microprocessors and calculators, the same ideas appear on a smaller scale. The first commercial microprocessor, the Intel 4004, was originally designed for calculators. It was followed by:

4-bit processors (early 1970s, calculators and controllers)
8-bit processors (mid-1970s to 1980s: MOS Technology 6502, Zilog Z80, Intel 8080)
16-bit processors (late 1970s to 1980s: Intel 8086)
32-bit processors (1980s through 2000s)
64-bit processors (mainstream consumer systems by the 2000s and 2010s)


That progression describes the consumer and small-business market, but larger organizations had powerful systems long before desktop computers became common.

In the 1960s and 1970s, governments, universities, and large businesses relied on minicomputers and mainframes such as the IBM System/360, DEC PDP-8, and DEC VAX-11/780. These systems often featured larger word sizes, more registers, and more sophisticated input/output capabilities than consumer machines.

Some specialized systems used very large word sizes—128 bits, 512 bits, or even larger—particularly in vector supercomputers such as the Cray-1. In these machines, a “512-bit register” often meant a vector register holding many values at once rather than a single ordinary integer.

As architectures grew more capable, instruction sets often became larger and more complex. This design philosophy became known as CISC (Complex Instruction Set Computer). The Intel x86 is a classic example, with a large instruction set and decades of backward compatibility.

In the 1980s, researchers revisited a simpler design philosophy called RISC (Reduced Instruction Set Computer). Systems such as MIPS, SPARC, and later ARM emphasized smaller, simpler instructions that could be executed very efficiently.

Whether a computer is mechanical, vacuum tube, transistor, or modern silicon, the central idea remains the same: a computer executes a sequence of simple instructions to move data, process it, make decisions, and produce output. Everything from calculator chips to smartphones to AI systems is built on that same fundamental model.

Students will learn the fundamental concepts of machine language and assembly language, including opcodes, operands, registers, flags, labels, jumps, branching, simple memory access, and the relationship between assembly language and the underlying machine instructions executed by the CPU.

Examples will be kept deliberately simple. This is a non-coding course; the objective is not to teach the syntax of any particular assembly language, but to reveal the concepts that all assembly languages and instruction sets have in common. To that end, I will frequently use pseudo code, mock assembly language, and simplified diagrams that emphasize ideas over technical detail.

Students may also “play computer” on paper, manually stepping through instructions and updating registers, memory, and output as software engineers often do on whiteboards around the world. This exercise helps make the fetch-decode-execute cycle concrete and understandable.

Where useful, I may demonstrate examples using 8-bit assembly language from classic home computers such as the Commodore 64, whose 6510 processor provides a clean and historically important example of a simple instruction set. Emulators for most popular historical computers are readily available for Windows, Linux, and macOS.

I will also refer students to the excellent online Little Man Computer Simulator, which provides a highly simplified educational computer for experimenting with machine language concepts.

Finally, I may demonstrate selected examples on an IBM System/370 emulator. The IBM System/370 represents a historically significant large-scale computer architecture and offers students a glimpse into the assembly language used on business, government, and university mainframes during the 1970s and beyond. I will also provide some deep dive examples for some PC apps that can be made to run at the console, similar to console commands.

The goal of this week is to help students understand that all software—from C and Java to modern operating systems and artificial intelligence systems—ultimately reduces to a sequence of simple instructions executed one step at a time by a machine.

Code that runs directly as machine code, or as compiled native code, generally runs most efficiently on a computer because all interpreter overhead has been removed. The processor executes the instructions directly rather than first translating them at runtime.

In theory, you could write all of your software in assembly language and produce some of the fastest and smallest programs possible. In practice, however, it would take an enormous amount of time to develop programs of any significant size or complexity, which includes most software written today. Assembly language is powerful, but it is also tedious to write, debug, and maintain.

This is why higher-level languages came into being. Languages such as FORTRAN, COBOL, C, C++, Java, and Python were developed to make software easier for humans to read, write, debug, and maintain. Although these languages may introduce some overhead, they greatly increase programmer productivity and make it possible to build the large and sophisticated systems we rely on today.

JIT, or just-in-time compilation, is where higher-level language code is converted into machine code while the program is running. This can happen from a scripting language down to machine code, or from bytecode down to machine code. Inline code is where small sections of code, such as simple loops or frequently used operations, are expanded directly into machine code to improve efficiency. In some languages and runtime systems, code that runs often can be recompiled and optimized more than once to reach greater efficiency.

I will provide some code for simple keyboard input, screen output, and file read/write operations for both Windows and Linux. I will also recommend compilers and may provide video demonstrations. This is meant to demonstrate making simple console commands. Usually this is done with C, not assembly language. Assembly language will be used only to help students fully grasp the machine itself and how it works internally.

Look into various electronic controllers and embedded computing platforms. To name a few: Phidgets, Pyboard, ESP32, Arduino, and the PLC (Programmable Logic Controller) systems we mentioned in previous study.

Phidgets supports a wide variety of programming languages, including Java, Python, C#, and others. Pyboard is designed primarily to run Python through MicroPython. ESP32 can be programmed in C, C++, MicroPython, and JavaScript-based environments. Arduino is most commonly programmed in a simplified form of C and C++.

Although these platforms are typically programmed in higher-level languages, all of them ultimately execute machine instructions specific to their processors. In principle, you can study and program most of them in assembly language, although I have not yet explored that in depth myself.

Among these devices, you will find a wide range of processor architectures, including 8-bit, 16-bit, 32-bit, and 64-bit systems.

The Raspberry Pi is a single-board computer rather than a simple microcontroller. It can be used as a controller, but it is also capable of functioning as a full desktop or server computer. Modern Raspberry Pi models use ARM processors and support both 32-bit and 64-bit operation. They typically run Raspberry Pi OS, an ARM version of Linux.

Of all of these, take a look at the ATmega328P used in the Arduino Uno. This 8-bit microcontroller is small, inexpensive, and has a simple, well-documented assembly language, making it an excellent platform for learning how computers work at the machine level.

The PIC16F84 is another classic 8-bit microcontroller with a very small instruction set. It became one of the most popular devices for learning embedded programming and assembly language during the 1990s.

I could have introduced these simple controllers in the next section, and I may move them there later. Most of these platforms are commonly programmed in C or C++. However, I wanted to show you a variety of processors and controllers that you can explore in assembly language if you desire.

• Show me an example of early assembly language code.
• Show me an example of machine code and explain what each byte represents.
• Show me an example of generic bytecode.
• Show me an example of Java bytecode.
• Show me an x86 assembly language example.
• Show me an IBM System/370 assembly language example.
• Show me an ARM assembly language example.
• Show me a RISC-V assembly language example.
• Show me a Commodore 64 (6502) assembly language example.
• Explain the difference between assembly language and disassembly.
• Show me the same simple program in C64, x86, ARM, and IBM 370 assembly language.
• Give me a simple example showing how RISC assembly differs from x86 assembly.
• Compare CISC and RISC instruction sets with code examples.
• Show me how a Java statement is translated into Java bytecode.
• Show me how Java bytecode is translated into machine code by the JVM.
• Give me a brief synopsis of the Intel 80386 instruction set.
• Show me how a loop looks in assembly language.
• Show me how an if/then decision is implemented in assembly language.
• Show me how a function or subroutine call works in assembly language.
• Show me how registers and flags are used in a simple assembly program.
• Show me how machine code, assembly language, and a high-level language relate to one another.

C grew out of the need to build Unix and other portable systems software without rewriting everything for every machine.

Java came along about 25 years later and achieved a very high degree of portability through the Java Virtual Machine (JVM). Carefully written ANSI/ISO C is also highly portable, though not to the same extent as Java.

Carefully written ANSI/ISO C: often 80-95% portable.
Typical practical C code: often 60-90% portable.
OS-specific or hardware-specific C code: much lower.

BCPL (Basic Combined Programming Language)

BCPL was created in 1966 by Martin Richards at the University of Cambridge. It was designed as a simple, portable systems programming language and directly inspired the B programming language.

B Programming Language

B was developed around 1969 by Ken Thompson at Bell Labs. It was a simplified version of BCPL used to help create early versions of the Unix operating system. B lacked built-in data types, and its limitations led Dennis Ritchie to develop C in 1972.

C Programming Language

C was developed in 1972 by Dennis Ritchie at Bell Labs as an improved version of B. It added data types, pointers, and structures, making it powerful enough to rewrite much of the Unix operating system in a portable high-level language. C went on to become one of the most influential programming languages ever created and has been used to implement large portions of many operating systems, including Unix, Linux, Windows, macOS, iOS, Android, and countless embedded systems and microcontrollers.

Students revisit the same Turing completeness and von Neumann architecture concepts introduced in earlier weeks, but now at a higher level of abstraction using the C programming language.

The goal is not to teach C in depth, but to use C to demonstrate core computing concepts such as:

• Variables and data types
• Functions
• Control flow (if, while, for)
• Arrays
• Pointers and memory addresses
• Structured programming

Students will use a compiler and console to build and run simple programs. This is how most software engineering students begin learning a new programming language: by writing small console applications.

C is a compiled language. Source code files are converted into object files, which are then linked together to create the final executable file. Scripting languages often have two basic steps: write and run. Compiled languages usually have three basic steps: write, compile, and run.

Examples will be shown for both Linux and Windows. Linux uses the GCC command-line tool. Windows uses the Code::Blocks IDE, which includes a Windows version of GCC. Microsoft also provides its own C/C++ compiler through Visual Studio.

On Linux, the basic command is: gcc input-source-file.c -o output-executable-file. The executable file is then run from the command line.

On Windows, students can compile the source code in Code::Blocks and then run the resulting executable from the console as if it were a system command.

If the program outputs to the console, the results are displayed after the program runs. If it reads from a file, it may display information, write back to the same file, or write to another file. If the program writes to a file, students can use the type command or Notepad to view the file contents.

The first program is traditionally called Hello, World!, a kind of "baby program" that proves the software can be compiled, started, and produce output. This same pattern applies throughout software development, whether building console tools, web applications, client-server systems, or mobile apps.

Students will see that output can be directed to many destinations, including:

• The screen
• A printer
• A file
• A network connection
• A log file
• A database

The first rule of software development is simple: Make it work.

Next, students will learn basic file input and output. Memory is temporary; when the power is turned off, everything in RAM is lost unless it is saved to permanent storage.

Finally, students will learn that a C console program is essentially the same kind of program as a system command. Demonstrations will show how command-line arguments are passed into a C program for processing.

Syntax is the grammar of a programming language, and it must be exact. If the syntax is incorrect, the compiler will generate an error message showing what it did not understand, along with a line number and other helpful information.

A semantic error, also called a logic error, occurs when the code is syntactically correct but does not produce the intended result. In other words, "You did what I told you to do, computer—not what I wanted you to do!"

Compiled languages report errors detected during compilation, such as syntax errors and type mismatches. Both scripting languages and compiled programs can also experience runtime errors while executing.

Also see:

• Macros (#define)
• Symbolic constants with const
• Enumerated types with enum
• Inline functions with inline
• Differences between macros and functions
• Conditional compilation (#ifdef, #ifndef)
• Header files and library interfaces such as <stdio.h> and <stdlib.h>
• The #include directive
• Include guards to prevent multiple inclusion

Related languages and shell scripting. Shell scripts are used to automate system tasks that you would normally perform manually at the command line.

• C++
• Objective-C
• C#
• Java
• Rust
• C Shell (csh)
• Bash Shell (bash)
• Shell scripting

Students are encouraged to study operating systems and command-line environments, including Unix, Linux, DOS, Windows, and PowerShell. It is also helpful to learn the structure of Linux and Windows file systems and how programs interact with files, directories, and devices.

The world of system commands is a useful parallel study because operating systems provide hundreds of small programs that can be run from a command line. These commands can be grouped into categories such as navigation, file management, text processing, networking, process control, and software development.

Both Unix/Linux and Windows provide command-line environments where commands are entered in a similar way. A C console application follows the same model as any system command: it accepts parameters, reads input, performs work, and produces output.

A main takeaway from this course should be that the command line has never gone away. Despite graphical user interfaces, software engineers and system administrators continue to use the command line extensively.

• Show how a C pointer relates to a memory address using a simple drawing-like explanation.
• Explain a Java reference.
• How are C pointers and Java references different?
• Why does Java not have pointers?
• Explain the evolution of computer operating systems.
• What are pipes and redirection at the command line?
• What are standard input, standard output, and standard error?
• Is an operating system like a musical conductor or an air traffic controller?
• What does the operating system do or manage exactly?
• What are the classifications of operating system commands?

Simula and Smalltalk helped introduce object-oriented ideas before C++, Java, C#, and many later languages spread them widely.

Students learn classes, objects, fields, methods, encapsulation, and the basic idea of modeling real or imaginary things in code.

Optional topics include inheritance, polymorphism, interfaces, composition, design patterns, and when OOP can be overused.

Students can compare objects to assembly lines, parts catalogs, blueprints, machines, vehicles, games, and business records.

Example prompt: Explain objects using cars, tools, or building blocks before showing code.

Languages evolved for operating systems, business software, games, web pages, enterprise servers, mobile apps, and scripting.

Students compare compiled, interpreted, and hybrid execution models using JavaScript, C++, C#, and Java as examples.

Optional topics include bytecode, virtual machines, JIT compilers, garbage collection, runtimes, and language ecosystem tradeoffs.

Students can connect languages to web browsers, desktop apps, Android apps, servers, game engines, and cloud platforms.

Example prompt: Compare Java, C#, C++, and JavaScript in plain English for a beginner.

Students see the path from early symbolic AI and expert systems to machine learning, neural networks, transformers, and modern LLMs.

Students learn basic AI vocabulary: algorithms, data, training, inference, models, neural networks, tokens, and pattern recognition.

Optional topics include GPUs, CUDA, transformers, embeddings, model limits, hallucinations, and the difference between tools and intelligence.

Students can study ethics, bias, critical thinking, automation, jobs, AI-assisted learning, and how to use AI without surrendering judgment.

Example prompt: Explain how a neural network is similar to and different from traditional programming.

This course may collect basic information needed to operate the class, communicate with students, and provide course access.

Information that may be collected:

• Name
• Email address
• Telegram username or group participation information
• Payment information handled by third-party payment processors
• Chat messages, submitted assignments, and course questions
• Optional audio, video, screen sharing, or chat participation during live sessions

Personal information is used only to operate the course, provide support, communicate with students, and maintain records when needed. Personal information is not sold. Students may request removal from the course and deletion of stored information, subject to legal, accounting, and legitimate recordkeeping requirements.

Live Q&A sessions may be recorded and shared with enrolled students. By participating in a live session, students consent to the recording of their voice, image, screen sharing, and chat messages. Students who do not want to appear on camera should keep cameras off and may participate by chat when available.

Course recordings and student contributions are intended for enrolled students only unless additional written permission is obtained.

Testimonials, public excerpts, student comments, screenshots, or clips from live sessions will not be used publicly for marketing without separate permission from the student or, when applicable, a parent or guardian.

• Course materials are for enrolled students only.
• Redistribution of recordings, documents, assignments, or private group content is prohibited.
• Respectful conduct is required in live sessions, Telegram groups, chats, and course discussions.
• Students should not share private personal information in public course areas.
• Live sessions may be recorded and shared with enrolled students.
• Students may be removed from the course for disruptive, abusive, or unsafe conduct.

Refund terms will be stated clearly at the time of registration. For an initial small-course launch, a simple written refund policy is given before accepting payment.

If students under 18 participate, a parent or guardian should register, approve participation, and consent to any recordings.

Extra caution will be used when collecting personal information from minors or sharing any content involving minors.

• Make all live sessions optional.
• Encourage students to keep cameras off if they prefer privacy.
• Mute participants unless asking questions.
• Share recordings only with enrolled students.
• Obtain explicit permission before using testimonials or student content publicly.