Hi there, this is Sergei from Smartikid, and today we're going to talk about Apple One operating system that was made by VOS. We're going to check what general operating system do, and what was specific about this VOS operating system,

and we're going to check what options it has, how it works, and we'll run Python code that emulates the key functions of the system.

And anyway, now we have operating systems with tens of millions lines of code, and this one is just like a few hundred, and in compiled versions just 256 bytes. So, this is a real engineering piece of art, made in 1976, and I hope you're

going to like it when you're going to know it much better. So, let's go ahead. Let's talk about this, because this is a hardware platform that was used to run the VOS operating system. It was a very simple personal computer that was actually built in a garage by

Steve Wozniak, Steve Jobs, and their team like Dan Kotke, Bill Fernandez, and some other guys. So, basically it was some display, some monitor, connected to a big PCB, big board,

with many, many, many chips, and with a 6502 CPU that ran only on 1 MHz. It is very funny right now. At that time it was very fast, and it has no any kind of a graphic mode. It can only print some charts. It was text mode only.

On the next slide, you can check the board that was made by Robert Dowell from the National Museum of Computer History from Lechley.

You see that it's a big bunch of chips, and also you see very big capacitors that were used for power. Let's go to Apple 1 architecture. Here you see it's very straightforward. It was CPU that did all the work.

It was connected to memory to get instructions and data to process, and it has a connection to an input-output system that was basically based on one big chip. Then it was connected to keyboard and display, and they worked in a very simple manner.

The keyboard just sent some char to the data bus, and the display just printed char that was sent via the data bus, and that's it. So it's a very, very simple computer. Anyway, the modern ones are very similar to that, but for sure display and keyboards are much more complicated.

But anyway, the whole idea of computers are pretty much the same. Here you see a smart ticket version of Apple 1, so everything is just on one

board, and you can see all the stickers with chips used, and it can run on batteries. Apple 1 was the first personal computer made by Vos and Jobs, and let's go ahead.

And a quick recap of what is operating system. Well, for sure it's a program, it's a piece of software that runs just after the computer was rebooted, and it has special mode, kind of a kernel mode, that is kind of a privileged mode, and nobody could change this.

But the functions are working with hardware, so it's everything related to drivers, to communicate with different parts of computer, like video, keyboard, different sorts of mouses, so input and

output, and also providing interface for the other applications, to simplify their work with hardware layer. So it gives functions, gives some piece of code that could be used by the higher level applications, user applications, and make

it much easier for them to work without need to check what kind of hardware do they relate on, do they run on.

So it is really good abstract layer for programmers who do write user programs. And the second part is managing resources, hardware resources that computer has. So in general, this

function includes allocating of memory, helping with running programs, checking what kind of threads are working, and all of this, not really depending on what kind of hardware is inside,

so it's a very general function that could use different sorts of hardware inside. So let's check the schematics, what we have about this.

I'll show you the main commands for the operating system. So we start emulator, Apple 1 emulator with the smartdkit rom loaded. You can check instructions on our YouTube, how to do this, and on our GitHub.

Okay, so we can examine memory cell. FF00 is the first cell where the operating system is located. The second we can do it with dot, meaning we're going to enter the next address to see the range of cells.

Here we are, also we can store something in memory. To do this, we can do this in rom that is located at 8000 by the FFFF, but we can do it on the first half of the memory from 0000 up to 7FFF.

Okay, let's take something like this, check what is there. Then we can enter colon to enter some value, and then we're going to see, examine it again, and we see it's 88.

Okay, if we want to run something, in this case we have was phase program written in memory at the address F000. So we add R to run it, and then press enter, and it starts.

Here you see how it works, it's just skr, symbol by symbol, it prints like a real terminal. Here we are. This is a review of 65 auto assembler code that is used, that was written by Steve Fosnik, and that is time-compiled to 256 bytes.

So first part is the creation of the process of variables, and this one, this part is very very specific.

It supports input-output ports that are used by special chips, so they are hardwired. Here you connect to real hardware. If you change it here in software, you can't really do it without changing it in real schematics and electrical connections on the motherboard of the computer.

We started at F000, so we start also with a hardware-specific reset. Here you see the prompt. We use, it shows when you need to input something.

Just like you see the big loop with key ready, it's checking it, and it's infinite loop between these two operators. So until you've got the new chart, you can't really move to the next. Then here you see kind of a switch case statement, parallel programming languages, you check what kind of chart it is.

It's a carriage return, or it's a dot, or it's a column, or it's an R.

Depending on this, it runs different subroutines. And the main one is the run one. This is the subroutine to run some program, so let's check this.

So run is here, and it is very straightforward. It just gets the press saved at XAML. So read like it stores high byte and low byte, and gets the four charts and two bytes address.

It just jumps there, and that's it. And also what is very interesting is this hardware-specific function. That is used, that could be used by user programs. It is echo, so it's basically print, printing a chart.

It checks bit on the chip. When it's ready, it could print, but if not, it also enters some infinite loop until it will be ready to print it.

Then it stores a register, contents of a register in this display port, and returns from the subroutine. And what is inside here, it's all special functions that help to parse text, digits, and all this stuff.

In order to convert from Charles and Eski codes, we got entered to a real numbers that could be processed by CPU.

Because as you know, Eski symbols, for example, they start from 3, 0 in hex. Like 0 would be 3, 0, 1 would be 3, 1, but you can't really add them. Using instructions of a CPU, you need to convert them to just 1 or 0, subtracting these 3, 0.

And so yeah, it's basically, that's it, so we declare something. Here, the variables, addresses of variables we were going to use, we reset, we got user input, we process this input, and finally we run some program.

So that's it. Okay, but what about, what is not included in VozOS? What is not inside, what we have right now in modern operating systems? Well, there is no any kind of file system we get used to.

So it works just with memory, computer has. So it's read-only memory that is written on the chip, and RAM, Random Access Memory, that could be rewritten and read by processors.

So it works with this, it's in Apple 1, it does 64 kilobytes, and that's it. To a kind of a version of a file system, it was a magnetic tape, so it was special card, where you can connect using special program written on this card, and you can call it from user interface from Shell.

And its main function was emulating kind of system that can send some byte to, some sequence of bytes to this magnetic tape,

and read the same sequence to some specific memory area, memory block. So in this case, file is a kind of a some place on the magnetic tape that could be read and transferred to memory,

and then run using shell command run, and it is already in memory. Anyway, you can't really list files you have, you can't really see what is inside, preview them before loading,

so you only can load, save something to this tape as a sequence, some memory block, and read this memory block from the tape without any names. So names, people generally, they're written by themselves, something like saying like from the first minute on this tape,

it is this file, from the second it is the second, and so on. So yeah, this is the first thing that is not inside, this was awesome. Second thing is networking, we're lacking, so users were just like one on one with their computer.

This could be emulated for sure right now, and we're doing this because you can use some sort of serial interface that could send char and get char, and then on the next level you can have anything, you can have Bluetooth, you can have Wi-Fi, you can have wire connection, anything,

and this could help to connect some computers. By that time it wasn't just working like this, so with your computer you can just load something with this magnetic tape and that's it,

and you can enter by yourself, like typing, some code, like it was in the original training manual, you just can type, retype the test program, just from the listing, and for the big program you could spend a lot of time doing this.

Yeah, but regarding the main functions of the operating system, if for sure it has interface to hardware, to video and keyboard, it can run programs, and it has a user interface, so it shows you what it can, it can get commands from you,

and it executes these commands, so we'll talk about this also. In most of the system there are three main modes, the first one is XAM mode, XAM,

and in this mode you can read any memory cell and see in hex right on the screen, so that's why it's XAMINING, you can check any address, your input address, and see what is located at this address. Second mode is XAMINING BLOCK mode, it's the same, but you can see not just one cell,

but some range of cells, you input the first address, the beginning address, and the ending address, and put a dot in between them, and in this case a shell knows that you want to see the whole range of memory

between these two addresses, so it's really convenient to check the source, the compiled version of ROSLOSS itself, so you can type the first address,

that is FF00, and the last one, FFFF, and you can see all these 256 bytes on your screen, row by row.

And third mode, it has this so-called store mode, the mode when you write some data to memory cells, it also could be just one cell at some address, and if you add extra data, extra hex numbers you want to write,

so it just automatically increments the address, place this new data, and so you can start from one address, and it just adds new bytes to the write,

and it will just write these bytes in the memory block. So you can really write to memory, that is useful when you want to need to enter some programs, because basically you don't have any need to enter some program,

you can just type it byte by byte, as in the manual written by ROSLOSS, and if you have this test program, you need to type it in, and then you can check what is, to type it in in this store mode,

block store mode, and then you examine this block, in this examine block mode, you see that yeah, everything is written right, everything is in memory, and then you just run, but it's the next story about finding programs. Okay, now it's about running programs,

the key function of every operating system, because otherwise why do we need this special piece of software, because people like computers to run programs, different sources and that. Okay, what is program? Program is a set of instructions for CPU that needs to be executed,

and some data also, and for sure it needs to be stored in memory, and we've done it on the previous, previously we've done it by typing this using keyboard, and then we have it in our memory, we've checked it with the examine mode,

we see that all bytes are on their places, and then we start to run. What is exactly done when you run? You need just, and what do you need, what argument, what parameter you need to run a program, well basically it is just an address of memory where the first instruction of this program is located.

And so yeah, you type this, for instance if you want to run this vos.face program from our ROM, from SmartKit ROM, you can just type F000, add R, a letter, which means run,

and hit enter, and that's it, you just gave this command to vos.os, and in this case, what it does, it just jumps to the address you've typed in, so it converts this address to, it saves it to memory, and then it just jumps there for the first instruction,

and this address, and that's it. In operating system of vos, you can't really quit this program if it doesn't have any option. It can, if it would ask you something, you would input something like,

I want to quit, or it asks you yes or no, and in this case it could jump itself to the first line of code of vos, so at F000, but by default, if program do just summon,

like this test program just prints all the ASCII letters, ASCII symbols, it doesn't have any exit, so the only way to stop it is just to press reset,

and you just send this signal to CPU, and it starts again from the, it reads this reset address, and then it goes there. It starts this vos operating system once again from the very beginning.

So running, it's kind of a vos OS, it's kind of a hard running, you can't really quit. But anyway, it restarts very fast, it's not like Windows right now, when you wait for a few minutes, when it loads and then downloads some updates,

it just takes you less than a second, so that's why I think it was not a problem, the time to reset if you want to stop some program. And what functions are really hardware specific for vos OS? Well, basically there are like three of them.

The first one is initiation, so in the very beginning it needs to work with this input-output chip, and it needs to set it up, and then you have two main things left. It is working with the display, that is, in this case it's just terminal,

so it just gets char by char, and then just like scrolls down by itself, and here, yeah, you need a function that really sends something that is really chip specific,

and in vos OS there's a function called echo that prints a char stored in a register of CPU. And this is hardware specific, but then, as a programmer, you just can load something to a register,

and just call echo and you've got it on display, you don't really care how it's done. The second hardware specific function is the one that is working with the keyboard. The same is here, first you set it up on the first step, on the setup, initial setup, hardware setup,

and here, what this code does on this getline function is you wait for a specific flag to be set up when char key, char that corresponds to a pressed key, would be ready to be read by CPU.

So CPU waits when it can read something, and this is very hardware specific, if keyboard would be some kind of different, like, for example, if it would be a USB keyboard,

not PS2 or something, then for sure this simple driver would be much more complex

and you would need much more code to work with this protocol, with this USB protocol, in order to just get this code and get it ready to be read by CPU. So this getchar function is really hardware specific, but anyway, then, if you write some code,

write some program for Woz OS, you just can call this and you don't really know how it's done, but then you got this char in the register and you can use it in your own code, you don't really care about chips and protocols of the keyboard,

and that is the main feature of operating systems, so they create their own layer for helping you not to care about what is on this silicon, so you just work with this software layer.

So for Woz, like, summary for the Woz OS, there are three main things, like you initiate everything, set up everything in the beginning after the reboot, and then you have hardware specific echo function and hardware specific getcharfromkeyboard function,

and then they're used in user programs written by programmers. Now we're going to check this Python code I have written to simplify the explanations, because 65.0 to Assembler is kind of not so easy to understand,

because it's a lot of instructions, but it's not so easy to see the whole picture. So I simplified everything, it's just very simple, but I wanted to create two classes in order to show that there is one distinct part that is related to UI user interface,

and the second is hardware specific, so I've created two of them. And then basically the flow is very simple. In the beginning you just have some hardware initiation, so you set up this hardware specific stuff,

and then you enter infinite loop. In Python code, sometimes I use this limitation of loops, because I just don't want to press Ctrl-C too often, I just want to stop it by itself.

But anyway, just in real life, it enters infinite loop when the first part is to get some user input, so it gets a line from you, then it parses this line, and depending on what it's found,

it runs some command, either checking some memory cells, either writing to them, either running some program address it found in this line. And if it runs something, as I've said already, just like it never goes back in the program,

there is not any jump back to the starting point of the operating system. But if it runs some examine or store program, subroutine, I mean, it just gets back and starts over again the new iteration, waiting for you to input something else to parse.

And so, I would say the final destination for this operating system is to finally run some program and stop,

and then give control to this program and forget about everything. Who wouldn't ask this operating system again? Wouldn't jump back. So yeah, you can check this code, you can download it, you can run it, and you can play with this.

And for sure you can see this assembly source, but it's much more complicated to understand what's going on. So please check this Python code and run it on your own. Here's our Python code, high level view on what's going on with the operating system.

So basically I have created this class hardware interface that is related to everything, this needs to be done with the hardware, it's not so much. So first of all we need something, we execute commands, like writing something to memory,

and we have to function separately and get line, get user input char and to print something. And it goes user interface, so it has like three modes, it saves user input, it saves like address to examine and store address.

And basically it starts with the examine mode, and it reads user input, here it's like some dummy here, some plug, and the main function is used is parse input. So it checks what was in, what the user had, if it sees a dot,

so it's entering some block mode, is a mining block, if it sees a column, it just needs to store something, and if it sees R, so it needs to run something.

Then after the declaration we have two instances, hardware and UI, just very simple ones, and then like here's what is already executed, so we set up, it's very simple, it is just our unit,

very specific stuff, and then we enter the infinite loop, but in this case I just wanted to start it just for five times, but anyway it could change for a while, for any loop. We read user input, action, hardware, that's it.

How was the brain system communicates with the user? So for sure user is like the king, he is the one who is like, the reason why everything was done, so he needs to communicate somehow with the system, give some commands and get some results, and so Woz.OS has very simple user interface that now we know

kind of a shell in the Linux or Mac OS or in Windows, but this shell has not so many commands as we used to, there is no any LS or any kind of RM or something like this,

everything you can do is just all these three main things, like XMI, XMI memory cell, XMI memory block and store, memory cell or memory blocks, and that's basically it.

The other thing, you can just run some program, and it covers everything you can do with this operating system. So yeah, it's just a shell, so you type something as a string, then it parses this string and it just prints out something back.

So inside there is a very simple algorithm that takes this string from you, it has some text buffer where it stores all these chars that were inputted, and then this algorithm just checks char by char,

what is inside, if it's some hex or number it's okay, if it is some divider it just skips it, if it is point it knows that it needs to change mode to block one, because it means that in the first it was some address,

then you put point and then you have the second address, and you need to examine if it finds a column, then it means that it needs to enter a store mode to save something in memory,

and if it finds our letter it means that it should run something. And yeah, it has some sort of a switch case structure,

but written in assembler, so it checks it step by step, so it branches out depending on what it has found, and then it just does this simple work, saves any variables these addresses,

parses these chars to get hex numbers, four digit hex numbers for addressing two, and two chars for bytes as data, and yeah, that's pretty much it,

and it is very very simple shell, that you can type and you get the result, with just very very reduced set of commands, and there is no any kind of a help command,

where you can see all the commands you can use, you just need to go to this operating manual, you can check it out, and now it is core 2, to see all these commands it has with the demos, yeah, so basically it is very very simple shell,

not any GUI or something like this, just the shell, but remember it was 1976, it was just the very very beginning of personal computer. Well, it's all for now, a quick summary of what we are discussing here,

well, a operating system is a kind of a program, that does too many things, it needs to provide some interface for the user programs, and to communicate with hardware, and the second is to manage these hardware resources,

laying many programs to run simultaneously, and do all this stuff with memory and so on, also operating system is a very simple one, it doesn't have many features, so the modern one is like file system, like networking,

yet it shows main features, that are very common to all operating systems, that we really know, well it has hardware specific functions, to communicate with the display and keyboard, that gives interface to user programs,

and it has some user interface, simple shell with commands to examine memory and to write to it, the main option to enter some programs,

to run them on this computer, this Apple one, and it's very simple, it's just the main loop is very straightforward, it gets one line of user input,

and process it, and then checks like and switch case operator, just putting this to be done, and you can find all these materials, not only as links to this video,

but also in our Discord, you can, would love to answer your questions, and for sure was a great engineer, and he started this era of personal computing, mass personal computing, with this very simple and nice operating system,

of just 256 bytes, just incredible, was really great, so hope you just know much more about this, about the first computers, and the first personal computers, and we can use something from this at work too,

because now you know more about algorithms, that were used that time, bye guys.

So hello, hello, welcome to the question and answer, on the, made by was how Apple one operating system works,

unfortunately, we just have lost Sergei, he was here a minute ago, and he is back again, at least I hear him, hi Sergei. Hi, hi, do you hear me? I hear, but we don't see your video picture now,

ah, there it is, very good, so thanks for the great talk, you already answered some of the questions in the chat, I have collected some additional questions, do you hear me? Let me check, thank you.

So Sergei, do you hear me? Yeah. Okay, very good. So one of the questions I have is, what can, was or as, can teach people today?

What do you think is the benefit of looking into this? Yeah, yeah, yeah, I see you.

First of all, was operating system can teach you, kind of the two main parts of every program system, that there is something that is kind of a user interface,

and something that is related to hardware, and for every programmer, because this is really crucial to understand,

because we all write programs right now, and we basically work with this application layer, we just use some functions, that were already done by the other programmers,

and work with the system program.

Okay, I have another question here. Sure. Do you think it's a useful exercise to port Was OS for modern architectures, like ARM or RISC-V, or even the Arduino?

Yeah, I think it's a good exercise. I will also repeat one of the questions, that we have seen in the chat, for people who haven't seen the chat, and looking for the recording.

The code you showed, the assembly code, was that the original code, that Steve Wozniak wrote back in the 70s? Yeah, it was.