Personal computers, Macs, and mainframes each represent a distinct era and architecture in computing history, with key differences rooted in how processing power is owned and accessed. Understanding these distinctions also explains why terminal emulation programs remain relevant tools in modern IT work.
PCs vs Macs vs Mainframes
One thing that I want to make sure we understand is what the differences are between PCs and Macs, but to understand really what the differences are, we also have to look at mainframes.
Mainframes are big computer systems that we've used to process information. Now we don't use mainframes as much anymore, we use things like servers instead, but there are still some mainframes out there, and in the past that used to be the way we did computing.
When you look at the history of computers, mainframes existed around this time where we had transistors and we worked into integrated circuits, and we started creating then these mainframes that would do all the processing for our company. There were these big computer systems, and usually they had quite a few people that were managing these systems.
Here I'm at the Wikipedia site looking at mainframe computers, and we can see here there's some pictures of some newer mainframes, so there's some examples of some more recent ones that are sold, and then it's got an example of an older one here. Some of these would fill up rooms, and like I say, you'd have teams of people that would be managing these.
Now, to interact with these mainframes, sometimes we started out with like punch cards, and there's various ways that we started out putting our inputs into the system and getting outputs from the system. But at some point in time we started developing terminal machines. So if I scroll up here, it talks about the terminal, and I'm going to actually open this up in another Wikipedia document, and this is computer terminals.
Now the way that you use a computer terminal to interact with the mainframe is really quite interesting. There isn't a central processing unit in this, this doesn't do computing. What it does is, when you press an A on the keyboard here, it will then send that A to the mainframe. The mainframe will then process it, figure out what it needs to do, and then send a response back to your screen. So for instance, if you were typing up a letter, you would hit A, that would be sent to the mainframe, processed, and then sent back to be displayed on your screen. So that is an example of how these computer terminals work. They weren't computers in themselves, they were just how you would access the mainframe, which is what the computer was.
So let's say I'm typing up a letter here on this terminal. I hit the A on the keyboard, and it will then send that A to this, which is representing a mainframe right now, where it gets processed there in its central processing unit, and then it sends back what it's supposed to happen. In this case, since we're processing a document, then it will put an A up there.
Now when the microprocessor came out, this was a game changer. It started changing the way we could compute. With the invention of the microprocessor, as well as several other innovations, we no longer needed to have this terminal and mainframe setup back and forth. Instead we could start taking those microprocessors and putting them on a desktop that have their own screen, own keyboard and own desktop here, and now it's its own device. It's a personal device, it is for a single person to operate, so therefore it becomes a personal computer. And that's where this PC came into play: it's a personal computer, because a person could sit at this and that processor was personal to them, that they got to utilize the full potential of that processor and didn't have to share it in the sense of like a mainframe you would have to.
Then Macintosh was introduced to the market, so then we have a Mac. This Mac here had its own processor built into the desktop as well, and it looked a little different than what this is showing right here, but essentially it was still the same idea, that it had a computer that was personal to that person.
However, we didn't call these PCs, and the reason why we didn't call these PCs is because in this case over here we had our mainframe systems set up here, and then we had versus these PC systems, so we had to differentiate between the two. Macs never had this mainframe setup, it never was set up that way, and so you never needed to differentiate the two terms at all. So we now say, well, it's a Mac versus a PC, they are two different things, versus the mainframe is a whole other thing here.
Now you may occasionally see somebody refer to a PC and mean both a Mac and just any type of computing device, but that's not historically the way it's been.
This is a good time to talk about a terminal emulation program. What you had right here is, because you needed a terminal to connect into a mainframe and make that communication, this was a serial connection, so a lot of times we'd use an RS-232 connection right here. We used this RS-232 connection even when the PC came out. We still did have a need: although it was great that we could do computing at the desktop, there was still a need to be able to process things on the mainframe and go through the mainframe. So what we did is we had a serial connection on this PC itself, there's a serial connection on the back, and then we would open up a program that would act like this device right here, this terminal right here. So now it's emulating a terminal, so it's a program that emulates a terminal program, and then what we can do is open that up and do this interaction with the mainframe.
We still use terminal emulation programs today, even though we don't use it necessarily with mainframes. A lot of times when we connect into certain pieces of equipment, we're connecting via a serial connection to it. A lot of times it's RS-232, and so we're making that connection and we're using that terminal emulation program like PuTTY or Tera Term or SecureCRT, and we're bringing those up to interact with those pieces of equipment. An example would be a Cisco switch: we're using the terminal emulation program to connect to those Cisco switches in order to program those Cisco switches.
Here I am on my demo laptop, and I have this program called PuTTY that's installed here, so I'm going to bring this up. This is PuTTY right here, and PuTTY is a terminal emulation program, and I can connect to different pieces of equipment here.
So what I'm going to do is actually load up some settings here. I've got a Serial 4 and I'm going to load that up. We don't need to be too concerned with what this is, it's just selecting the serial, which is an RS-232. I can come down here and select this to control some of the connections of this, but I'm just going to click open because I've already got it preconfigured.
If I hit enter, then what will happen is I'm talking to another machine. This right here is one of the Cisco devices, it's either a switch or a router, and so this is connected into that device and I'm able to now interact with that device through this RS-232. What's happening is, every time I press a key on this keyboard, it's sending through that serial connection a message to this router, if it's a router, and then that router figures out how to respond and then sends a message back.
TechKnowSurge builds IT and cybersecurity professionals through hands-on, concept-first training built around real understanding — not memorization. Free interactive tools, structured programs, and 25+ years of real-world experience, all in one place.
Explore free tools and programs →