Category: computers

Love of Lisp

I have an on again, off again love affair with a language called lisp. It is the second oldest high level computer language with only Fortran being older. It is deceptively simple at its core. It wasn’t even meant to be an actual computer language when it was created. It was a notation created  by John McCarthy in 1958 to talk about Church’s lambda calculus. Shortly after he published a paper about it, one of his graduate students, Steve Russell, implemented it on a computer.

Lisp distinguishes itself by being comprised of a half a dozen or so primitive functions, out of which the entire rest of the language can be derived. Just because it can, doesn’t mean that it should be, so most modern lisps compile to either machine code or virtual machine byte code. This typically results in a considerable performance boost.

Lisp was heralded as the language of artificial intelligence. That was probably because it had the novel property of homoiconicity. That is to say, the structure of a lisp program can be faithfully and directly represented as a data structure of the language. This gives it the singular ability to manipulate its own code. This was often thought to be one of the necessary if not sufficient capabilities for a machine that could reason about its own operation.

While this was intriguing, the thing that drew me to lisp was the conciseness of expression that it facilitated. Programs that took hundreds of lines to express in other programming languages were often expressed in four or five lines of lisp.

Lisp was also the first dynamic language. It allows the programmer to continue writing code for execution even after the original program has been compiled and run. The distinction seemed important enough to McCarthy that he termed lisp a programming system instead of a programming language.

I have always found lisp an excellent tool for thinking about data, processing, and the interactions between them. Most other programming languages require a great deal of translation from the design to the finished implementation.

And so, I find myself reading and studying a book called How to Design Programs. It is a text on program design that was written using the DrRacket language system, based on the Scheme dialect of lisp. It is interesting to see the ways that the authors approach certain topics. I hope to get the chance to apply their insights to teaching a class using the book as a text.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

The Making of a Programmer Part III

I worked at Intergraph for six years. When I started there it was a startup in the exponential growth phase. It was exhilarating to come to work every day. I was working on cutting edge technology. My first job at Intergraph was as a technician. I tested and repaired specialized computers that were optimized to search graphics files for patterns. My Army training had prepared me for just such a job.

I enjoyed my work for six months or so. Then I got tired of working with broken computers all the time. One of the engineers discovered that I knew how to program and gave me some tasks to do. Before I knew it, I was working for him and he was the head of the newly formed networking department.

I was given the task of writing a program to copy files from one computer to another over the network. Originally the plan was to write the program using Pascal, I high level, structured programming language. I was uncomfortable with that. I kept finding problems with the implementation of Pascal that would have to be worked around. I finally suggested that we implement the program in assembly language.

Programs on the PDP-11 were often given three letter names. I called my file transfer program IFM and told my boss it stood for Intergraph File Management. I told my friends the truth. It stood for It’s F%#$ing Magic.

After making IFM work between two PDP-11 computers my next challenge was to add VAX-11 computers to the mix, that is I had to transfer files from PDP-11 to VAXs, VAXs to PDP-11s,  and VAXs to VAXs. Luckily, VAX-11 assembly language was a super set of PDP-11 assembly so the translation went smoothly.

The next challenge came when Intergraph decided to build an intelligent desktop workstation that ran Unix. I was provided an early prototype of the workstation, serial number 8, to get file transfer working. This time the underlying file system was different than it was on the DEC machines. I had to start from scratch. I decided to use C, the system programming language made famous by the Unix system.

My new file transfer program was called FMU for File Management Utility. I leave it to the reader’s imagination what that actually stood for. C proved to be a powerful language and I learned to employ all kinds of heuristics to determine how to preserve the semantics of the files while transferring them from one type of file system to another.

It was during this time that I went back to college. I had over two years of credit under my belt and the college that I was attending didn’t have a Computer Science degree program at the time. So, I took Physics, and Calculus, and all the computer science classes that they offered. I ended up getting a Bachelors of Science degree in General Studies.

I worked full time while getting that degree. The last term before I graduated, the college announced that they were going to start offering a Computer Science degree. I asked what it would take to get a second degree in Computer Science. They looked at my transcript and said that all I would have to do would be to take forty more hours to establish residency and I would have the degree.

By this time I was friends with most of the professors in the Computer Science department. I arranged to teach one class and take two ever term until I finished my second degree. I taught Operating Systems a number of times, 8086 Assembly Language, and Artificial Intelligence. It was a great time, but all good things must come to an end.

One of the other colleges in the area had a bunch of Computer Science professors with PhDs that didn’t get tenure. The college that I was attending snapped them up and didn’t renew their contract with anoy of the adjunct professors with less than a PhD. I took my second Bachelors in Computer Science and called it a day.

Next installment I’ll talk about my experiences working on the Star Wars program, working for NASA, and landing my dream job at an AI lab.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

The Making of a Programmer, Part II

When we left off I was talking about my experiences circa 1980. I had been writing Computer Aided Instruction (CAI) for the Army in BASIC. In particular, I was writing code for the Commodore Pet. It ran a particularly nice version of Microsoft BASIC, complete with support for both audio cassette storage and disk drives connected via the IEEE-488 GPIB interface standard.

Personal Computers of this era rarely had hard drives. The hard drives made developing software for the Pet relatively nice. It was while working there that I discovered that it was possible to write self modifying code on the Pet. That was, to my mind any way, a necessary, if not entirely sufficient, requisite for creating Artificial Intelligence.

During a Christmas leave we went home to Murphysboro, Illinois to visit my parents. My dad was a high school teacher and was negotiating the teacher’s salaries for the next school year. He had access to a Radio Shack TRS-80. I wrote a BASIC program that was essentially an early forerunner of a spread sheet to allow him to analyze the effect of salary adjustments on the overall cost of a given proposal. He could run two or three scenarios in the time that it took the school board to analyze one. I was proud of my impromptu hack.

After I got out of the Army, I went to work for a little company in Birmingham that specialized in selling personal computers to small businesses. They were particularly appreciative of my ability to go back and forth between building and troubleshooting hardware and writing software.

My big achievement there was a program that allowed a person with a blueprint of a sheet metal part to describe the part to the computer so that the computer could generate a paper tape to control the machine that automatically punch out the part. The paper tape was called a Numerical Control (or NC) tape. I called my program an NC Compiler. I had to write an assembly language driver to control the paper tape punch that was hooked up to the computer.

It is important to say that I wasn’t learning how to program in a vacuum. For my entire four years in the army and for years afterwards I subscribed to Byte magazine. Byte magazine was completely devoted to personal computer hardware and software. They published schematics of hardware, and listings of software. Every August the published their annual computer language special issue in which they featured a different computer language every year.

Byte is where I learned about Pascal, Lisp, Smalltalk, Forth, Modula 2, Ada, Prolog, and other languages that I don’t even remember off the top of my head. They also published reviews of the various personal computer hardware and software products. It was the only magazine that I had ever subscribed to that I read the advertising as diligently as I read the articles.

There were other computer magazines that were influential like Kilobaud, and Dr. Dobb’s but Byte was the best of the lot. I wonder how kids today learn about computers but then I remember that they have something that we didn’t. They have the internet. If you want to learn something about programming today you have your choice of articles, books, or even videos telling you how it’s done. For that matter, you have the complete back catalog of Byte magazine and Popular Electronics at your finger tips. Of course, they are a bit out dated now. The are interesting from a historical perspective I guess.

When I left the small startup in Birmingham they still owed me several months pay. I finally was able to negotiated a swap for some flaky computer hardware in lieu of the back wages that I had little hope of ever seeing. Subsequently, I spent many a frustrating hour investigating the operating system of the little computer by translating the numerical operation codes back to the assembly code mnemonics so that I could analyze them, a process called disassembly.

It was about this time that I decided to go back to college and finish my bachelor’s degree. In the next installment I will talk about the languages that I was learning, and some of my experiences working for Intergraph.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

The Making of a Programmer

I sometimes think about the way that I learned about computers. I started out with a subscription to Popular Electronics magazine. At the time, I didn’t know much about electronics. I quickly learned about Ohm’s law which describes the behavior of electrical current in a resistive circuit. I picked up various details about other types of circuits and components by reading articles about them.

My dad’s cousin, Jim Shrewsbury had written an introductory book on radio. I read it cover to cover. I decided that I wanted to get an amateur radio license so I bought a copy of the ARRL Radio Handbook. I had trouble mastering morse code so I didn’t obtain a license until I was an adult. But I learned a lot about electronics.

In January 1975, Popular Electronics published the first installment of a two part article on building a small computer. Up until then, computers were large machines that took up lots of space and required lots of power. The idea of an individual owning one was rather novel. My imagination was sparked. I wanted one.

I read everything I could find about computers. I got access to a multi-user computer called Plato at the college library. When I was desperate for a job I enlisted in the Army for training in digital computer repair. After a struggle to pass basic training, I found myself in Huntsville, Alabama at Redstone Arsenal to learn how to fix the computers in the Pershing missile system.

The first part of the course taught us about digital logic, the basic building blocks of computers. Next, we learned about a small computer built specifically to teach how computers worked called the ComTran-10. I later learned that it was patterned closely after the Digital Equipment Corporation PDP-8 minicomputer. This was my first experience with writing assembly language programs for a computer.

Assembly language is the native language of a computer. It varies between computer models. Each assembly language instruction corresponds to an instruction that the central processing unit (CPU) of the computer executes natively. Once you’ve learned how to write programs in assembly language there is no program, in theory, that you can’t write.

That is of course a bold statement. It assumes that you can break down the problem into simple enough pieces that it can be expressed in assembly language. It also assumes that when you finish breaking down the problem, you have enough hardware resources, memory, CPU time, etc., to actually execute the program.

The way most modern programs are written are in higher level languages. Higher level languages are programs that translate programs from languages that are easier for humans to understand into the raw binary numbers that represent the assembly language instructions that the CPU can directly execute.

The process of translation is magical. The first higher level languages were written in assembly language. But then, the subsequent higher level languages could be written in the earlier higher level languages. In modern times, the only people that actually know assembly language are the people that design CPUs and the people that write higher level languages. (Even though the higher level languages are written in other higher level languages, the still have to generate assembly code as output.)

In the rest of the course, we studied the two computers that actually comprised the Pershing system, the guidance computer and the launch computer. We studied every component in the entire system. We learned to troubleshoot the system down to the individual component level. In the end, we knew how those computers worked.

When I got back to Redstone Arsenal from my tour in Germany, it was to spend the balance of my enlistment as an instructor in the school where I had learned about computers. By this time the Commodore Pet computer was being used to teach students about digital logic. The Pet was the forerunner of the famous Commodore 64 computer that many kids of a younger generation than me cut their computing teeth on. The Apple II and the Radio Shack TRS-80 were also on the market by then.

BASIC was the language that all of them were programmed in. It was the language that I used to become a journeyman programmer. It was exciting. It was more powerful than any language I’d programmed in before (with the possible exception of the Tutor language that the Plato system used). But for all that BASIC was an awful language. But it was the best thing that we had at that time.

That was a turning point in my career as a programmer and it will serve as a good stopping point in my story. In the next installment, I’ll give some examples of the kinds of programs that I wrote in BASIC and the languages that eventually replaced it.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

My First Experience with Programming

During my second year of college I took an introductory course in psychology. It was a large class that met for lectures in a large auditorium. The labs were held in smaller groups and presided over by graduate assistants. They had recorded the lectures and made them available in the library so that if you missed the live lecture you could make it up at your convenience by listening to the recording.

They had also created computer based instructional material on a new system that was also available in the library. The system was called Plato. Plato was a mainframe based program that ran on a computer at the University of Illinois in Champaign-Urbana. The system supported numerous graphical terminals that could be connected remotely via modems and phone lines.

I was so impressed with the system that I applied for a user account on it. When it was granted, I found a user who was a computer science major and had program space allotted on the system and befriended him. He gave me a portion of his programming space to use. I bought the book on Tutor, the language in which Plato was programmed and set about teaching myself to program.

Tutor was an interesting language. It was similar in some ways to Fortran and in others to Basic. It had features that were unique to it, at the time at least. One of the most interesting features was the ability to take a list of words and phrases and match them to an arbitrary block of text allowing authors of instructional material to automatically score answers to essay questions.

The terminal on the system had a resolution of 1024 pixels wide by 768 pixels high. It was a monochrome plasma display. The pixels were orange when they were lit and brownish black when they were dark. The display had a programmable character generator so you could create custom characters in addition to the standard alphabet. This allowed for text that was displayed in different alphabets as well as character based graphics. It was also capable of line graphics.

The screen was touch sensitive so you could point to items on the screen to select them. The keyboard had more keys on it than a standard typewriter keyboard. This included several special function keys as well as special shift keys that allowed for extensive keyboard command short cuts.

I enlisted the aid of my wife at the time to design a custom character set that allowed me to animate a simple drawing of a halloween cat walking across the screen. This thrilled me that I was able to use the computer to make a programmed animation.

Later the next term, the local administrator of the Plato user accounts conducted an audit of the programming space allocation. My computer scientist friend had accounts on other computers on campus and hadn’t spent much time on Plato. He had not done any curriculum related work with his portion of his account.

I, on the other hand, was a cinema and photography major. My animated cat was directly related to my curriculum and ended up saving my friend’s (and my) programming space.

The system was lots of fun. It had a user to user message system. It had discussion threads, and it had a bunch of multi-user games. For example, it had a multi-user implementation of Star Trek. It had a dog fighting game. It had a game called Empire where you tried to conquer the world. These games were often written by users.

A few years ago I was Googling around on the internet and discovered that someone had written a Plato emulator that ran on the internet and an emulator of the terminal that ran on Windows, Macs, and Linux machines. There were a bunch of videos about the system on You Tube. I downloaded the terminal emulator and requested an account on the system. It was interesting to revisit my first experience with computers. It reminded me of why I had become so passionate about them.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

I Know How Moses Felt

Tonight my new MacBook Pro that I ordered in October is sitting in the UPS warehouse in Huntsville. Thanks to the magic of the internet and UPS: Tracking software, I followed it from China to Shanghai, to Anchorage, AK, to Louisville, KY, to Nashville, TN, and finally, at 2:09AM this morning, to Huntsville, AL. It will sit there until Monday when it will be put on the truck for delivery.

To say that I am frustrated is an understatement. I have a perfectly good computer. It is serving me well for the things that I use it for every day. I read my email. I record my vitals. I write my words, which for the past month has entailed writing a minimum of 1667 words per day on a novel. I use it to write my blog post. I occasionally use it to write software.

The MacBook Pro will allow me to do all that plus more. It will allow me to record music with Garage Band, edit video with iMovie, develop iOS, macOS, tvOS, and watchOS software in Swift using the XCode IDE. It will allow me to do all that anywhere I want to take it. It is the lightest, most capable laptop Apple has ever made.

And yet it sits in the UPS warehouse until Monday. I will live. I will enjoy it when it comes but I will do other things until then. But I will be frustrated, thinking about how close it is and yet still not here.

Sweet dreams, don’t forget to tell the ones you love that you love them, and most important of all, be kind.

Memories of a Time Before

The life we lead today is like science fiction when compared to how we lived when I was a boy. We had TV but we only got three of four channels. Some of them were intermittent at best. All television was broadcast over the air so you had to have an antenna to receive stations that were any distance away. Most televisions were black and white. There was a time when color televisions were becoming the norm.

All phones were connected into the phone system using wires. There were no cell phones. There were pay phones all over the place. Phone calls cost a quarter for three minutes. It was a luxury if you had more than one phone in the house. We would often be told to get off the phone because someone was expecting an important phone call.

Computers were large affairs that only the government, universities, and large businesses could afford. At their smallest, they were the size of a refrigerator and at their largest they could occupy an entire floor of a moderate sized building. Programmers worked with pencil and paper. They were often referred to as System’s Analysts. There weren’t many colleges with degrees in Computer Science. Most programmers had degrees in Electrical Engineering or Mathematics. IBM discovered that English and Music major were particularly good at writing complex programs and started hiring them as programmers as well.

The transistor was the newest innovation. Every kid wanted their own transistor radio. We listened to rock and roll music on AM radio stations. We formed garage bands and learned to play the songs that we heard on the radio and dreamed of signing a recording contract and becoming stars.

When your friends moved away, you wrote them letters and mailed them with an envelope and a stamp. You wrote the letters with pen or pencil on paper. There was no such thing as email or text messaging. Even when your friend moved across town you might still write letters to keep in touch.

When you took a picture, you had to either develop it yourself which required a dark room, lots of smelly chemicals, and a good bit of skill, or you would send your exposed film to a laboratory to be processed and it would be a couple of days before you got your pictures back. And there was no way to know if they were going to turn out any good until after they had been processed.

Tape recorders were relatively expensive. There were cassette tape recorders that you could record music off the radio on and then there were reel to reel tape recorders that were more expensive and were high enough quality to record demo tapes of music. I never owned a reel to reel tape recorder but my friend’s father did. We used it to record the music we composed for our garage band. I wish I  had a copy of those tapes now.

What do you remember about the time before we woke up in this science fiction story?

Sweet dreams, don’t forget to tell the people you love that you love them, and most important of all, be kind.

The Ever Expanding Standards of Literacy

Once upon a time the definition of literacy involved both reading and writing, more specifically writing with a quill. To write with a quill, you had to know how to form the end into a fountain pen. This required some skill with what is still known as a pen knife. There were also pencils but writing in pencil was not as permanent as writing in ink.

Then typewriters were invented. Now writers could write faster and more legibly using this remarkable machine. The definition of literacy didn’t change so much as the expectations of your readers were raised such that you were expected to use a typewriter to submit your manuscripts. Thus, the definition of literacy expanded a little bit.

Next came the computer. With a computer you could have assistance with spelling and grammar. You could reach more people, thanks to the web. You could edit text without having to totally retype it. You could easily make multiple copies. It was important to make sure that you made mutiple backups of the files on your computer in multiple places. The definition of literacy expanded to the use of computers to read and write with.

We come to the most recent addition to the attributes of literacy. You must be able to create web sites. You can do that in several different ways. You can do it the old fashion way using HTML and CSS. Or, you can find one of the many web frameworks like Ruby on Rails, or Django, or Grails, or many others. You might try one of the numerous different implementations of Wiki. Or, you might try a content management system like WordPress or Drupal. This has further expanded the expectations of the literate person.

I enjoy writing. I am thankful that I have a computer instead of having to write everything out longhand. I am relatively sure that I wouldn’t have gotten this far in my quest to master the craft of writing. I still have much to learn but I have much better tools with which to work.

Sweet dreams, don’t forget to tell the people you love that you love them, and most important, be kind.

Evolution of Programming Part Two

In the last installment we had traced programming from an electrical engineering activity involving patch cables through assembly language and FORTRAN and then Lisp. There were many other early computer languages. Some were interpretive like Lisp. Others were compiled like FORTRAN. All of them sought to make it easier and faster to develop working programs. But they all overlooked one fundamental fact.

The purpose of programming languages was for programmers to communicate the details of their algorithms to other programmers. The production of an executable binary (or the interpretation of the source code by an interpreter) was a motivating by product but the same results could have been theoretically produced by typing the numeric instruction codes directly into the computer like the first programmers did.

High level languages allowed programmers to examine their ideas in much the same way that an author of prose reads their manuscript. They facilitated experimentation and they served as a short hand for communicating the details of complex computational processes in terms that the human mind could grapple with.

There were many paradigms of programming throughout the years. One of the first that was identified as such was Structured Programming. Many of the early languages had a very simple syntax for altering the flow of execution in a program. They typically consisted of a statement that evaluated an expression and then based upon the value of the expression caused execution to continue with either the next sequential statement in the program or else branch to another location in the program. This simple construct was how the program made decisions.

The problem was that in those early languages programmers often found themselves in the situation where they wanted the program execution to branch to a different location unconditionally. This was accomplished by a GOTO statement. Both FORTRAN and Lisp had them in one form or another. The GOTO statement made it very difficult to follow the thread of execution of a program. Structured Programming asserted that all programs could be expressed using a small set of control structures, IF, THEN, ELSE, WHILE, UNTIL, and CASE for example. The details of how those instructions work are not as important as the absence of the GOTO from them.

Structured Programming did make programs easier to read but it turns out there were cases when GOTO was absolutely necessary. But it was still considered a construct to be avoided if at all possible. Both FORTRAN and LISP implemented constructs to make it possible to use Structured Programming techniques in them. There were a large number of other languages that supported Structured Programming, notably Pascal and C.

The next popular programming paradigm was Object Oriented (OO) Programming. The idea was that you bundled data, stored in bins called fields, with the pieces of programs that operated on it, called methods. In the first OO language, Smalltalk, the idea was that objects sent messages to other objects. The messages had arguments that made them more specific. The objects would receive these messages, dispatch them to the methods that processed them and return the value that the method computed to the caller.

It turns out that Object Orientation was a very effective means of compartmentalizing abstractions. It made it easier for programmers to visualize their programs in terms of a community of cooperating abstractions.

OOP is still a popular paradigm today. Examples of modern object oriented languages include C++, Java, Ruby, Python, and many others. As it turns out, OOP didn’t replace Structured Programming. Rather, it extended it.

Another popular programming paradigm is functional programming. Surprisingly enough, Lisp was the first functional programming language. One of the key aspects of functional programming languages is the fact that the pieces of programs, called functions or methods, can be manipulated and stored just like any other data. They can be passed as arguments to other functions, and stored in variables to be recalled and executed later.

An example will help to clarify. Suppose that you had a program routine that sorted a list. In many languages that routine would only be able to process a list that only contained all the same kind of data, perhaps all numbers, or all text. It would have to know how to compare any two elements in the list to see what order to put them in. In a functional language you could write a sort routine that would take a comparison function as well as the list of items to sort. Then, if you passed in a list of numbers, you could pass in a comparison function that knew how to compare two numbers. If you passed in a list of text items, you could pass in a comparison function that knew how to compare to text items. The actual sort routine wouldn’t have to know what type of items were stored in the list.

Another aspect of functional languages is the concept of referential transparency. That is a very scary term that simply means that any function that is called with any given set of arguments will always return the same value such that you can replace the call to the function with the value that it returns. This is a very good thing if you have a function that takes a lot of time to compute that gets called multiple times with the same arguments. You can save the result from the first call (called memoizing) and return it any time the function gets called a second time and speed up the performance of the program immensely.

This brings us almost up to how the World Wide Web fits in but it is going to have to wait for part three. Sweet dreams, don’t forget to tell the people you love that you love them, and most important of all, be kind.

Evolution of Programming Part One

At first every computer was designed and built by hand from scratch. The very first computers were programmed by connecting circuits together with patch cables. They were built with vacuum tubes as the transistor had not been invented yet. At that stage programming was primarily an electrical engineering task.

As the state of the art progressed, computers were designed and built by hand but there was an evolutionary resemblance between each successive unit. Some time around this time John Von Neuman came up with the idea of storing programs in the computers memory so that they could be easily modified. Programming, while still a very specialized task, became less hardware engineering and more similar to creating abstract mathematics. Programs were specific to the computers they were written for but the concepts were applicable to other models of computers.

As computer manufacturers started building computers with semiconductors instead of tubes and built many computers with essentially the same design, programmers started sharing small routines to do common tasks like reading from an input device or writing to an output device. These small routines evolved into operating systems.

Up until this time programs were written out on special forms and then converted into punched cards or paper tape with holes in it. These media were then fed to the computer to load the program. The program was run by computer operators who then collected any output generated and returned it along with the input media to the programmer. This was a time consuming process. As anyone who has ever written a program can tell you, the first attempt was rarely exactly as you intended it so there was a lot of head scratching done over memory dumps to try to figure out what went wrong and fix the program so that it could be submitted to run another time.

About this time, someone had a heretical idea. Instead of humans laboriously converting their programs into the numerical codes that the computer processed directly, they would write a program that would allow the programmer to write the program using a symbolic character representation where each symbolic word corresponded to the numeric code of the machine instruction. This representation was called assembly language and it sped up the development of programs by a factor of ten or so.

The next big change to programming was the development of the so called high level language. The first such language was called FORTRAN which was a word coined from the phrase FORmula TRANslation. It allowed engineers to specify programs in terms of the equations that they wanted to solve. This drastically improved productivity again, at least in so far as your program involved computing the solutions to equations.

The next high level language was called Lisp and it was derived from the phrase LISt Processing. Lisp was designed to facilitate the manipulation of abstract symbols. It was based on the idea of a list of symbols. Each symbol was called an atom. These atoms were arranged in lists enclosed in parenthesis. Lists could also contain other lists embedded within them so that when they were written out it seemed to the uninitiated like a lot of arbitrary words with parenthesis sprinkled liberally throughout.

The truth was, Lisp was a revolutionary advance in computing for a number of reasons. First and foremost, Lisp programs were written as lists, just like the data they operated on. This made it easy to write programs that read and wrote other programs. This made it possible for Lisp programs to think about programs in a rudimentary way.  The study of Computer Science exploded in a frenzy of research about the kinds of things that could be represented and computed by a program and the research was largely done in Lisp at the key research centers.

Lisp was also one of the first programming languages that you programmed interactively. Typically the programmer sat at a console and was presented with a prompt, often a greater than character or a dollar sign. They would then type a Lisp expression in. The computer would read what they typed, evaluate it, and print the result. Then it would prompt for another line of input. This process was called  the Read, Eval, Print Loop or REPL for short.

This style of programming encouraged the programmer to explore the problem domain piece meal instead of spending days designing solutions that might not work out when they were finally executed.

A third important attribute of Lisp programs were that they were largely independent of the details of the underlying hardware. Since they were typically stored in the human readable text source form, they could be easily moved from one type of computer to another. There was a bit of up front effort to implement the Lisp language on the new computer but the application programs moved over rather smoothly.

It is interesting to note that as later languages would introduce new features to the programming community it would be found that these features were pioneered by the early computer science researchers using Lisp.

In part two of this article, I will trace the evolution from Lisp to the World Wide Web. In the mean time, sweet dreams, don’t forget to tell the people you love that you love them, and most important of all, be kind.