Doram's Programming Class - Material

[Doram]

This post by Doram was thumbed up by: 2

Forgotten (February 7th, 2017, 3:44 pm) • ~Yuri (February 10th, 2017, 6:44 pm)

[Doram]

0010101001010100101010101010100111010011001011010100010001011110100100101010111110011010100110011101110100111101010101010101001001010101010101010101010000111110101001010101010101010101010101001010101010101010101010101010101010101001010101010101010101010010101101001010010101001011011001010101010101010101010101010010101010101010010101010101010

---

Lesson 1: General Concepts

---

01010101000101010010101110111010111001010010100010001010101010010101010101010101010101010010000101101011011111101010010110110101010010101001010101011101001101010101010101010010001010101111100101010100101010101001010101010101001010101010010101010101010101010101101001010010101010101011110101010101101010100101010101001010101010101010101010010110101001010101001010101010

Ok, we're gonna take this from day zero, and build our way up. ALL I am assuming that you know is the basics of using a computer, like how to turn it on and run a program (like discord or your browser).

First off, what I'm covering: We're starting with general computing and programming concepts, then generally how a language is set up and pseudocode, then a brief HTML+CSS rundown, and finishing up with translating that into some Javascript programming.

Pardon the baby level here, but I am assuming zero programming knowledge here, so let's just get this out of the way, shall we? (Thankfully, this will be the shortest lesson...)

---

Programming. What is it? Short answer: a structured way to give a computer instructions to do anything. Long answer: stick around and find out.

First off, in the MOST general sense, here is everything involved: You have your computer which is a hunk of metal and plastic that does math, a program that uses that math to do stuff, the programmer (you) who writes the program and designs what stuff is done, and the user who runs the program and does stuff with it.

Next up, structured. What do I mean by that? I mean that there's a set of instructions that have been set up to allow you to break any problem down into well defined baby steps that a computer can do easily, like math, and a logical framework that organizes those smaller things into a larger task. All of those instructions, when grouped together are called a language. And that means exactly what it sounds like. It's a language that you can use to talk to the computer, in a very real sense. Whether or not it accomplishes anything completely hinges on how well you learn to talk in this new language.

Now, all those baby steps fall into two broad categories: the engine and the interface.

The engine (sometimes referred to as the logic) is what drives the program, and does the number crunching and organization that accomplishes the task. The logic of the engine is purely what a computer was truly meant to do - math, and lots of it. Everything up to about Trigonometry is super easy for a computer to do, and it is capable of doing any one simple equation millions of times a second. Also, comparisons fall into this category. Is one number bigger than another? Yes, do one thing. No, do something else. Those comparisons are, in fact, the heart of a program's ability do do stuff.

Interface is a layer on top of that, since it involves math. But at the most basic levels, it is designed to get those ones and zeroes put together into decimal and letters and shapes, and give you some human way to get what's in your head into a mathematical process for the computer through instructions, and how you can take the numbers the computer is crunching, and turn them back into something visible on a screen.

The first layer of it is actually for the programmer, and is literally the language that you are using, and the interface you use to create your program (in terms of Javascript, that will be notepad and text documents that you use to write the language), and from there, it becomes the actual result or program that you create with those instructions, from inputs and outputs that you request from the user, to the visual look of the program and what it does.

All of this interface stuff generally affects what is referred to as input/output or i/o. The three most common i/o devices are a keyboard, mouse, and screen/monitor. The keyboard and mouse are input devices (mostly), because they are the tools to get input from a user. The user types, and moves the mouse, and the program responds. The screen is generally an output device, because it displays the results of whatever the program made from the input from the keyboard and mouse.

On a final note to the highest level consideration of all of this, I wanted to say a couple of things.

For one thing, the interface is everything your user knows about what you and they are trying to do. It sets the limitations for everything, gives the opportunities for interaction, and displays the results of what they have accomplished. Even though it truly is only half of the program (the logic doing the actual work is the other half), to your users, it is all they will ever see of your program, and represents it as a whole to them. Do not underestimate the importance of the interface.

Finally, programming is also an art. And like any human art, it is a type of communication. In terms of a video game, you are telling a story. In terms of a utility, you are telling them what you think a computer can do to make our lives easier and more rich. And, since it uses computers, it is also a type of cooperation. You aren't just telling a story, you are helping a player live a story. You aren't just telling someone how to use a computer to create useful things for their lives, you are giving them the tools and environment to do so. Your act of creation, helps them with their own act of creation, and you create something together. It is quite a beautiful thing, and to my mind, truly the pinnacle of human art. Keep that in mind if anyone you meet ever looks down on programmers.

Next lesson, we'll dive into how a typical language is set up, and introduce you to pseudocode. Discussion and Homework is HERE.

[Doram]

0010101001010100101010101010100111010011001011010100010001011110100100101010111110011010100110011101110100111101010101010101001001010101010101010101010000111110101001010101010101010101010101001010101010101010101010101010101010101001010101010101010101010010101101001010010101001011011001010101010101010101010101010010101010101010010101010101010

---

Lesson 2: Language Metastructure and Pseudocode

---

01010101000101010010101110111010111001010010100010001010101010010101010101010101010101010010000101101011011111101010010110110101010010101001010101011101001101010101010101010010001010101111100101010100101010101001010101010101001010101010010101010101010101010101101001010010101010101011110101010101101010100101010101001010101010101010101010010110101001010101001010101010

Part 1: Universal Features of Programming Languages

Ok, let's get into it then. A programming language hinges on three things: variables, comparisons, and the commands that take those and create a process flow out of them.

Variables are literally labels that the computer uses to refer to a spot in memory for remembering something. That way, you can have a spot to store a bit of information like a number, and you can have a meaningful label like "Age" that you can use the word "Age" to refer to that number, and then, you can use that label to do things with a number for somebody's age. They are called variables because that spot in memory can have its contents changed any time you want, and in fact, that's a lot of what programs do, is take that info and do stuff to it. Data Types are the different types of variables, from different types of numbers to text and more, and using them well is a major task in making your program efficient and fast.

Operators and Comparisons bring this all into the realm of math, by arranging our variables into equations. For example, we can make a decision if someone's age is over a certain number, like if your age is over 21(or 18, or whatever), then you are legally allowed to drink alcohol. We can also figure out a person's age by subtracting their birth year from this year. This is the kind of simple baby step that I mentioned earlier.

Commands are the framework that surround all of that. There will be commands for creating a variable, setting or assigning a value to that variable, and then making decisions based on that variable. There will also be commands for being able to cycle through a bunch of options (mostly called loops), and options to request or process input and output operations (such as processing keystrokes or mouse movements and clicks, or writing something to the screen). Syntax is the specific pattern that all of this must match in order to work. Syntax is a curse word to most programmers, because most of the bugs you will hunt down in your career as a programmer will boil down to tiny stupid mistakes with syntax.

Now, let's dive a little deeper into each of those.

---

Variables and Data Types

Variables will generally have a type associated with them. The most common types are "number" (usually further split into integers and some kind of floating point - a number with a decimal, but that point can be anywhere in the number, so it is called floating), "string" (any kind of text - a literal string of characters run together into, say, a sentence - and also including single characters and sub-divisions like that), "boolean" (literally yes/no or off/on, sometimes, that's all you need), and some way of handling empty or nonexistent stuff (generally referred to as "empty", "null", and "undefined", which are often NOT the same thing). There will also be some functionality for arrays, and sometimes they're considered data types, and sometimes objects, but we will get into that later. Some languages are really explicit with this stuff, and others really don't care a lot at all. That's one of the ways that each language can differ from each other.

Splitting number up, sometimes you will not just have integer and float, but each of them will also have small and big versions of them. For integers, they are generally referred to as "short" and "long". A short integer in Visual Basic, for example, can hold numbers from -32,768 through 32,767, while a long integer can hold from -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807. Similarly, floating point numbers are usually split into "single" precision and "double" precision. Again using Visual Basic as an example, a "single" can hold from -3.4028235E+38 through -1.401298E-45 for negative values and from 1.401298E-45 through 3.4028235E+38 for positive values, and a "double" can hold from -1.79769313486231570E+308 through -4.94065645841246544E-324 for negative values and from 4.94065645841246544E-324 through 1.79769313486231570E+308 for positive values.

Splitting strings up, you can have strings that are specifically designed for Unicode as versus plain ASCII, and you will usually have a type that only holds a single character. Some languages take strings really seriously and have a ton of ways to play with them, and others do not.

Which actually leads right into the last "type" of variable, arrays. Arrays are collections of variables. For example, you can consider a string to be an array of characters. In the string "Hello", the first position has the letter "H", the second has the letter "e", and so on. You can get information about the first position, for example the ASCII Decimal Code for "H" is 72, and that information can be useful by itself. Or, you could consider the string or array as a whole, and it paints a different picture. Most languages will have a special notation to them, for example "variableName [index]", where "index" is the position of the individual variable within the array. Also, most arrays start with an index of 0, so the first index is 0, the second is 1, etc. So in our variable myWord that contains "Hello", myWord[0] = "H", myWord[1]="e", and so on. Again, some languages are fine with arrays being a data type, and others are adamant that they are NOT, and we'll get more into that when we cover objects.

And, while I'm mentioning objects, I'll give you a brief taste, though they are complicated, and only implemented in some of the more advanced languages. They are similar to arrays, in that they can contain a number of other variables, but they can also contain code, from functions to get and set the variables within to the ability to change the contents in complex or unique ways, or interact with other objects. Let's take the brief example of an object "Person", which has within it a variable "Age". A couple of functions would allow you to get and change "Age", but it might also have a function to just advance "Age" by one, and that function would be called "Birthday".

There is one last comment I have on Variables, and that is the limitations on variable names. For example, most languages require that a variable start with a letter. Many require that variable names not have spaces in them, though they will usually allow dashes "-" and underscores "_". One practice that has evolved over the years is called Camel Case, and this is where a variable can consist of several words, but they are run together, and the first letter of each next word is capitalized. Thus the variable I just used "myWord". The oldest languages had limits on the length of the names as well. Good luck coming up with something descriptive and easy to remember when you only have 8 letters. Most modern languages have limits like 128 or even 256 characters, so hitting that limit is nothing you will generally have to worry about, though. Also, being as descriptive as you can with your variables is important to the readability of it, for you to understand what you are doing, and for anyone else looking at it to have a clue how your stuff works. Thus myOriginalWordEntry is great to grab the initial word, and hang onto it for further processing while finalProcessedWordResult gathers the output of your process.

---

Operators, Comparisons, and Common Issues With Them

Operators and Comparisons have their own section here because they have special importance in programming languages. Operators are part of the math of programming, and many work exactly like they do in regular math. You want to add two numbers or two variables, simply use a "+". Minus is similarly logical, although generally, division is done with a slash "/", and multiplication is done with an asterisk "*"The reason for the asterisk, is to make sure that the operator is not a letter, which will signify a variable (so using "x" for multiplication is a no-no).

Equals is also VERY important, and is so important that it sometimes isn't even considered with the Operators, and is instead considered a command, or usually just covered twice. Equals as an operator can be part of the set of Comparisons, like less-than "<", and greater-than">" so that you can test if things are the same. In fact, many languages go beyond the logical greater-than-or-equal-to ">=" and less-than-or-equal-to "<=", to dividing equals itself into "==" meaning if two things are equivalent, and "===" meaning two things are identical. This becomes an issue when you consider Data Types, because the number 6 can be equivalent to the string "6" (6 == "6" is true), but it will not be identical, because one is a number, and the other is a string (6 === "6" is false). As a command, equals is usually used for assignment. "myVariable = value" means that value is put into myVariable. So, "myNumber = 6" is a command in the fact that it has asked the computer to put the number 6 into the spot in memory labeled myNumber. Data types can also trip up more simple comparisons, too. How would you decide if the string "Hello" was greater than the number 3? Some programming languages would fail, and others have well defined logic for figuring something as obscure as that out.

There are also unique operators that exist only for programming, such as NOT, AND, OR, NAND, NOR, XAND, and XOR. Generally, when working with these, you are considering true/false conditions, which correspond to the binary 0 (false), and 1 (true). Generally, you will not go beyond the simple NOT, AND, and OR. NOT flips whatever you are working with, so NOT True = False, and NOT 0 = 1. AND is only true (1) if both of the things compared are true (1), thus 1 AND 1 is true (1), and 0 AND 1 is false (0), 1 AND 0 is false (0), and 0 AND 0 is false (0) - it essentially finds the minimum . OR is only true (1) when at least one of the things compared are true (1), thus 1 OR 1 is true (1), 0 OR 1 is true (1), 1 OR 0 is true (1), and 0 OR 0 is false (0) - it essentially finds the maximum. All of this applies, even when you are working on higher levels of logic. Testing for (myVariableA == 10 AND myVariableB == 20) would only result in a true if both the smaller comparisons are also true. The other 4 (NAND, NOR, XAND, and XOR) are combinations of those, and while used in older programming languages, have become purely the realm of circuit design in modern usage. This is partly because describing them and using them is hellishly complicated, and more than I can cover in the course of this class.

---

Commands and Syntax - Bringing It All Together

Finally, commands - the actual heart of any programming language. These are the things that you use to tell a computer what to do, and they come in three general types: Setup Commands, Decision and Looping Commands, and Complex Functions

Setup Commands are exactly what they sound like. They will create your structures and prepare them for use. Many languages require you to set up your variables and objects before you use them (and specify their Data Type), so this is where we are at in the overall process. The word used for this part of the process varies from language to language, but some of the common ones are "declare", "initialize", "dimension", or "create instance". The Commands that do this are usually some abbreviation of the preferred descriptive word. Visual Basic, for example, refers to it as dimensioning, and the command is "Dim" (So, we would start any code for myName with "Dim myName as String")

Decision Commands are also fairly straightforward. These are where much of the real power of the language comes into play, as you can make decisions based on any of your variables, other numbers that are relevant, or objects. These are spearheaded by the infamous if-then-else structure, where you start out with an if statement that is connected to a comparison of some sort, and then a block to run if the condition evaluates to true, and a block to run if the condition results in a false (when all "else" fails of course). Most of the time there is also the option for an "else if" (or bunch of them) to have more than one test in a particular piece of code. Loops, similarly, allow a comparison to limit the execution of a block of code, but in this case, it isn't deciding which block to run, but instead, how many times to execute a single block. The for-next structure has an independent counter cycling through a specified number of times. The do-while structure waits for some comparison to be satisfied by the changes made by the block of code, and usually has two forms to let the test come at the beginning of a loop or at the end of it. Finally, the simplest decision commands are things like goto, which doesn't compare anything, but just tells the computer to move to another area in your code, and continue processing from there.

Complex functions soak up the rest of the commands. Commands to generate a random number, commands to determine the type or status of a variable, commands to calculate mathematical extremes like trigonometric functions and roots and logs and such, commands to chop up and manipulate variables in a number of ways (like formatting a string like a date, or like money, or like a percent, etc.), commands to interact with the screen, draw stuff, grab info from the mouse, connect to a remote server, you get the idea.

Finally, we have Syntax to consider. Syntax is the specifics of how the language is built. Typical Syntax issues are things like these: How you end a line, and whether you can stack multiple commands in a line or not. Whether a variable has to be declared, and where and how that is done, or the exact rules for handling variables when declaring them is NOT required. Limits on variable names (as I mentioned before), and rules on exactly how different Data Types act, and how they can be compared. These are some of the most distinct differences between languages.

Discussion and Homework are HERE.

[Doram]

0010101001010100101010101010100111010011001011010100010001011110100100101010111110011010100110011101110100111101010101010101001001010101010101010101010000111110101001010101010101010101010101001010101010101010101010101010101010101001010101010101010101010010101101001010010101001011011001010101010101010101010101010010101010101010010101010101010

---

Lesson 2: Language Metastructure and Pseudocode

---

01010101000101010010101110111010111001010010100010001010101010010101010101010101010101010010000101101011011111101010010110110101010010101001010101011101001101010101010101010010001010101111100101010100101010101001010101010101001010101010010101010101010101010101101001010010101010101011110101010101101010100101010101001010101010101010101010010110101001010101001010101010

Part 2: Types of Programming Languages

This lesson is all about the different ways that you can categorize a language. You can categorize it by the format, or you can categorize it by it's environment.

---

Format Categories

There are three general "formats" of programming languages: Procedural, Object Oriented, and Event Driven. Technically, any given language can have features from two or more of those, but you can think of them as different approaches to attacking your problem.

---

Procedural Programming

Procedural is the most basic kind of programming. All languages have a bit of this. Procedural languages literally have a first line, second line, etc., and when it reaches the last line, it's done. There might be some hopping around or looping in there, but the last thing it does before it finishes is spit out its results, and then then it shuts down, and you have to run the program again to do anything else with it. Early programming languages were like this, and examples include assembly, BASIC, Fortran, COBOL, etc.

This is, in fact how DOS (one of the first operating systems) used to work (and therefore computing in general). You would start your computer, and be dumped into the "DOS Environment", which was literally a line-entry by line-entry text-only system, where you would move to the directory of your program, run your program, and when you were done and closed your program down, you would be dumped back into DOS to move to another directory and run the next program.

---

Object Oriented Programming

Object Oriented programming was the next to come along. Object Oriented languages split everything up into discrete objects that interact with each other. These objects would have their own variables (sometimes called "properties" or "attributes"), functions (often called "methods"), and error handling. The way this is structured is that you will have chunks of code (usually in a separate area, and commonly in separate files), that has the definition of the object (sometimes called the constructor), and you will call this code from another object or procedure, making a copy (called an instance) that you can fill with information and ask to do whatever it does. This makes it easier to code repeated tasks, easier to confine errors to locatable places (because the first step to fixing a bug is FINDING it), and easier to make re-usable chunks of code that can be tacked onto a project, speeding up overall development time. Examples of this include C++, PHP, Java (but not JavaScript), Ruby, Python, etc.

Fun fact on many of the most modern programming languages is that some or all of the programming language itself can be programmed in itself. JavaScript, for example, has objects that make up all of the data types and such, so that when you are declaring a variable, you are actually instancing a variable object. This runs from the definition of the data type and what it can hold (the object's properties) to how you can manipulate those variables with the built-in functions (the object's methods).

---

Event Driven Programming

Event Driven programming came along next. These are considered "high level" programming languages, because it has taken much of the process of programming and done it for you, before you even start. Event Driven programming actually takes Object Oriented programming another step further, giving you a standardized environment and graphical user interface (GUI), and the system takes care of everything to do with for that, and all your program has to do is respond to the user doing something like clicking or typing (which is the "event"). This can be compartmentalized with different controls and interface chunks (which are technically objects) that are supplied automatically, and you can just gather what is happening and route it to the appropriate chunk to be processed, and return the results to the system to wait for more input. Again, this helps make error catching easier, and also takes a lot of the programming burden off of the programmer, since most of the interface stuff is already written (which is a third to half of the work, generally).

The reason I put JavaScript in this category, even though it is fully capable of making objects and is built out of a number of them, is the fact that the vast majority of what you do in JavaScript will not be in the form of creating objects, but instead putting VERY short snippets of code under events that use the existing objects for tiny, but useful bit of programming. For example, making an image work like a button, glowing when hovering, moving when pressed, opening some link at the end of the clicking process, etc. Other uses include running and controlling media and animations, validating and manipulating data on forms, controlling complex menus, or even VERY simplistic HTML based games.

---

Environment Categories

There are two ways to define a category for environment, programming environment and running environment. In terms of programming environments, you have Compiled, Interpreted, and Virtual Machine. In terms of running environment, and this has more to do with running things that live or interact with the internet, you have Server Side versus Client Side processing of your code, which is a matter of how much processing power you need, and where it makes sense to apply that power.

---

Programming Environment - Compiled

The oldest version of this is compiled. In a compiled programming environment, you write your code in one file (a text file, for example), and then send it through a program called a compiler, which turns your written code into the string of 1s and 0s that the computer needs. In this case, each processor (such as Apple versus PC, or desktop versus mobile) will have its own compiler, turning the general code into specialized sets of binary, specific to each chipset. Sometimes the language will have specific commands for each chipset as well, meaning that the code is not always portable, but more modern languages account for that, for the most part. Also, this is a very static and unflexible thing. The written code is saved and held aside, and the compiler spits out a stable executable designed for one platform only.

Most compilers will throw errors for a large number of common errors, and the compiling process will fail, and then you have to go and debug your code until it can make its way through the compiler. However, sometimes there are bugs that make it through the compiler (usually correct syntax, but faulty logic), but will fail once the code is run, and you have to rely on your own error handling to track down the bugs that survive to that point.

---

Programming Environment - Interpreted

Then B.A.S.I.C. came along, and changed all of that. Beginner All-purpose Symbolic Instruction Code introduced the concept of an interpreter. Instead of a separate program compiling your code once, you entered the compiler as a program, and interactively wrote your code in there. The benefit? The interpreter would test your code, line by line, as soon as you entered it. Many bugs would be found IMMEDIATELY, and can be corrected before they become a problem. This interface remains to this day, as the Visual BASIC/.NET framework. Similar to a compiler, though, the executable was specific to a given chipset, and was still a bit on the unflexible side because of that.

---

Programming Environment - Virtual Machine

Enter the Virtual Machine. Java introduced the concept of putting an additional layer of software between your code and the computer running it, called the Virtual Machine. The VM would accept bitcode, meaning that you could compile a program, and make sure that it would run correctly, but then the VM would translate between the Java bitcode, and whatever bitcode was required by the chipset running it, and eliminated all the guesswork on how to handle the different ability sets of different machines. Best of all, while it could act like a compiler, and produce static executables, it could also do this real-time, and all you had to distribute was the written code, which was usually smaller than the resulting bitcode, and then it would be double-compiled at the destination, assuring maximum flexibility of your code - write it once, and it runs anywhere.

Java has come under fire in recent years, because of certain vulnerabilities that come from the way it works, but the concept is good, and adding additional layers of interpretation has produced a number of VERY easy to use programming frameworks, like GameMaker and others designed for young people to jump into programming with little to no knowledge, like Swift. In fact, this has further spread the idea that Everyone Can Code, and the drive to empower the general public by making programming as a skill more widespread. Other draws for it are still very compelling, too, since you can literally run Java on everything from a computer and printer to a Smart refrigerator to some of the more complex parts of your car.

---

Running Environment - Server Side

Now, on to the running environments. Certain languages can do both, but many choose one side or another. First, we will start with Server Side. Server Side programs run on the server (web or otherwise), and serve up either a finished functional page, or processed data meant for the final use or display. The benefit of server side programs is that they are run on a single computer (or server system), which is usually pretty powerful, and can crunch numbers for your clients, and just give them the final result that they need, in a predictable way. If you're doing infrequent, but intense calculations, Server Side is the way to go. The other major benefit of server side programming is security, since the user never sees your code, just your final processed data. Dedicated Server Side languages include PHP, Perl, and CGI.

---

Running Environment - Client Side

Client Side, on the other hand, runs completely on the client's computer. The benefit of Client side is that it can be customized to the environment that it is running in (giving different results to someone looking at it on a Mac versus a PC, for example, or even displaying the page in the same Human language as is the default on the computer - like Chinese or Spanish), and that it reduces processing load on the server, allowing it to serve many customers at the same time. If you're doing frequent but simple processing, Client Side is the way to go. Dedicated Client Side languages include JavaScript, AJAX, and, technically, HTML+CSS.

Most of the rest of the programming languages we have discussed would be considered Client Side (since they are just programs that run on your computer and never touch a server), but many things that would normally be Client Side are now blurring the line because of the Cloud. Things like Google Docs allow you to log onto their servers and run a Server Side word processing program that is just like the one you would normally run Client Side while offline. Many things also straddle the line, such as our own forums here, which are half built in PHP (for the secure side of it including the database, account management, and the basic underlying page structure - all handled Server Side) and half built in HTML+CSS+JavaScript for the final page display and functionality (using HTML and CSS as they were intended to format the page, but also including things like the BBCode which is JavaScript - all handled Client Side).

---

Ok, We're back to simultaneous lesson and questions, which are HERE.

[Doram]

0010101001010100101010101010100111010011001011010100010001011110100100101010111110011010100110011101110100111101010101010101001001010101010101010101010000111110101001010101010101010101010101001010101010101010101010101010101010101001010101010101010101010010101101001010010101001011011001010101010101010101010101010010101010101010010101010101010

---

Lesson 2: Language Metastructure and Pseudocode

---

01010101000101010010101110111010111001010010100010001010101010010101010101010101010101010010000101101011011111101010010110110101010010101001010101011101001101010101010101010010001010101111100101010100101010101001010101010101001010101010010101010101010101010101101001010010101010101011110101010101101010100101010101001010101010101010101010010110101001010101001010101010

Part 3: Pseudocode

Finally, we're getting to the meat of this lesson. Prepare for some general logic...

---

Purpose
Pseudocode is essentially a plain language description of what you want your program to do. This is truly where you start working out the logic of what you want to do. Usually, your Pseudocode will go through several versions as you break your problem down (generally called iterations by programmers), and when you are done, your pseudocode will look slightly different depending on what programming language you are using, since your pseudocode will have to take the strengths and weaknesses of your chosen language into account, in terms of how your logic is structured. We're going to take this lesson a little differently. First off, I will cover some general concepts, and then I will walk you through an example of the process. Let's get to it.

---

Pseudocode Concepts
Your first couple of iterations will generally not look like code at all, as you try to find a way to describe your problem and the possible steps to solve it. Sometimes you can see a clear path, sometimes not, and this process is how you get through those latter cases without going insane. Also, be aware that this process will be a guide for your programming, but it is not an iron rule. In the end, the programming language may steer you back away from this during the process of actually writing your program, especially when dealing with the limitations of any given language. Don't be afraid to take a moment to back off a bit and adjust your pseudocode to the new process before continuing on. As much as the pseudocode is a tool to write the program in the first place, accurate pseudocode can help you debug at the end of the process too. Also, knowing how programming languages work in general will allow you to keep to the most common structures, and make sure that you not only find it an easy task to get your chosen language to do the job, but also give you a structure that can be applied to multiple languages, if you feel the need to port your code to another platform. As you get more used to programming, you will be more able to do this in your head, though having a written record of it is still useful, if you are collaborating with someone on the programming, or if you see the possibility of other people maintaining your code at a later date.

Your goal, as much as possible, is to think about your problem from the perspective of what decisions need to be made about what you are looking at, and how you need to organize your information, in order to solve your problem. Those decisions will shape the commands you will use, and how you organize your information shapes the variables you will use. Generally, you will start with something that looks like a paragraph, and end with something that looks like an outline (where you usually go the other way around in other writing). As you break everything down, the language should start looking like code, describing conditions, loops, and variables in general language, at which point, you know it's time to get going on the actual code. In the end, each phrase or sentence should accomplish only one or two things (because any command will only do one or two things).

Now, before we jump into the next section, I will say this: breaking down a project into it's constituent parts is valuable outside of coding, and indeed, if you can learn to break down ANY process into pseudocode, it will be much easier to do it when you are coding. So, without further ado...

---

Pseudocode Example: Pancakes

Ok, we're going to take something relatively complicated, and see if we can pseudocode it. Let's say, making pancakes from scratch. (Wait. How is that complicated?)
First off, let's look at the process as a whole. You get the ingredients together, mix 'em up, cook 'em, and serve 'em. That's... 4 steps to start.

Code: Select all

1 get ingredients
2 mix ingredients
3 cook mixture
4 serve pancakes

Now we break it down further. What ingredients? Well, we need a recipe. So, let's add get recipe to the list.

Code: Select all

1 get recipe
2 get ingredients
3 mix ingredients
4 cook mixture
5 serve pancakes

Well, holding the recipe isn't helping unless you read it,and it's part of the process of getting the recipe, so we'll mark that as part of the process, as a sub-part of that step.

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
3 mix ingredients
4 cook mixture
5 serve pancakes

Ok. Now we've gotten and read the recipe, time to put it into action. The ingredients are part of that second step, right.....

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter.
3 mix ingredients
4 cook mixture
5 serve pancakes

Oh, How much might make a difference. Still second step though.

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
3 mix ingredients
4 cook mixture
5 serve pancakes

And, let's see here... dry first.... then wet.......

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
3 mix ingredients
3.1 mix dry ingredients: flour & baking powder & salt & sugar
3.2 mix in wet ingredients: milk & eggs & butter
4 cook mixture
5 serve pancakes

That's uh, kinda jumbled. Maybe we should make sure that's actually WELL mixed...

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
3 mix ingredients
3.1 mix dry ingredients: flour & baking powder & salt & sugar
3.2 mix in wet ingredients: milk & eggs & butter
3.3 stir until smooth
4 cook mixture
5 serve pancakes

There we go! No to cook.... like in a pan *looks at recipe* Yup. Pan. And, stove. Let's be as specific as possible here.

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
3 mix ingredients
3.1 mix dry ingredients: flour & baking powder & salt & sugar
3.2 mix in wet ingredients: milk & eggs & butter
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 cook mixture
5 serve pancakes

Wait. If we're being super precise about the pan, we might as well be precise about the whole process. We better specify getting a bowl and spoon at the start of all this. Oh, and a measuring cup. That's extra "ingredients", and an extra few steps to the mixing process...

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 get bowl
3.2 put bowl on countertop
3.3 measure dry ingredients
3.4 add dry ingredients to bowl: flour & baking powder & salt & sugar
3.5 mix with spoon
3.6 measure wet ingredients
3.7 add in wet ingredients to bowl: milk & eggs & butter
3.8 mix with spoon
3.9 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 cook mixture
5 serve pancakes

Actually, let's structure 3 better. That looks a little clunky...

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 cook mixture
5 serve pancakes

That's better. And while we're at it, there's more to this cooking stuff than just "cook"

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 add batter
4.6 flip pancake
4.7 remove cooked pancake from pan and put on plate.
5 serve pancakes

Wait all that batter isn't going into ONE pancake, and only so many fit in a pan at a time....

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 add batter
4.5.1 measure out a small amount of batter for a pancake and add to pan
4.6 flip pancake
4.7 remove cooked pancake from pan and put on plate.
5 serve pancakes

Uhh... that's only good for one pancake, though. What about the rest of this bowl? I guess those steps should repeat, eh?

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 Repeat until no batter left:
4.5.1 add batter
4.5.1.1 measure out a small amount of batter for a pancake and add to pan
4.5.2 flip pancake
4.5.3 remove cooked pancake from pan and put on plate.
5 serve pancakes

When do you flip again. *sigh* Might as well put that in too...

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 Repeat until no batter left:
4.5.1 add batter
4.5.1.1 measure out a small amount of batter for a pancake and add to pan
4.5.2 flip pancake
4.5.2.1 watch pancake until the edges look dry and the middle of the pancake has a bunch of bubbles in it, then flip
4.5.3 remove cooked pancake from pan and put on plate.
5 serve pancakes

Oh, fer goodness' sake. Flipping. We forgot to add the spatula to all this. Back to ingredients.......

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon, spatula.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
2.1.11 large wide spatula
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 Repeat until no batter left:
4.5.1 add batter
4.5.1.1 measure out a small amount of batter for a pancake and add to pan
4.5.2 flip pancake
4.5.2.1 watch pancake until the edges look dry and the middle of the pancake has a bunch of bubbles in it
4.5.2.2 use spatula to flip pancake by sliding under the pancake, and twisting until spatula is upside down and pancake falls back onto the pan, making sure to keep the spatula over the pan
4.5.2.3 watch for the edges to start to brown, and check that the pancake is releasing from the pan (indicating that it is done)
4.5.3 remove cooked pancake from pan and put on plate using the spatula.
5 serve pancakes

Holy crap. I bet you didn't think this was gonna get this complicated, huh.
Oh, are we serving DRY pancakes? no. Let's put some syrup on this thing and call it a day. Whew!

Code: Select all

1 get recipe
1.1 read recipe
2 get ingredients
2.1 Ingredients: flour, baking powder, salt, sugar, milk, eggs, butter, bowl, measuring set, spoon, spatula.
2.1.1 flour: 1.5 cups
2.1.2 baking powder: 3.5 teaspoons
2.1.3 salt: 1teaspoon
2.1.4 sugar: 1 tablespoon
2.1.5 milk: 1.25 cups
2.1.6 egg: 1
2.1.7 butter: 3 tablespoons, melted
2.1.8 bowl: 1 medium
2.1.9 measuring set
2.1.9.1 measuring cup
2.1.9.2 tablespoon
2.1.9.3 teaspoon
2.1.10 large mixing spoon
2.1.11 large wide spatula
3 mix ingredients
3.1 prepare bowl
3.1.1 get bowl
3.1.2 put bowl on countertop
3.2 Add ingredients and mix
3.2.1 add dry ingredients: flour & baking powder & salt & sugar
3.2.1.1 measure dry ingredients
3.2.1.2 add dry ingredients to bowl
3.2.1.3 mix with spoon
3.2.2 add in wet ingredients: milk & eggs & butter
3.2.2.1 measure wet ingredients
3.2.2.2 add wet ingredients to bowl
3.2.2.3 mix with spoon
3.3 stir until smooth
4 cook mixture
4.1 get pan
4.2 put pan on stove
4.3 turn on heat
4.4 wait for pan to warm up
4.5 Repeat until no batter left:
4.5.1 add batter
4.5.1.1 measure out a small amount of batter for a pancake and add to pan
4.5.2 flip pancake
4.5.2.1 watch pancake until the edges look dry and the middle of the pancake has a bunch of bubbles in it
4.5.2.2 use spatula to flip pancake by sliding under the pancake, and twisting until spatula is upside down and pancake falls back onto the pan, making sure to keep the spatula over the pan
4.5.2.3 watch for the edges to start to brown, and check that the pancake is releasing from the pan (indicating that it is done)
4.5.3 remove cooked pancake from pan and put on plate using the spatula.
5 serve pancakes
5.1 arrange pancakes in a stack
5.2 pour syrup over the top

Wow. That's 48 "steps", just for making some lousy pancakes. So, uh yeah. Pancakes. Never gonna look at them the same way, eh? You got the idea, though. In fact, let's test that:

Discussion and Homework are HERE.