Building Machines In Code – Part 8

This entry is part 8 of 9 in the series Building Machines in Code

Adding a Crude Console Last time, we left off with a working computer system using the Tiny-T processor. I told you that we would add a very crude terminal to the system this time. The terminal I’ll present today is barely a terminal. It won’t have any special functions, text scrolling, or any other features

Building Machines In Code – Part 7

This entry is part 7 of 9 in the series Building Machines in Code

Today’s Project NOTICE: Today’s Code will only work under Python 3.10 and later. In this episode, we will build a new system using a processor with Von Neumann Architecture. We will also be splitting our system into various files and classes to organize our system better. The Memory will no longer be part of the

Building Machines In Code – Part 6

This entry is part 6 of 9 in the series Building Machines in Code

Last issue we built a simple assembler for our TIny-P processor emulator. In this installment, we will build a loader. But what is a loader? Loaders are small programs that load other programs into system memory and prepare them for execution. Most loaders are part of an Operating System however, in the embedded world, there

Building Machines In Code – Part 5

This entry is part 5 of 9 in the series Building Machines in Code

Tooling Hardware and software developers are tool makers by trade. Just like a machinist, software developers often need to develop their own tools for the job at hand. Sometimes these tools are simple scripts to automate a boring, or complicated task, or perhaps, a tool to fill a yet unfilled niche. Whatever the reason, tool

Building Machines In Code – Part 4

This entry is part 4 of 9 in the series Building Machines in Code

Programming the Tiny-P Programmers are often confused by the terms machine language and assembly language. Many developers consider these two terms interchangeable. But in fact, they mean very different things. If you go back to the Tiny-P Opcode table presented in part-3 of this series, you can see how the various machine code values are

Building Machines In Code – Part 3

This entry is part 3 of 9 in the series Building Machines in Code

Creating the Tiny-P CPU In this post, we will finally write some code. I promise! We’ll be using Python here as one of the most popular languages these days according to the Tiobe index, narrowly beating out C. So, in the interest of reaching as many people as possible I settled on Python for this

Building Machines In Code

This entry is part 1 of 9 in the series Building Machines in Code

Regarding the difference between simulation and emulation:
Not limited to computers I use this distinction:
– A simulation mimics the outward appearance
– An emulation mimics the cause/process.

If you want to convince people that watching television gives you
stomach-aches, you can simulate this by holding your chest/abdomen and
moan.

Implementing Stack Oriented Languages – Part 4

This entry is part 4 of 4 in the series Implementing Stack Oriented Languages

Strings and Variable So far we’ve added lots of stack operations and a couple I/O routines with the KEY and EMIT keywords. At the moment if we wanted to write a simple “Hello World” application we would need to place each character on the stack and pop them off using the EMIT keyword. This is

An Introduction to Graph Algorithms

An Introduction to Graph Algorithms
This entry is part 1 of 1 in the series An Introduction to Graph Algorithms

This post marks the first in a series of posts I will complete on graph algorithms. The code will be python however, I will write the code very verbosely so it will be easily ported to your favorite programming language. I will assume you have some programming skills but are still a novice or that

Implementing Stack Oriented Languages – Part 3

Implementing Stack Oriented Languages – Part 3
This entry is part 3 of 4 in the series Implementing Stack Oriented Languages

Before we move on to adding more features to our language, I think it is high time we combine our disparate parts into a single entity.