WEBVTT - The History of Programming Languages Part Two 0:00:04.440 --> 0:00:12.400 Text with technology with tech Stuff from stuff works dot com. 0:00:12.440 --> 0:00:15.600 Hey there, and welcome to tech Stuff. I am your host, 0:00:15.760 --> 0:00:19.320 Jonathan Strickland. I'm a senior writer with how stuff works 0:00:19.360 --> 0:00:22.680 dot com, where we try to demystify the universe one 0:00:22.760 --> 0:00:26.079 topic at a time, and we are going to continue 0:00:26.440 --> 0:00:29.920 our story about the history of programming languages. In our 0:00:29.960 --> 0:00:33.160 previous episode, we looked at the history of computers leading 0:00:33.240 --> 0:00:36.559 up to the development of two of the earliest programming languages, 0:00:36.600 --> 0:00:40.239 for Tran and Kobol. Technically there was another language that 0:00:40.440 --> 0:00:44.360 is considered to be the earliest or the second earliest 0:00:44.720 --> 0:00:47.880 um and really one more that's technically earlier than both 0:00:47.920 --> 0:00:52.360 of those as well, but it wasn't known about outside 0:00:52.360 --> 0:00:54.360 of Germany for the longest time. We'll cover all of 0:00:54.400 --> 0:00:56.840 that in this episode, but I'll have a slightly different 0:00:56.880 --> 0:00:58.880 structure from the last one. So in the last one, 0:00:59.360 --> 0:01:02.840 I try to stay on a roughly chronological path, going 0:01:02.920 --> 0:01:06.679 year by year talking about developments as they happened in 0:01:06.720 --> 0:01:11.319 actual history. But with programming languages that can get really confusing, 0:01:11.400 --> 0:01:13.520 and it also requires lots of jumping back and forth 0:01:13.560 --> 0:01:18.000 between the different families of programming languages because while certain 0:01:18.080 --> 0:01:21.600 new ones were starting to emerge, older ones were continuing 0:01:21.640 --> 0:01:24.880 to evolve, So I might end up saying, well, in 0:01:25.120 --> 0:01:30.720 nineteen seven, de Bah this programming language hit its fifth version, 0:01:30.760 --> 0:01:33.479 whereas this other one came out for the first time, 0:01:33.560 --> 0:01:36.399 and this other one stopped being used, and it just 0:01:36.440 --> 0:01:39.440 gets really messy. So I'm going to probably concentrate more 0:01:39.520 --> 0:01:43.000 on specific programming languages and specific groups and follow their 0:01:43.040 --> 0:01:46.120 paths down before making a jump back to a different language. 0:01:46.520 --> 0:01:49.559 I'll also do my best to explain some of the 0:01:49.640 --> 0:01:54.680 general concepts in programming. Um. There are way too many 0:01:54.720 --> 0:01:59.720 individual programming languages to go into detail in a single episode. 0:01:59.720 --> 0:02:02.160 It would take lots of episodes to talk about all 0:02:02.160 --> 0:02:06.600 the different programming languages, and also considering that most of 0:02:06.640 --> 0:02:10.359 them have multiple versions or generations of the programming language, 0:02:10.400 --> 0:02:15.760 some of which are radically different from preceding versions, it 0:02:15.880 --> 0:02:17.760 just would be too difficult for me to go in 0:02:17.880 --> 0:02:20.440 for each one. So we're gonna We're gonna do our 0:02:20.480 --> 0:02:24.440 best and cover it from a more high level perspective. Now, 0:02:24.440 --> 0:02:26.919 in the last episode, I did mention a guy named 0:02:26.960 --> 0:02:31.480 Conrad Zeus who developed his own computers in Germany independently 0:02:31.520 --> 0:02:33.640 of any of the work going on anywhere else. He 0:02:33.800 --> 0:02:38.800 also independently made his own programming language called plunka Cool, 0:02:39.400 --> 0:02:43.639 but this was virtually unknown outside of Germany for several decades. 0:02:43.919 --> 0:02:47.760 The programming language is remarkably prescient, but had no real 0:02:47.800 --> 0:02:50.320 effect on the rest of the evolution of programming languages 0:02:50.400 --> 0:02:54.200 because no one in the Western world, and really Germany's 0:02:54.200 --> 0:02:55.960 in the western world, no one in that North America 0:02:56.040 --> 0:02:58.160 knew about it, and that was where a lot of 0:02:58.160 --> 0:03:01.600 this early work in programming languages was coming from. No 0:03:01.639 --> 0:03:03.480 One in the UK knew about either, and that's where 0:03:03.480 --> 0:03:05.799 a lot of the other work was coming from. So 0:03:06.480 --> 0:03:09.079 it was an amazing achievement and I want to make 0:03:09.120 --> 0:03:12.640 sure that we acknowledge it, but it's not something that 0:03:12.680 --> 0:03:16.239 ties into the rest of our story directly. One other 0:03:16.320 --> 0:03:18.160 thing I should mention is that in the last episode 0:03:18.160 --> 0:03:20.160 are really led up to the development of four Tran 0:03:20.280 --> 0:03:24.160 and Cobal, which were two important early programming languages. Four 0:03:24.200 --> 0:03:28.760 Trand was and is still used in scientific applications, while 0:03:28.840 --> 0:03:32.040 Cobal became the programming language of choice for businesses. But 0:03:32.040 --> 0:03:34.320 there are other languages that also popped up around that 0:03:34.400 --> 0:03:37.240 same time that are unrelated to either of those, so 0:03:37.320 --> 0:03:40.960 they don't branch off from four tran or COBAL. They 0:03:41.000 --> 0:03:45.840 are independent programming languages, and one of those is Lisp. Technically, 0:03:45.880 --> 0:03:49.280 it was, at least by most accounts, the second programming 0:03:49.360 --> 0:03:52.040 language if you put aside Zeus's work and you look 0:03:52.080 --> 0:03:55.160 at four trand as being the first programming language, LISP 0:03:55.360 --> 0:03:59.600 if you're looking at pure publication years is the second one, 0:04:00.280 --> 0:04:04.360 and the name stands for List Processor Lisp l I 0:04:04.760 --> 0:04:08.600 s P. It was developed by John McCarthy at Dartmouth 0:04:08.720 --> 0:04:11.840 and M I. T in the mid nineteen fifties. The 0:04:11.920 --> 0:04:15.480 first reference manual was published in nineteen sixty and it's 0:04:15.480 --> 0:04:19.080 a programming language that is based on recursive functions, which 0:04:19.160 --> 0:04:22.560 is a function that appears in its own definition, and 0:04:22.600 --> 0:04:25.320 this sets it apart from four trand. In the Ford 0:04:25.320 --> 0:04:28.200 Trend programming language, you can view a program as a 0:04:28.200 --> 0:04:30.880 sequence of steps that a computer is supposed to take, 0:04:30.960 --> 0:04:33.200 sort of like a to do list, like do this, 0:04:33.400 --> 0:04:36.000 then do that, then do that, etcetera, etcetera, all the 0:04:36.040 --> 0:04:39.640 way down the line. A Lisp program is a function 0:04:39.760 --> 0:04:44.160 applied to data. It can also use its parenthetical notation 0:04:44.279 --> 0:04:48.400 to represent actual data, which meant Lisp programs could operate 0:04:48.480 --> 0:04:51.760 on other programs as data and it would become one 0:04:51.800 --> 0:04:55.200 of the most important programming languages for artificial intelligence, partly 0:04:55.320 --> 0:04:59.240 because uh, it was a a learning program that a 0:04:59.240 --> 0:05:01.520 lot of people were using in order to do research 0:05:01.520 --> 0:05:05.080 and development in ai UM and it was a computer 0:05:05.120 --> 0:05:08.040 program capable of learning things that could be based on 0:05:08.040 --> 0:05:12.200 on Lisp as a self modifying program because I had 0:05:12.240 --> 0:05:15.440 that recursive nature. That's what allows it to be self modifying. 0:05:16.160 --> 0:05:18.719 One interesting aspect of Lisp is that when you type 0:05:18.720 --> 0:05:22.280 out the code, you nest functions inside of parentheses, So 0:05:22.360 --> 0:05:26.040 you might end up having a whole mess of parentheses 0:05:26.080 --> 0:05:28.919 housing a series of functions that would be performed on 0:05:28.960 --> 0:05:31.520 a specific data set. And it sounds very similar to 0:05:31.520 --> 0:05:34.080 the way I tend to write. I like parenthetical asides, 0:05:34.320 --> 0:05:38.800 perhaps a bit too much. Lisp was a more specialized 0:05:38.920 --> 0:05:42.839 language and more abstract than other high level languages. And 0:05:42.839 --> 0:05:45.920 remember a high level language is one that is easier 0:05:45.960 --> 0:05:50.039 for humans to comprehend. It is further removed from the 0:05:50.120 --> 0:05:54.200 machine code that's actually running on the computer hardware itself, 0:05:54.680 --> 0:05:57.239 and then you have some sort of process in between 0:05:57.279 --> 0:06:00.279 the high level language and the machine code that makes 0:06:00.320 --> 0:06:03.720 it understandable to the machines. So humans are not great 0:06:03.760 --> 0:06:07.000 and understanding machine code. It is pretty hard to program 0:06:07.000 --> 0:06:11.280 and not impossible, but very challenging, and machines can't understand 0:06:11.520 --> 0:06:15.000 high level languages. Uh. The languages are our way of 0:06:15.040 --> 0:06:19.120 making it easier for us to work with computers. Now, 0:06:19.560 --> 0:06:21.760 LISP sees a great deal of application in the world 0:06:21.760 --> 0:06:25.640 of artificial intelligence, but it's not used extensively outside of 0:06:25.640 --> 0:06:29.440 that field. That doesn't mean that no one else uses it, 0:06:29.440 --> 0:06:32.200 it's just not as common as other forms of programming 0:06:32.240 --> 0:06:37.200 languages for other applications besides AI. Lisp would inspire Seymour, 0:06:37.279 --> 0:06:40.839 Papert and m I. T Research, a researcher rather to 0:06:40.920 --> 0:06:44.840 develop another language called Logo l O g O and 0:06:44.880 --> 0:06:47.320 that was meant to be an accessible programming language that 0:06:47.400 --> 0:06:50.480 kids could learn to code in. It used graphics and 0:06:50.520 --> 0:06:54.640 a simple set of rules to encourage learning. Another offshoot 0:06:54.680 --> 0:06:57.840 of LISP was Scheme, which is frequently used in college 0:06:57.920 --> 0:07:00.120 level coding classes to teach some of the basic on 0:07:00.160 --> 0:07:04.320 steps of programming. So you'll find that among programming languages 0:07:04.600 --> 0:07:08.279 there are several that were invented specifically to help people 0:07:08.440 --> 0:07:14.440 understand the concepts that go into various coding philosophies or paradigms. 0:07:14.680 --> 0:07:18.880 There are different approaches to coding, and some programming languages 0:07:19.080 --> 0:07:24.360 are are more appropriate for certain philosophies than others. Uh, 0:07:24.360 --> 0:07:26.040 there are a lot of languages that you can use 0:07:26.240 --> 0:07:29.000 various approaches to programming. You don't have to, you're not 0:07:29.080 --> 0:07:31.720 nailed down to a very specific approach. But there are 0:07:31.760 --> 0:07:35.640 some that just lend themselves better to a certain process 0:07:35.840 --> 0:07:38.760 versus another, And a lot of them were designed by 0:07:38.880 --> 0:07:43.080 educators who wanted to encourage people to start thinking in 0:07:43.160 --> 0:07:48.040 ways that would develop into good programming practices, and then 0:07:48.080 --> 0:07:53.640 they would graduate on to using more robust programming languages. 0:07:53.680 --> 0:07:56.800 There are actually some programming languages that aren't really meant 0:07:56.920 --> 0:08:00.800 for real world use. They're really meant just as a 0:08:00.880 --> 0:08:04.480 means of understanding the basics of programming itself and getting 0:08:04.520 --> 0:08:08.880 a grasp on computer science. Another programming language that emerged 0:08:09.040 --> 0:08:13.200 shortly after Lisp for Trand and cobol was a p L. 0:08:13.720 --> 0:08:16.400 And a p L is an acronym, and it or 0:08:16.440 --> 0:08:19.720 initialism if you prefer. Really it's an initialism and it 0:08:19.800 --> 0:08:25.560 stands for a programming language. It seems pretty straightforward. You'll 0:08:25.600 --> 0:08:28.040 notice that some folks like to name their programming languages 0:08:28.800 --> 0:08:34.120 very generic things. The creator of a p L was 0:08:34.280 --> 0:08:37.760 Kenneth e Iverson. A p L used symbols to represent 0:08:37.840 --> 0:08:41.000 functions and operators, and the nice thing about that is 0:08:41.040 --> 0:08:44.000 that it helped make the code more efficient and concise. 0:08:44.080 --> 0:08:47.239 You didn't need as much code to represent the functions 0:08:47.280 --> 0:08:50.840 you wanted to run with any given program. So one 0:08:50.880 --> 0:08:53.640 branch of a p L is sharp a p L. 0:08:54.600 --> 0:08:56.480 This was a variant that was designed by the company 0:08:56.559 --> 0:08:59.880 I P. Sharp Associates, and it added some more functional 0:09:00.200 --> 0:09:02.800 to a p L enough to be considered its own 0:09:02.880 --> 0:09:05.880 programming language. So not just a variation, it's really its 0:09:05.880 --> 0:09:09.920 own language and its own right. Programmers would create other 0:09:10.040 --> 0:09:14.400 programming languages that did not depend directly on these early ones, 0:09:14.440 --> 0:09:18.079 but they served. These early languages served as the foundation 0:09:18.160 --> 0:09:21.960 for several others. In some cases they inspired people to 0:09:22.040 --> 0:09:26.520 make new programming languages, and in other cases they themselves 0:09:26.559 --> 0:09:31.360 actually were the foundation for specific uh new implementations of 0:09:31.400 --> 0:09:35.960 programming language. There's so many variations that I can't list 0:09:36.000 --> 0:09:38.199 them all even in a series of podcasts unless I 0:09:38.240 --> 0:09:40.240 were just to rattle off names, and that would have 0:09:40.320 --> 0:09:42.560 no meaning whatsoever. So I'll focus on some of the 0:09:42.600 --> 0:09:45.720 more prominent languages and their variants, and we'll start with 0:09:45.800 --> 0:09:49.120 for TRAN, the programming language made it much easier to 0:09:49.120 --> 0:09:52.120 program calculations for computers, and it removed the need to 0:09:52.160 --> 0:09:55.960 work in machine code or assembly language. Four trans launched 0:09:56.000 --> 0:10:00.160 in nineteen fifty seven. The basic language received several updates. 0:10:00.280 --> 0:10:03.000 For Tran two came out in nineteen fifty eight and 0:10:03.040 --> 0:10:05.840 introduced some new features, such as the ability of programmers 0:10:05.840 --> 0:10:09.080 to create subroutines and functions, which meant they could use 0:10:09.120 --> 0:10:12.880 the same code repeatedly in future programs or within the 0:10:12.920 --> 0:10:15.360 same program, and it saved a lot of time there 0:10:15.400 --> 0:10:18.160 was no need to reinvent the wheel with every implementation. 0:10:19.000 --> 0:10:23.400 Other updates would follow. The first truly machine independent version 0:10:23.520 --> 0:10:26.600 of four trand came out in nineteen sixty one. It 0:10:26.679 --> 0:10:29.400 was four TRAN four. This was the first version that 0:10:29.400 --> 0:10:32.480 could run on different computer architectures, so that the same 0:10:32.480 --> 0:10:36.480 program created in four TRAN four would run across different machines. 0:10:36.760 --> 0:10:40.120 But this wasn't yet a standardized language unrelated to any 0:10:40.160 --> 0:10:44.560 specific type of computer. It still was limited to a 0:10:44.640 --> 0:10:48.640 family of architectures, but that would change with the next 0:10:48.760 --> 0:10:52.439 version of four TRAN in nineteen sixty two, you had 0:10:52.440 --> 0:10:56.319 a group called the American Standards Association, and they created 0:10:56.400 --> 0:10:59.520 a set of standards for the next round of programming languages, 0:10:59.720 --> 0:11:03.719 and the goal was to make them architecture agnostic. They 0:11:03.720 --> 0:11:07.200 didn't want programmers to have to reinvent their programs with 0:11:07.360 --> 0:11:11.880 every different architecture of computers out there. To do so 0:11:11.960 --> 0:11:14.079 would just mean that you would write the same program 0:11:14.160 --> 0:11:16.320 and then have to rewrite it and rewrite it again 0:11:16.480 --> 0:11:20.839 for every single different architecture you encountered. The language to 0:11:20.920 --> 0:11:25.040 emerge from that process was four TRANS sixty six. Meanwhile, 0:11:25.280 --> 0:11:28.520 other programming languages, including several I haven't mentioned yet, we're 0:11:28.880 --> 0:11:32.760 leaving for TRAND behind because really for TRAND was still 0:11:32.840 --> 0:11:35.160 kind of limited in what it could do. It was 0:11:35.240 --> 0:11:37.560 good at what it could do, but it couldn't it 0:11:37.640 --> 0:11:42.520 was it was like a very relatively narrow band of applications. 0:11:42.840 --> 0:11:46.719 And over the course of several years, computer programmers work 0:11:46.800 --> 0:11:51.000 to build out more functionality into four TRAN, including creating 0:11:51.040 --> 0:11:54.560 the ability to make true block if statements and direct 0:11:54.600 --> 0:11:59.439 access input output functions. That result was four TRANS seventy seven, 0:11:59.440 --> 0:12:03.079 which became the most widely used programming language in the world, 0:12:03.440 --> 0:12:05.679 and there are still examples of code written in four 0:12:05.720 --> 0:12:10.920 trans seventy seven today. Forty years later, four Tran ninety 0:12:11.080 --> 0:12:13.400 was the next version of Pure four Tran. It was 0:12:13.440 --> 0:12:16.800 created to again address some of the shortcomings of Fortran 0:12:16.920 --> 0:12:19.839 compared to other programming languages, such as the ability to 0:12:19.880 --> 0:12:23.520 allocate memory dynamically, and it was published as a standard 0:12:23.520 --> 0:12:26.760 by the International Standards Organization in n and there was 0:12:26.800 --> 0:12:31.000 one more version in N called four Tran I s 0:12:31.040 --> 0:12:35.079 O for Tran also spawned a few other languages. One 0:12:35.160 --> 0:12:38.480 notable family was the al Goal series of languages a 0:12:38.679 --> 0:12:41.720 l G O L. Like four Tran, al Goal founded 0:12:41.720 --> 0:12:46.280 its greatest applications and scientific calculations, that's really where it 0:12:46.400 --> 0:12:50.040 was used for the most part. It introduced a block 0:12:50.160 --> 0:12:53.719 structure in which coders could insert a block of statements 0:12:54.400 --> 0:12:57.120 for the scope of variables within the code, and it 0:12:57.200 --> 0:13:00.880 also incorporated recursion, which is the ability of a procedure 0:13:00.920 --> 0:13:05.320 to call upon itself. UH. It never really reached commercial success, 0:13:05.320 --> 0:13:09.120 but it had a profound impact on people developing their 0:13:09.120 --> 0:13:12.920 own programming languages. So in other words, it wasn't so 0:13:13.360 --> 0:13:18.239 compelling as to get universal adoption, but it definitely inspired 0:13:18.280 --> 0:13:21.520 a lot of programmers to give it a world and 0:13:21.600 --> 0:13:25.200 to then incorporate some of those elements into their own 0:13:25.280 --> 0:13:29.640 programming languages later on. Next, we've got pl slash one 0:13:29.679 --> 0:13:32.880 PL one programming language. This was from George Raydon, a 0:13:33.200 --> 0:13:37.160 computer scientist who held degrees from Brooklyn College, Columbia University 0:13:37.160 --> 0:13:40.120 in the City University of New York. This was a 0:13:40.160 --> 0:13:43.280 real hybrid language. At borrowed elements from four TRAN, from 0:13:43.360 --> 0:13:47.040 cobol and from ALGOL. The name stands for programming language 0:13:47.480 --> 0:13:52.240 PL one. It's pretty straightforward. IBM would take PL one 0:13:52.640 --> 0:13:55.800 and mush mush mush it into p LS. This would 0:13:55.880 --> 0:13:58.800 remain ibm s programming language of choice until the C 0:13:59.120 --> 0:14:02.120 programming langue wages came along a bit later. The PL 0:14:02.240 --> 0:14:06.440 one format allowed for more complex processes without the need 0:14:06.600 --> 0:14:09.679 to build up an enormous amount of code, So in 0:14:09.679 --> 0:14:12.040 other words, you could use the code to execute a 0:14:12.040 --> 0:14:15.320 bunch of different operations rather than building each of those 0:14:15.320 --> 0:14:19.400 operations up from more basic components. It was not only 0:14:19.520 --> 0:14:23.120 used in scientific and business applications, but also data processing, 0:14:23.240 --> 0:14:26.160 so we're starting to get into some more general purpose 0:14:26.240 --> 0:14:30.200 computing at this point. Keep in mind, the computers well 0:14:30.280 --> 0:14:33.440 before the personal computing age. They tend to be very 0:14:33.480 --> 0:14:37.760 specific use machines. They weren't necessarily meant to do lots 0:14:37.800 --> 0:14:41.760 of different things. They were built for specific purposes, and 0:14:41.840 --> 0:14:45.400 therefore a lot of these programming languages were tuned to 0:14:45.440 --> 0:14:47.600 those specific purposes. You didn't have a lot of general 0:14:47.600 --> 0:14:51.200 purpose computing in those early days. But that's it for 0:14:51.280 --> 0:14:54.920 the direct For trend descendants, we'll talk about Cobal just 0:14:55.000 --> 0:14:58.400 really briefly. Like for trand Cobal would evolve over time. 0:14:58.440 --> 0:15:01.480 There were versions like Cobal six D one and see 0:15:01.480 --> 0:15:05.480 Cobal seventy four and see cobalight five O O or 0:15:05.680 --> 0:15:09.360 object oriented Cobal. I'll talk about object oriented programming a 0:15:09.360 --> 0:15:12.160 bit later in this episode to explain what that actually means. 0:15:12.720 --> 0:15:16.160 And Cobal two thousand fourteen. According to the Gartner Group, 0:15:16.480 --> 0:15:20.640 eighty per cent of the world's business runs off Cobal code, 0:15:21.280 --> 0:15:23.920 so very influential, and keeping in mind it was like 0:15:24.000 --> 0:15:27.520 the third big programming language to emerge, it's pretty impressive. 0:15:28.200 --> 0:15:31.600 So that's the basics for the foundation of programming languages 0:15:31.680 --> 0:15:34.000 early early on, and the next section I'm going to 0:15:34.080 --> 0:15:36.720 look at some of the big programming languages that followed 0:15:37.200 --> 0:15:41.240 and what those are intended to do. Why are these 0:15:41.560 --> 0:15:44.920 programming languages in the first place, Once we established them, 0:15:44.920 --> 0:15:47.160 why did we need more? We'll look at that in 0:15:47.160 --> 0:15:49.920 the second but first let's take a quick break to 0:15:50.080 --> 0:15:59.800 thank our sponsor. You know, I I noticed that I've 0:16:00.040 --> 0:16:03.160 used the word basic to describe a lot of things 0:16:03.200 --> 0:16:05.320 in this podcast, so I guess it's a good time 0:16:05.360 --> 0:16:10.240 to talk about the programming language Basic. Thomas E. Kurtz 0:16:10.280 --> 0:16:14.760 and John G. Kimeny, students at Dartmouth College that designed 0:16:14.840 --> 0:16:17.360 the programming language, and they had the intent to create 0:16:17.400 --> 0:16:20.960 one that was easier to code in the earlier languages. 0:16:21.360 --> 0:16:25.120 So before Basic, most languages required a pretty strong grasp 0:16:25.280 --> 0:16:29.640 on mathematics. So in fact, mostly early programmers and computer 0:16:29.720 --> 0:16:33.120 scientists like Grace Hopper, you know, the person who we 0:16:33.280 --> 0:16:38.720 credit with coining the term computer bug. She was a mathematician. 0:16:39.760 --> 0:16:42.000 In fact, that was what her interest was in. She 0:16:42.080 --> 0:16:44.800 didn't want to be known as a programmer. She was 0:16:44.920 --> 0:16:47.520 interested in mathematics, and that's what a lot of the 0:16:47.560 --> 0:16:52.360 earlier programs were. They were mathematicians. But not everyone can 0:16:52.440 --> 0:16:56.400 have that sort of grasp on very complex mathematics. So 0:16:56.480 --> 0:16:59.160 basics design meant that you didn't have to be a 0:16:59.200 --> 0:17:02.160 math whiz to learn how to build a program. I'm 0:17:02.200 --> 0:17:05.320 personally thankful for it because that's the programming language I 0:17:05.400 --> 0:17:08.679 have the most direct experience in. The language did have 0:17:08.800 --> 0:17:11.960 some hefty level limitations, but it wasn't designed to be 0:17:12.000 --> 0:17:14.080 the last language you'd ever need to learn. It was 0:17:14.119 --> 0:17:18.680 really to get you into programming. The name stands for something. 0:17:18.680 --> 0:17:20.920 It's not just a word, it's actually again, and it's 0:17:20.960 --> 0:17:26.040 an acronym. It's beginners all purpose symbolic instruction Code Basic. 0:17:26.880 --> 0:17:29.879 The initial version of Basic debut in nineteen sixty four. 0:17:30.440 --> 0:17:33.920 A decade later, Bill Gates and Paul Allen would offer 0:17:34.000 --> 0:17:36.440 up a version of Basic as one of the first 0:17:36.440 --> 0:17:41.120 products from a little company they founded called Microsoft. Basic 0:17:41.280 --> 0:17:44.600 was also the language of the Apple too. That particular 0:17:44.720 --> 0:17:48.800 variant was integer Basic, but these were all from the 0:17:48.840 --> 0:17:52.200 same family. Basic taught students how to think in terms 0:17:52.200 --> 0:17:55.840 of logical progression to design code that would produce a 0:17:55.840 --> 0:17:59.399 desired result. Typically, you'd begin each line of code with 0:17:59.480 --> 0:18:02.359 a number to designate that line, to say what order 0:18:02.760 --> 0:18:05.480 that goes in as far as the order of operations. 0:18:05.760 --> 0:18:09.000 So for example, I might type one zero to mark 0:18:09.080 --> 0:18:12.240 the first line of code, and then I would follow 0:18:12.280 --> 0:18:14.000 that with some sort of command, so would be one 0:18:14.080 --> 0:18:18.600 zero space something for example cls, which would stand for 0:18:18.640 --> 0:18:21.240 a clear screen. Then I could follow that with the 0:18:21.280 --> 0:18:23.680 next line of code, which would begin with a new 0:18:23.760 --> 0:18:27.639 number like to zero to zero. I might write print 0:18:28.160 --> 0:18:31.600 that tells the computer that the next thing I type 0:18:31.640 --> 0:18:34.760 in it will need to display or print out in 0:18:34.840 --> 0:18:38.800 some way, and I might put in quotation marks hello world. 0:18:39.000 --> 0:18:42.639 It's very common way of learning programming is doing your 0:18:42.680 --> 0:18:45.560 first Hello World. Then I could type in one more 0:18:45.600 --> 0:18:48.200 line of code, and I type in the number three 0:18:48.280 --> 0:18:52.080 zero's for our third line, and type in the word 0:18:52.400 --> 0:18:55.640 end to end that program. So if I ran that program, 0:18:55.640 --> 0:18:58.000 it would clear the screen and then print the line 0:18:58.040 --> 0:19:01.200 hello world, and that's all it would do. Obviously, this 0:19:01.400 --> 0:19:03.959 is not the extent of what you can do in Basic. 0:19:04.040 --> 0:19:06.560 If it were, it would be a pretty useless language. 0:19:07.119 --> 0:19:10.159 You could add other elements, such as if then statements. 0:19:10.400 --> 0:19:13.120 You might ask for an input from the user, such 0:19:13.160 --> 0:19:15.920 as a line of code that prints the sentence would 0:19:15.920 --> 0:19:18.480 you like to learn about tech stuff? And then another 0:19:18.560 --> 0:19:20.919 line that presents either a yes or no option to 0:19:20.960 --> 0:19:22.919 the user. You know, you could type a Y or 0:19:22.960 --> 0:19:26.600 an N. Your if then statement would then have a 0:19:26.640 --> 0:19:31.240 branching pathway. So within your code you would have different 0:19:31.720 --> 0:19:35.560 lines that would represent what happens depending upon what the 0:19:35.680 --> 0:19:38.240 user did. So, if the user typed in a why, 0:19:38.840 --> 0:19:42.480 you might then have a bit of information about tech stuff, 0:19:42.480 --> 0:19:45.600 saying it's a totally awesome podcast hosted by a groovy 0:19:45.680 --> 0:19:49.879 dude named Jonathan Strickland. If you typed in and it 0:19:49.880 --> 0:19:52.840 would say, what's your problem? Man? You want to know 0:19:52.880 --> 0:19:55.120 about tech stuff? It's pretty awesome. I think you need 0:19:55.160 --> 0:19:57.560 to know more. If you typed anything else, you might 0:19:57.600 --> 0:20:00.000 get a message saying I'm sorry, man, I totally don't understand. 0:20:00.040 --> 0:20:02.760 What the heck are you trying to say? Those are 0:20:02.760 --> 0:20:07.000 those if then statements. If user types this, then go 0:20:07.280 --> 0:20:13.080 to this other line of code. Very basic idea, no 0:20:13.200 --> 0:20:19.560 pun intended. In programming in the late nineteen sixties, a 0:20:19.680 --> 0:20:23.960 new programming language created a revolution in programming. And it's 0:20:23.960 --> 0:20:28.200 an important language, though one that I think most non 0:20:28.280 --> 0:20:33.359 programmers haven't really heard about. It's small Talk. That's something 0:20:33.400 --> 0:20:36.280 that any computer science major has likely studied at some 0:20:36.359 --> 0:20:39.840 time or another. But why was it so important? Well, 0:20:39.880 --> 0:20:43.119 small Talk created a new paradigm for programming. It was 0:20:43.160 --> 0:20:46.919 an object oriented programming language, and it began as a 0:20:47.080 --> 0:20:51.080 project at Xerox Park. Now that's the same research and 0:20:51.080 --> 0:20:54.240 development branch of Xerox that brought us tons of other 0:20:54.280 --> 0:20:57.760 stuff like the graphic user interface, the Gooey or the 0:20:57.840 --> 0:21:02.440 virtual machine or the mouse. So what exactly does it 0:21:02.560 --> 0:21:05.760 mean to be an object oriented programming language? What is 0:21:05.960 --> 0:21:09.920 an object in programming? Well, an object can be many things, 0:21:09.960 --> 0:21:14.280 including a function, a data structure, a method, or a variable. 0:21:14.800 --> 0:21:18.320 Small Talk incorporated this concept and also included a related 0:21:18.359 --> 0:21:22.720 one called inheritance, which allows you to make a subclass 0:21:22.760 --> 0:21:25.760 of an existing object. This is useful if you're working 0:21:25.760 --> 0:21:29.760 with variations on the same basic structure. An inherited subclass 0:21:30.040 --> 0:21:34.400 will initially be identical to its parent class. So let's 0:21:34.400 --> 0:21:37.960 say you've created an object and then you create uh 0:21:38.240 --> 0:21:40.840 and you know, use inheritance to create a subclass of 0:21:40.880 --> 0:21:42.919 that object. At first, it's going to be identical, but 0:21:42.960 --> 0:21:47.040 then you can make changes to the subclass that will 0:21:47.160 --> 0:21:51.480 not change the parent class of object. And from a 0:21:51.520 --> 0:21:55.000 programming perspective, this makes it easier to build complex code 0:21:55.119 --> 0:21:58.120 because you don't need to rebuild the entire object each time. 0:21:58.160 --> 0:22:01.240 You just take that you make a subclass or you 0:22:01.800 --> 0:22:07.480 implement a subclass that you've already established. Objects have two 0:22:07.880 --> 0:22:10.240 facets to them. They have a state and they have 0:22:10.280 --> 0:22:14.120 a behavior. So it's easier to think about this if 0:22:14.119 --> 0:22:17.159 we use an analogy and think about a physical object, 0:22:17.520 --> 0:22:20.040 which can be anything. Really, the analogy can be a 0:22:20.080 --> 0:22:23.760 little helpful. Let's let's think of a cat. First. Of all, 0:22:23.800 --> 0:22:25.720 cats would hate it if I called them objects, but 0:22:25.960 --> 0:22:29.440 for this purpose we're gonna refer to cats. So cats 0:22:29.480 --> 0:22:33.679 have numerous states. One state for a cat might be 0:22:33.840 --> 0:22:36.160 the breed of cats. So is it a tabby cat? 0:22:36.320 --> 0:22:39.239 Is it a Persian? Is it a Siamese? That is 0:22:39.280 --> 0:22:42.760 that cats state, and it also has a behavior like 0:22:43.040 --> 0:22:47.520 purring or treating you with utter contempt. You can describe 0:22:47.560 --> 0:22:51.240 this object, the cat, by its state and by its behavior, 0:22:51.400 --> 0:22:55.919 so it is uh the same with objects and object 0:22:55.960 --> 0:22:59.120 oriented programming. You can describe them by their states and behavior. 0:23:00.040 --> 0:23:04.280 Objects store states and what are called fields or variables. 0:23:05.119 --> 0:23:08.280 These include all the possible states for that object. The 0:23:08.359 --> 0:23:12.399 behavior of objects is expressed as methods or functions, and 0:23:12.840 --> 0:23:15.440 um when they are applied to it. The methods operate 0:23:15.560 --> 0:23:19.280 on an objects internal state. One of the big benefits 0:23:19.280 --> 0:23:22.520 of object oriented programming is the source code for any 0:23:22.560 --> 0:23:27.000 given object is independent of that of all other objects. 0:23:27.000 --> 0:23:32.399 They are their own entities. This makes objects modular, and 0:23:32.440 --> 0:23:34.840 you can easily pass an object around a system because 0:23:34.840 --> 0:23:37.720 it's not directly entwined with everything else. Now, in the 0:23:37.760 --> 0:23:40.680 real world, this is easy for us to imagine. Right, 0:23:40.720 --> 0:23:43.920 Let's say that you've got a baseball and a baseball bat. Well, 0:23:43.920 --> 0:23:46.159 those two things are are related in the sense that 0:23:46.160 --> 0:23:48.440 they're both used in a baseball game. But you can 0:23:48.440 --> 0:23:50.480 pick up the baseball and leave the bat behind. You 0:23:50.520 --> 0:23:52.520 can pick up the bat and leave the baseball behind. 0:23:52.560 --> 0:23:55.280 They are not directly connected to each other in any 0:23:55.320 --> 0:23:58.959