The History of Programming Languages Part One

going to be laying the groundwork for programming languages. Long time listeners know this is kind of my m O. I like to really make sure that we have a foundation before I go into a topic because I feel like context is really important. And despite our love of stories that have a beginning, middle, and end, typically history is not so neat and tidy. We tend to have lots of stuff bleed into other things and so it

gets a little complicated. So before we talk about the history of programming languages itself, let's talk about why we need programming languages in the first place. Well, when you get down to it, computers process machine language, or a type of machine language. Machine language in itself is a descriptor it is the language that machines quote unquote understand and what they are using in order to execute various operations. Uh, the machine language of today is the binary code zeros

and ones. All those instructions that a computer carries out essentially boiled down to chains of zeros and ones. So in order to really understand programming languages, at least most of modern programming languages, we need to understand about binary and as it turns out, the concept of using binary arithmetic dates back quite a ways, well before the dawn of the computer. The earliest scholarly work I could find regarding binary arithmetic dates to seventeen o three, eighteenth century.

It was written by Gottfried Wilhelm Leibniz. The Leibniz was a German mathematician and philosopher and one of the two people to invent differential and integral calculus. Anyone know who the other person was? Bueller, Bueller, I'm sure a lot of you are shouting it out right now. It's actually sir Isaac Newton. Newton and Leibniz were two co inventors

of calculus. They did it independently of one another. In other words, neither of them were aware of the other person's work, which is kind of cool when you think about it. It's this this uh, an interesting moment in history where you have two different brilliant people coming up with the same idea simultaneously. And this is not the

only time this has happened. There have been quite a few times in human history where people in different parts of the world have come to the same sort of amazing realization at around the same time without ever being aware of the other person. As it turns out, they both tried to lay claim to being the father of calculus. Uh. Really, their followers were more rabid about it than they were.

And there's in fact, an entire fascinating story about the battle for who should be given credit for inventing calculus. But that's a story for another podcast. It's really not a tech stuff story. You might be a stuff you missed in history class story if you really want to make some history folks go crazy about talking about, you know, lots of maths. But let's go back to binary arithmetic. The Leibnitz wrote about binary arithmetic in his memoir De la Caademir Royal de san sees ha ha ha, And

I know my French is terrible. You shouldn't pop off from Sabien and Maroisment. His work, though, was the first to explain that arithmetic typically relies upon base ten. Makes sense. You know your your typical person has five fingers on each hand, five toes on each foot. Base ten makes sense.

You count one to ten with your fingers. So he would say that base ten really ranges from the number zero up to the number nine, and then you repeat that sequence again, only you put a one in the second column, you know, the really the tens column, and then you start back at zero and work your way back up to nine, and then you would put it to there, and so on and so forth. So you worked up to the one hundreds column and the one

thousand's column. But he says he found that the simplest progression of all to be more useful in the science of numbers. That simplest of progressions is between just two numbers zero and one before it repeats itself. So the number zero is zero, the number one is one. If you wanted to represent the number two, you would write one zero. So again it's kind of like going zero

to nine, and then you would go to ten. In this case, you go to zero the one, then you would go to what is effectively ten that represents the number two. Three would be one, one or eleven if we were using the decimal system, and a four is one zero, zero or one, and so on and so forth. Now by the time you get the thirty, you're looking at one one, one, one zero, and a thirty two is one followed by five zero, so it would be one hundred thousand in the base ten system. Leibnitz said

that this scheme allowed for geometric progression. So if you were to take the binary digits for four, which is one zero, zero, and then you took the binary digits for two, which is one zero, and then as in the number one followed by the number zero, and then you took the binary digit that represents the number one, which in this case is one, and you were to add all of those together, you'd end up with one on one that is the binary digit for seven, which

is also what you get when you add four and two and one together in base ten. Leimnez says this approach allows for lots of practical applications, such as weighing a lot of different masses with just a few different types of weights or in coinage to allow for many different values with just a few coins, So he was thinking of practical applications for binary arithmetic. He also said that expressing numbers this way allowed for easy mathematical operations

such as subtraction, multiplication, and division. Leibnitz also said that using binary just made sense. You didn't have to memorize facts by rote as. Everything was evident through what he called ordinary reckoning. So in other words, you wouldn't have to memorize things like seven plus eight is fifteen, right, You wouldn't have to memorize these sort of ideas, or that four times six, you know, what is that? What is four times six? I'm asking you know it's twenty four.

So you wouldn't have to memorize these and and have it all by rote But that with the binary approach, because you're only working with ones and zeros, there's none of that memorization. It's all very intuitive. Now. Granted you then have to work out what those ones and zeros are representing in the base ten system. That's a little

more complicated, but it works. Leibnitz Is work predates computers by centuries, and there's some evidence to suggest that binary counting systems were actually being used by other culture ors well before Leibniz came along. They weren't written in scholarly journals, but they existed. Some researchers from the University of Norway noted that on the island of Manga Manga Riva, and I could be completely butchering the pronunciation of that, so

I apologize. It's a island over in the South Pacific Islanders had been using a binary system to count between the numbers twenty through eighty. So they used base ten for all numbers leading up to twenty, and then between

twenty and eighty they used binary digits. And they were doing this before the fifteenth century, so before the fourteen hundreds, the islanders didn't have a written language, which meant that whenever they had to do math, which they started having to do they began to trade with other islanders and other cultures well before the fourteen hundreds. It meant that they needed to be able to do math in their heads easily, and binary allowed for that as opposed to

something that's in the decimal ten system. But who considered using binary as the basis for machine language? Where did that come from, well, that would be much much later, And in fact, there's some other elements of programming that pre date the decision to go with binary as the basic language for computers. So let's look at some of those developments because that's kind of again what led to

the rise in programming itself. So to find the thread of this story, we have to go back to eighteen o one, so a century after Leibniz was writing about binary arithmetic, and that's when Joseph Mrie Jacquard introduced the programmable loom. We've talked about this in previous episodes of Tech Stuff. The programmable loom was a real innovation back

in the nineteenth century. The programs consisted of wooden punch cards, So you had these large pieces of wood with holes punched in through in a certain pattern, and what you would do is pass threads through the holes in the cards when you were threading up your loom, and those holes would essentially dictate what the pattern was going to

be when you finished. So if you wanted a specific pattern, you just put the appropriate punch card, load that up for your loom, pass the thread through, and then weave on the loom. So that you would get the pattern you wanted. You needed to change it up. You just switched out the cards that you were using. Uh, so different patterns would use different configurations of holes. You know, obviously, if the hole is there, then a thread can pass through.

If there's no hole in that position, then a thread cannot pass through. It's pretty pretty intuitive now if you think about this in an abstract way. The punch cards are like a series of two positions switches. The holes are the on switch because they allow a thread to pass through, and the areas where a hole could be but there isn't a hole is an off switch because you cannot pass a thread through a solid piece of wood. So Jacquard's loom sped things up and really got things

moving in the weaving business. It also ended up putting a lot of weavers out of work in the process, and they got very upset. But it would take a couple of decades before someone made the mental leap that a punch card could be something that you could use with abstract ideas, not just physical material like thread. That someone was Charles Babbage who first proposed a mechanical device

called the difference engine. That was a device that was meant to compute tables of numbers, and it was a really complicated device with lots of gears and shafts that could rotate in different directions, and it would have used a lot of moving parts. But Babbage was never able to actually finish it. It took longer than what he had predicted, and ultimately the funding dried up as various patrons got fed up with waiting around for Babbage to

finish the thing, and they ended up stopped. They stopped paying him. But he began to work on a new device that he called the analytic engine. And here's where Jacquard's work came in. Babbage realized that those punch cards that were physically either allowing or preventing thread to pass through could act not just as gateways for physical material like thread, but also for abstract notions like a problem statement or information needed to work out a problem solution.

So by changing up what could and couldn't pass through, you could run a problem through a mechanical calculator. Essentially. Now with Babbage's design, we're not talking about electricity. Is still gears, mechanical parts that have to connect with one another, and all of it is based on physical motion. So if you've ever worked with a loud computer that had a bad fan or something, you have a hint of what it must have sounded like to work on this thing.

Only the analytic engine involved more clanking, or at least I hope it involved more clanking than your computer did. If your computer is clanking, you probably should take that in to get a bit of an adjustment, or if you're really handy, take a look in there, your fan is probably out of alignment. While Babbage was working on that first analytic engine, he was also helped by the

world's first computer programmer. Her name was Aida Lovelace, the Enchantress of Numbers, and I've done a full episode about Lovelace before. I Think the Stuff you Missed in History Class podcast has done an episode on Lovelace before. She was remarkable, an incredible person, uh, someone who I think needs more reck ignition for her contributions to computer science.

She envisioned a world in which not only could one create a punch card program for a calculator to run through and give you the solution to a problem, she was able to make another mental leap on the same level that Charles Babbage had made. Babbage's leap was, hey, this card that could allow or prevent thread to pass through could also be used in a more abstract way.

Lovelace's leap was this device that is intended to solve mathematical equations and answer those sorts of problems, could also be used to do all sorts of other things, things that computers today can do. But no one at the time was even imagining. She was such a forward thinker that she was able to envision a world where you could encode all sorts of information and use a device like the Analytic Engine to process it information like music

or images. So the remarkable thing is, years before, decades before anything like that would be possible, Lovelace was imagining that actually coming to pass. And I really wonder what she would think of the world today from a technological standpoint. If she was able to look around and see the sort of things that computers could do, she might feel very much vindicated by this vision she had back in the nineteenth century, where electronics were not a thing yet.

No one had really harnessed electricity in a meaningful way at the time that they were working on the analytic engine. So it's a really phenomenal thinker. I cannot imagine being in a world where I'm able to project ahead that far and think of something so abstract and to be so right on the money. Really well. The next step along the path to programming happened in eighteen nineties, so we're getting to the end of the nineteenth century, and

that was a census year in the United States. So in the US we hold a census every decade, and the purpose of the census is to determine the representation of states in the House of Representatives, that is a group in Congress in the legislative branch that is dependent

upon state populations. So we have the Senate. Every state gets to senators, but then we have the House of Representatives, and the number that we have is dependent upon the population of the various states, which means we occasionally have to check and see what the populations are. If they changed dramatically, then the number of representatives will again change to reflect that. But the U s had hit a problem by the end of the nineteenth century. There were

just too many dang people to count. It was just taking really long to count them all by hand. So in seventeen nine century earlier. They was also the very first year that we held a census. It took nine months to count up all the different responses for the United States Census. By eight the census, the previous census, the one that just happened before. They were trying to figure out a new method. It took them seven and

a half years to tally all the results. Seven and a half years to count up the results of the previous census. That meant that you were two and a half years away from having to do it all over again. And so the Census Bureau held a contest, and they called for inventors to come up with some way of tallying the census responses much more quickly so that they're not wasting so much time and money just counting how

many people are in each state. Enter Herman Hollerith, who invented a solution in response to the US Census Bureau and offered he won the prize that the bureau was offering. Holly. Rith created what he called a card reader. So again we get to punch cards, very similar to what was

being used by Babbage and then previously by Jacquard. This red cards by sensing holes that were punched into the cards, and it also had a gear mechanism to help keep count of all the different things that needed to count all the demographic information, and had a panel of dials that would track the various counts so that you could just look at the different dials and you would get

a summary of all the different responses. Each card had positions on it that would indicate different data about the citizen it represented, and his invention meant the eighteen nineties census could be tabulated in three years, so less than half the time of the previous census, the one that had happened in eighteen eighty. It's still a good long while to have to count that up, but much much faster and more efficient it than the previous census was.

Hall Earth would go on to found a company called the Tabulating Machine Company. That company, by the way, is still around today, but its name has changed because the Tabulating Machine Company would evolve into International Business Machines, which today we know as IBM. So IBM had in its history, the original purpose of it was to uh tabulate punch cards, and those punch cards were originally used for the eight nineties census in the United States. Kind of cool little

bit of trivia. So if you're ever at pub trivia and they're asking where IBM came from, now you know. And you also know that the person who's running the trivia is a total geek who may also listen to the show, So hey, shout out to you, Mr or Mrs Trivia Master. Those punch cards would become an important part of programming later on now. Arguably the first person to build a general purpose computer was a man named Conrad Zeussa who designed and built the Z one computer

in the late nineteen thirties. His device combined electronic and mechanical parts, so it wasn't a purely electronic computer. It still had some moving parts to it, and he had decided to go with binary processing as the basis for his computer. It makes it simple because you only need to switch with two positions on or off for each of your little processors and or gates if you prefer, and he thought that made more sense than decimal processing. And he used discarded film as his medium to send

commands to the computer. He wasn't using card stock, he wasn't using paper tape, he didn't have access to it, but he did use discarded film from various film houses in Germany, and he would just punch holes in that to be the instructions for his machine. His Z three machine, which he built in nineteen forty one, might have been the first general purpose programmable digital computer, but it was

destroyed during a bombing raid in World War Two. Only his Z four device was able to make it through the war, and for years Zeus's work remained in obscurity. No one knew that he had made these things, and he had done it again independently of anyone else. So you would see the rise of computer science in other countries disconnected from his work, and in turn, his work was disconnected from their's. Again, another example of these two

different places with the same ideas coming into shape. He arrived at his designs independently of all the other pioneers and computer science. We'll talk a little bit about his programming language in our next episode, because while he was creating a programming language earlier than almost anyone else, it didn't become known to most computer scientists until the nineteen seventies. Well, I've got a lot more to talk about in the history of programming languages, but before I jump into the

next section. Let's take a quick break to thank our sponsor. All Right, during World War Two we get the term computers. But here's the interesting thing. Computers were not machines. For the most part. In World War two computers the word computers referred to people. It applied to human beings, and their job was to compute various equations, specifically relating to

artillery and gunnery when it first started. By World War two, our war machines had reached incredible amounts of power and you could fire upon positions that were well out of you. But it meant that you needed to understand exactly what a shell was owing to do when you fired it. In other words, based on the power of the gun, the weight of the shell, wind, other factors. If you fire at a certain elevation, if a certain angle from

the ground, where is that show going to go? It's really important if you want to hit, say, an enemy encampment versus just countryside or a town. Well, it meant that they needed people who were really good at maths. So the army started to hire math majors. But that meant that they were looking primarily at women, because the men were already drafted into the armed forces, and they were serving as soldiers and other frontline personnel. So women

were predominantly the computers of World War two. These were women who were studying mathematics, and we're breaking round in the areas of math. So they would work out all of these different equations to figure out how things like muscle velocity or wind effects or atmospheric drag and other factors affected shells, and they created what we're called firing tables for various types of weaponry. But there was more work than they had manpower or maybe I should say

woman power to do. So they needed some way to do this work more quickly and efficiently, especially where you're just taking small changes in a variable in order to create another table, because otherwise you just have to run all those different equations again. If you could do something where you could just make a small change and run that same problem and get the answer quickly, it would save a lot of time. So there was a need

for computational engines that could do this work faster. Now over at Harvard, engineers built a machine called the Mark one. This was the first programmable digital computer made in the United States, but one it was not a purely electronic machine. It had some mechanical parts to it, including a large central shaft that had to be turned by a an actual motor and about uh, you know, five horsepower, and

it also had clutches and relays. It weighed five tons and had five hundred miles of wiring inside of it. The computer itself was eight feet tall and fifty one ft long, and it read instructions on a reel of paper tape with holes punched into it. So this was like one really long punch card this roll of paper tape.

And it solved the problem that some other early computer programmers ran into, which is, if you have a stack of punch cards, and especially if you failed to number your stack of punch cards and you dropped that stack, then your program was completely out of order and it was useless. In fact, it might be easier for you to go back and e program using a fresh new stack and a hole puncher. Then it would be to

try and figure out what order the cards had been in. Uh. The moral of that story was always number your cards. Although very few people have to worry about working with punch cards these days, but if you do, always number your cards. That way, if you do drop them, then you just have to get them in the right sequence again. Uh, and it's not as big of a headache. One of the programmers of the Mark one was a woman named

Grace Hopper, who is also credited with creating the term debugging. Now, the word bug had been in use for a while to designate the idea of a design error or flaw that needs to be corrected, whether it's in calculating machine or something else. So bugs as a term for something that's not right have been around for a while, but Grace Hopper got the credit for debugging. She was involved in a literal d bugging in which programmers pulled a moth out of relay number seventy in the Mark two system.

We'll talk more about Grace Hopper in a little bit now. Around the same time as the Mark one was being put together over in the UK, scientists were building another machine called the Colossus. This machine was a more specific computational device. It wasn't a general purpose computer. It was made specifically to break the cryptographic codes sent by German officers during World War Two, including codes that were created

using the Enigma Machine, a fiendishly clever cryptographic device. Now I have done a full episode about the Enigma, so I'm not going to dwell on it very much here. It is a fascinating gadget, and again, Colossus was a specific purpose machine. It could not be reprogrammed to do really anything else. So while it was fascinating, it also had limitations by its very design. But we see here that each individual piece of information can come in various forms, right,

and so especially with punch cards, is essentially on or off. Now, the mechanical computer didn't take over the world, and digital computers wouldn't really emerge until the nineteen forties and fifties, and truly digital electronic computers wouldn't be there till the nineteen forties and fifties. But many of the earliest computers would use physical switches that you would set before you would run any sort of program. So you didn't have

like a processor. You had all these these banks and banks of switches, so you'd have to make sure that each switch is in the correct position and all the wires are plugged into the correct ports before you would run a problem through the calculation machine. Now, if the switches had two positions, that's essentially programming in binary zeros and ones or or off and on, so that only uh counts if the switches have just two positions. If you put multiple positions for the switches, then you're not

using binary, you're using a different system. Uh. But a lot of those early machines were using two position switches, so they were binary machines. And it makes sense in the digital world where on and off are the only discrete values, and so in the beginning, programmers built code in binary. For the most part, not every machine is like this, but a lot of them were. In this world, a single unit of information is the bit that is either a zero or a one. And I'm sure you've

heard that eight bits are a bite. Now, that was not arbitrarily chosen. There was a reason for eight bits to make a bite, and it wasn't the only strategy of making bites. There were other versions of the bite that were six bits long or twelve bits long. So how did eight bits becoming a bite become the standard? Well, honestly, that part of our story happens a little bit later. So in part two of Programming Languages, we are going to revisit bits and bytes to explain why eight bits

make a byte. But I'm going to talk a lot about binary in this particular episode, so that's why I had to bring it up here. The next computer I'm going to chat about, however, was not dependent upon binary. It was dependent upon the decimal system that that base ten system. And that computer was one that I mentioned recently on a different episode of of Tech Stuff. It was in the Weather Models episode. That would be the

Electronic Numerical Integrator and Computer or ANIAC. It's a very early computer, one that I talked about in that Weather Models episode just just previously, and it was the brainchild of John Mauchley, and several other people worked on it as well, obviously, but Marchley was the one who proposed an all electronic calculating machine back in nineteen forty two,

ended up taking a few years to build. The United States government, specifically the military, was very interested in this because they wanted to have a more uh efficient machine to do things like figure out those those firing tables. But the ENIAC was not completed until after the conclusion of World War Two in nineteen forty five. It was the first fully electronic computer with no mechanical parts. The electronic nature meant it could complete a calculation in a

fraction of the time it took the Mark one. So, for example, a calculation with the mark one might take six seconds for it to complete because it actually involves moving physical pieces around in order to get to that calculation. However, the ENIAC could do the same calculation in two point

eight thousands of a second. Then againting yet could only store twenty numbers at a time, so there were limitations, and for the first ten years of its existence, the ENIAC ran more calculations than the totality of all calculations performed by human beings before the ENIAC was built. So from the dawn of time up to nine humans did a certain number of calculations that were dwarfed by the

first ten years of Niac's operations. However, then it got struck by lightning, which reminds us we probably shouldn't get too cocky about this sort of thing. We might anger thor So. NIAC didn't have a CPU like a modern computer. To run a program through NIAC to have it solve a problem, you would have to set physical switches that had ten positions, and you'd had to plug wires into

specific ports Before running your calculation. So ANIAC was a big, big machine, so big it was a hundred fifty feet wide that's forty six meters wide, and it weighed thirty tons, and it kind of looked like one of those old timey phone operator banks where you'd pull a plug out

of one socket and place it into another. And some of you probably still have no clue what I'm talking about, but just imagine a big panel of sockets into which you can insert cable plugs, and on one problem, you would have a sample configuration of plugs in some of those sockets. But let's say you want to run another problem. That would mean having to unplug those first cables, plug

them into different sockets. Each problem would look totally different, so you would have to change those physical connections as well as the physical orientations of those ten position switches that were there. Any act also could not store problems. It didn't have a programmed storage capability. It was a collection of electronic adding machines and other arithmetic units which were originally controlled by a web of large electrical cables.

According to David Alan Greer in the Annals of the History of Computing, the original programmers of ENIAC were Jene Jennings Bartek, Francis Betty Snyder Holberton, Kathleen McNulty, Mauchley, Anton Nelly, Marlon West, Scoff Meltzer, Ruth Lichtmann, Title Bomb, and Francis Bilas Spence. In other words, the first programmers for ENIAC were six women, the first programmers of the first fully

electronic computer. And I think it's really important to drive that home because the very history of computer science is reliant upon the contributions of women, and frequently, far too frequently, in the world of computers, women are are disregarded or thought of as being incapable of uh any real meaningful contribution, when in fact, the very foundation of computation is on the backs of women. Um As as for these six,

for years the Army failed to acknowledge their contributions. For one thing, NIAC was classified and still is to this day, classified information, and so their contributions weren't acknowledged as a matter of national security for quite some time. But since then they have been acknowledged, and I'm glad their story is now available for people to hear. It's a pretty incredible one and maybe someday I'll do a more specific episode about ENIAC and the men and women who were

instrumental in getting it going. But clearly they're programming didn't involve much of a programming language, at least not in the way we think of programming languages today. They were all looking at the very complicated decimal systems. They were setting things up for running a single problem. If you wanted to change the problem, you had to change that

entire set up, that physical setup of the computer. Now, the ENIAC team invited another person, John von Neuman, over to take a look at it, and I talked about von Neuman in the Weather Models episode as well, and together the ani ACT team and von Neuman were able to kind of come up with the the premise for the successor to ani ACT. This would become the EDVAC,

which was the first stored program computer. EDVAC stands for Electronic discrete variable automatic computer, and the stored program aspect meant you didn't have to change the physical wiring of the device itself. The program would be stored inside the computer, not in the arrangement of all its components, and unlike NIA, ed VAC would be based on the binary system instead of the decimal system. The binary system simplified things because

you only needed a switch with two positions. And again, the decimal based machine meant that you needed switches with ten positions. Since you can represent numbers using binary, then you know, Leibnitz showed us that centuries earlier, it made sense to go with that system. Now, one person who realized this and who really nailed it was Claude Shannon, another mathematician and someone that I will probably do a

full episode on again in the future. I actually do have a Claude Shannon episode in the archives as well. Shannon wrote The Mathematical Theory of Communication in nine to set the foundation for the theoretical limits of communication between humans and machines. The identified the bit as the fundamental unit of information and thus the basic unit of computation. For this, Shannon is often cited as one of the

fathers of computer science. Since the computers could be reprogrammed without making physical changes to the machine, it meant that you had to do that reprogramming through code, and so we finally get into some of the programming languages. Now. One of the earliest was called shortcode, originally known as brief code, and proposed by Mauchley, you know, was the one of the guys behind Eniac. So how is shortcode a programming language different from machine code, the language computers

actually quote unquote understand. Well, we'll find out after we take a quick break to thank our sponsor. Alright, So how was shortcode different from machine code? Well, shortcode allowed programmers to work out problems using mathematical expressions instead of machine instructions, so you didn't have to just have everything out in zero and ones in binary. You could take a couple of shortcuts. It was developed for the UNIVAC computer, the first mass produced computer, and also the work of

Eckert and Mauchley of NIAC fame. This removed programmers from the same level of language as the one that the machines were using. So you have machine level language that refers to the specific language the machine itself quote unquote understands the language it uses to process the problems that you submit to it. So you can program machines at

the machine level. But it's hard to do. It tends to be tedious and difficult, and it's really easy to introduce an error into the programs because it's not very intuitive, particularly if you're talking about programming in binary. If you're just looking at a bunch of zeros and ones, very quickly, you can lose track of what it actually represents. And if you put in a zero or a one where it should have been the other, everything turns to popsy

turvy and you've got bugs in your program. You have to go back and figure out where the mistake is, and then you have to fix it, and that one fix may not be enough. You may have to end up going down the line and fixing everything that comes after it. Beyond machine level languages are things like short code. That's that next step up. It's a very very small step up. It's actually a low level programming language, which means the level of the language is not that far

off from the machine code itself. It's easier for humans to use than pure machine code, but it's not that far removed from actual machine code. Another low level programming language would be an assembly language, and there are many assembly languages. These use simple mnemonic instructions. Assemblers translate this into machine code, and because different machines rely on different architectures, there are many assembly language is. Essentially, each architecture needs

its own assembly language. The program that turns that is of course called the assembler. The assembly language into machine code is your assembler. So in the old days, we

didn't have a common architecture across computer systems. Computer systems were very specifically designed by different manufacturers and often for very specific purposes, so there was no compatibility across different machines, and your assemblers had to be peculiar to whatever the architecture was of that machine that you were working on. One ninety two, Grace Hopper, you remember her well. She built the first compiler, and it was called the a

dash O compiler. A compiler's job is to take code that's written in a programming language and convert it into machine codes. It's sort of like a translator. It takes the programming language something that humans can work with, and turns it into machine code, something that machines can work with. Hopper's compiler was pretty simple and was an effective way

for Hopper too, As she once said, be lazy. She wanted to stop being a programmer and returned to being a mathematician, so she wanted to find ways that she could generate sort of shortcuts to doing very basic tasks. And that's when she built this basic compiler. Copper took all these subroutines that she had been using over the years, and she put them on a reel of paper tape,

labeling each subroutine with a call number. Then when she needed to run a specific subroutine, she could refer to it by the appropriate call number, and the machine could find the corresponding section on the paper tape and run the subroutine. Now, according to Hopper, people didn't realize the significance of her contribution right away. Many people were still thinking of computers as glorified calculators, so these were machines

that could do math, but not much else. Hopper says, she you foresaw more complicated programs, but they would need things like compilers to offload some of that laborious work to make those programs practical. So Hopper was saying, what I'm doing here is opening up new opportunities for us to use computers. And she said she ran into a lot of resistance where people just didn't see it that way.

They had been used to programming these things by hand, working either at machine code level or just barely above machine code level, and so it was too complicated to consider using it for anything other than just crunching some numbers and running some equations. Well, she and her colleagues worked on improving this approach and two generations of compilers later.

With the A two compiler, it became one of the first compilers to get extensive use in the computer world, and that is what laid the foundation for higher level programming languages that fell along that same pathway. At this stage, computer languages were mostly reliant on symbols, not on words, and Hopper saw need to change that as well. She wanted to create a system which programs could be written

in English. Letters, she reasoned, were really just symbols, so they should be something that could be interpreted by a compiler and then converted into machine code. So she made further adjustments to the compiler she had created, and she built something called the flow Matic compiler f L O W DASH M A t I C. The flow Matic. Well, this set the stage for an important programming language called Cobal.

But before Cobal, we have to talk about four tran So over at IBM, there was a programmer named John Backus who was leading a group who are designing a programming language and their group had a lofty goal. They wanted to create a high level programming language. So in other words, they wanted a language that's much closer to how we humans tend to communicate with each other, rather

than the types of languages that machines rely on. Assembly language is a low level language, and it's still pretty close to machine code, and it's best used for low level applications. IBM one is something that would be much easier to use from a programming perspective, something that's much more robust. For TRAN was the solution, and it stands for formula translation. Some folks call it a scientific language.

It's largely used in the scientific field. For TRAN was machine independent as well, which meant that it could run on different computers and not just a single type. So it wasn't that they had developed this for a particular type of IBM computer and that's the only thing it would run on. It was meant to run on different types of machines, and it was also meant to be easy to learn and suitable for a wide variety of uses.

The tradeoff for high level languages is that it takes longer to compile them into machine code, so it's it creates a delay in executing the code. You end up making it easier to build the code for humans, but it's harder for the machine itself to read the code. The compiler has to translate more and more, so if the language is easier to program in, you can make up the gap of that decrease in efficiency for executing

the code, and that was the case with Fortran. The high level nature increased the execution time by about twenty so it added more time for it to execute the code using the compiler, but it increased the efficiency of actual programmers by five percent, so programmers were writing programs

faster than they were before. They were making up way more time because of the ease the relative ease of programming and for tran as opposed to programming and say assembly language, so it took longer to execute the code, but that was more than balanced out by how quickly

programmers could actually write code. So while back Is Group developed for Trand in nineteen fifty four, it wasn't until nineteen fifty seven they got a commercial release for Trand would become the programming language for the scientific community, which is why it's still used in weather modeling applications, as I mentioned in our previous episode. Alright, so back to COBAL. The development of COBAL took place right around the time

the third generation of four trand was being developed. COBAL would become important because it helped unify efforts in programming. Up to that point, all those computers were pretty much using their own specific methods of programming. So you couldn't build a program meant for one system and poured it directly over to another. You'd have to go about rebuilding your entire program following the architecture and constraints of your

new machines architecture UM or design, I should say. And so in the late nineteen fifties, some computer scientists set out to create a programming language that could run on different computers, and that group was then Conference on Data Systems Languages or CODACILL c O d A S y L. Members of the group included government employees, computer science experts

from various universities, and members of various industries. So by the end of nineteen fifty nine they had settled on the specifications of their programming language, and they called it the Common Business Oriented Language or COBAL for short. It would officially be published in January nineteen sixty after receiving approval from an executive committee. How the Department of Defense

was really behind the effort. They were really pushing for it because they were one of the few agencies in the world that actually possessed computer systems from different manufacturers, So they were running into this problem of having all these different computer systems that were incompatible with each other. Most other places didn't have that problem because they didn't

have the money to own that many different systems. They were all in with a single system, but a unifying language would mean they could run programs on multiple machines to handle lots of boring stuff like data management, tracking information for inventory, payroll administration, and other tasks. The US government would eventually require that all computers sold or least to government agencies had to be able to run COBOL software,

which ensured the languages adoption. It's very sad that was Cobal and not Cobold's the little critters from Dudgeons and Dragons that end up being low level monsters, but such as life now. The custodian of COBAL is the American National Standards Institute, which develops and publishes new COBAL standards. COBAL saw the most use in government and business applications,

whereas for TRAN was being used in scientific applications. Now, with COBAL and for TRAN, we are in the earliest days of computer programming, and I think this is a good place for us to include today's episode. In our next episode, we're gonna look at how those programming languages and a couple of others arose over the years and

gave birth to different programming languages. We're gonna look at how these different languages are different, why are they different, what is it that they are able to do because of those differences, and kind of explain the various families of programming languages and why they exist. So make sure

you tune into the next episode to learn more. And then we're gonna turn our glance to some other form of technology, something that doesn't involve supercomputers and programming languages, at least not on the technical end, because eventually I gotta stop talking about math or my brains will leak out of my ears. If you guys have suggestions for future episodes of tech Stuff, you should let me know by sending me an email. You could scream out the window,

but I often can't hear you. The email address for our show is tech Stuff at how stuffworks dot com um or you can drop us a line on Twitter or Facebook. The handle it both of those is tech Stuff hs W. Remember you can go to twitch dot tv slash tech stuff and watch me record these shows live. Every Wednesday and Friday, I go live and I record episodes of tech Stuff. You get to talk with me, I chat with the chat room. We have a grand old time, and you also get to see all the

outtakes that don't make it into the final version. So go to twitch dot tv slash tech stuff to check out the schedule, and I hope to see you in there and I'll talk to you again really soon for more on this and thousands of other topics. Because it has staff works dot com