The Homeschool Computer Science and Programming started with icebreaker introductions. Tell the class three truths and a false statement about yourself, including the instructors! Everyone was asked to share their experience with programming and computer science.
The class is filled with new faces as well as familiar ones. Every student has varying experience and interests. To gauge the different levels, we started a discussion on what everyone's interests, or goals for the class were. Interests ranged from 3D printing and Minecraft commands, to animation and advanced programming. Since this class will take a project-based approach, students will learn to merge all of these goals into one project, or projects -from all of the class-shared objectives and set Homeschool curriculum objectives. Students will learn how to create an "objective tree" by using several methods. Think of each objective, or goal as a separate piece that relates to the rest, to fit together making a large puzzle. By using an objective tree, as a class we can break each goal down into smaller definable characteristics. We will start to interconnect each objective (goal) from these.
Name that hardware! When the homeschool students walked into Tech Em, they noticed two tables at the front of the studio with a slew of mismatched computer hardware. How could they not notice! Each piece of hardware was labeled with a different number. Students were tasked to write down what they thought each hardware is named and what year they think it was invented our built. When they were finished, we went over what each piece was and when it was invented. Many of the devices' real identities and age came to a complete surprise to everyone. For example, what students thought was just a keyboard, was actually a whole computer, the TRS-80 (or "trash-80", despite the nickname, it is completely respectable)!
This exercise was an excellent intro to the advancement of computer hardware. The hardware devices from the quiz were from several different decades. A vacuum tube representing the 1940's, and a Raspberry Pi (first generation from 2012).
To gain a further appreciation for the advancements in computing, learned that a computer does not have to be powered with electricity or by a battery. Even their parent's car is considered a computer. Examples of early computers started with Tally Sticks, at a time when history was not recorded. These were tools (mechanical devices) to aid in counting. Other examples included were the Abacus (~2700 BC to present), Pascal's Calculator (1642-1800's), and the Arithmometer, by Charles-Xavier Thomas in 18201. Then came the introduction of the "Father of Computers", Charles Babbage, who designed the first automatic computing engines and Ada Lovelace, the FIRST computer programmer! She developed programs to be carried out by Babbage's machines. This was a great segue from calculation to computation2.
So, what is hardware? What is software? What is a computer program?
Engineers are always searching for building faster devices, and developing tools that increase the efficiency of these devices. Students learned that the advancements in computing hardware were categorized into generations. The use of the vacuum tube (about 17,000 of them!) with commercial computers, like the ENIAC.
The transistor replaced the vacuum tube as the main component of hardware. The advent of the transistor helped to ring in the second generation of electric-commercial computers, like the IBM 1401. These computers only consisted of about 10,000 transistors, a big improvement from having 17,000 unreliable vacuum tubes. Because transistors were smaller, more durable and more reliable, they were more efficient than its predecessor, the vacuum tube. Think of the transistor as a switch, it can have two distinguishable states, on or off, it can store two different numbers, one or zero. These little transistors are the building blocks of computers, combine more than one of these together (with a few more hardware components) and you get a circuit allowing flow, and control of that flow of electricity, which were placed by hand on printed circuit boards. Controlling electricity flow helps the computer perform actions we specify it to perform, efficiently.
The more transistors, the more zeroes, and ones (data) a machine can process. Computers store data using zeroes and ones. Engineers started miniaturizing integrated circuits to end up with microchips, reigning in the third generation with one of the first microcomputers. Each year, we were able to have increasingly more circuits placed on a single integrated circuit (Moore's Law) 3. Presently, we can store about 730 million transistors on a 1X1 inch micro chip. 4
By looking into the history of computer progression, we were able to see it in-person at the front of the Tech Em room with the interactive quiz we completed earlier in class.
To inspire students for project ideas they might complete during this homeschool session, they were presented with many examples of projects performed at Tech Em. These included, Raspberry Pi projects (Morse code w/ LEDs, temp/humidity sensing), publishing designed games with the Hyperpad app, microcontroller and coding with Arduino, 3D designing and printing (even with Minecraft!), building apps, advanced programming -data structures, and making creating a graphical user interface (GUI) with Python.
We briefly went over this in class. We are going to be using GitHub as a way to compile and organize everyone's coding projects they have been working on. This site can 'host' their repositories, so it will all be in one place. Once we start typing up code, we will teach them how to upload their projects onto a private repository. Having all of their projects in one place will help with putting together a portfolio from the class if you and your child choose to do so. Students can upload other software projects they work on outside of class (and after this class) onto this site. There are millions of open source projects on GitHub that your child has access to once they create an account!
We will be using a messaging app called Slack. Tech Em has been using this for some time. We have created a separate Slack 'team', to have all the students from each of the classes join. This provides the opportunity for students to reach out after the class with questions on any of the concepts we learned, discussing projects, or troubleshooting code while at home. While students are using Slack, they will have the opportunity to access feedback from the rest of the Tech Em Studios team!
For those students that have an email address, please accept the Slack invitation if you have not already done so.
For those that do not have an email, parents, you have the option of either creating an email with your child with Gmail or another domain, or we can send an invitation to your email.
After accepting the invitation, your child can create their own credentials for the Slack sign-in.
During the time until next class, students can create a GitHub account to start getting used to it. As a class we will go through how we will upload our projects.
We are planning on having every student earn an official Tech Em Studios certificate for the course! We will most likely have an 'assessment' towards the end to make sure each student has understood the fundamental concepts of what we teach throughout this Fall towards the end of the session.
We started with a review of what we went over last week: Objective discussions (what our learning interests are for the class and project ideas), using Slack, GitHub, the Interactive Quiz on hardware devices.
Some in the class are familiar with the programming language Python, while others are not. We used Python version 3. For veterans and 'newcoders' alike, we reviewed and learned how the interpreter works. This is a place where we can quickly test out ideas to see how they work. We also reviewed and learned how to create a new Python file and save; in order to run our program (or code).
We completed an exercise in Python using the module, 'turtle'. This is a fun way to dive into Python while working with animation techniques. We learned several different coding fundamentals. A module is like library we can pull information from and bring into our program we write. To bring in the turtle module, we first wrote
import turtle for the first line in our code. By importing a module, we can manipulate a slew of functions previously written. We then created a variable (a placeholder for information) along with the function, Pen, by writing
t = turtle.Pen(). A function is essentially "reusable code." When we run these lines of code, a new window pops up with a pixelated arrow head (our turtle). This turtle leaves behind a pixelated trail behind itself when we give the instructions to move it, thus making a complete arrow. Because of this, it is helpful to think of the turtle as a snail instead -real-life snails leave trails (mucous trails!).
Since we created the variable 't', we can tell our turtle to move by calling that variable. We did this by writing
t.forward(100) (does not have to be 100). We can also create other variables with any name -any, except for 't' since we already named a variable as such.
Other commands we used:
t.left(90) (or any degree amount)
After learning the ropes of this module, we challenged ourselves with completed various challenges. These included, making a complete square, a square without corners and an octagon. After writing a couple of these programs, we realized we were typing multiple lines of the same with the same command orientation. To shorten our code, we could use a loop (something that repeats).
For example, when making a square we initially wrote:
we can decrease the amount of lines of code by using a loop function. Here is an example:
for i in range(4):
By using this loop function, we decreased the amount of lines we need to write. This still makes the same square! Notice the underscores before the instructions. These are present to show the implementation of the 'tab' key, though in Python, this happens automatically. We learned in class, any instruction under a function that is 'tabbed' will perform that function's attributes.
By using the coding fundamentals we learned from class, create multiple 'turtles' that each create a different object or design on the screen. If you are unsure of how to get the right version of Python installed on your computer at home, just ask us in Slack! For instructions on how to get to Slack look to the section on this blog from last week.
A module is like library we can pull information from and bring into our program we write. These are programs created by writing definitions into a separate file called a module or script. This is saved on a permanent memory device like a disk, so that it can be used over and over again.1 When we type
import turtle at the beginning of our program we are able to use the tools already written in that program with our program. We also learned and implemented another Python tool, a variable -something of quantity, able to assume varying values. This value you assign to a certain variable can anything, an integer or name, or anything you tell it to be. Once we create our variable, we can reuse it. You may notice there is a repeating theme here, reuse, over and over, etc. This theme boils down to making things more efficient to increase productivity. While we write our programs, we will always strive to make things more efficient. So, if you realize you are rewriting code to complete a similar task, go ahead and make a variable or function -reusable code. When you use tools like this, you can holistically shorten your programs your write and the time frame you write them in. We also used loop functions to write our instructions for our 'turtle' to complete, which also aimed at shortening our program.
Here is an example of excellent use of variables using the turtle module:
To download Python on your computer at home visit python.org. Be sure to download the version, 3.5.2 for your particular operating system (Windows, Linux/UNIX, Mac OS X, etc.)
To further engrain our learning of the what makes a computer, a computer (devices for manipulating information), our understanding of a computer program (a set of instructions that causes a computer to perform a specified task)7, a computer's instruction cycle (Fetch, Decode, Repeat); furthermore, to incorporate objectives for the class, we learned what 3D printing is. We also came to understand how 3D printing works and the benefits of 3D printing and 3D designing. We started our 3D print and design lecture with learning about dimensions (1D, 2D, 3D) and what a dimension actually is.
The lecture on the different dimensions can be summed up with a "screenshot" of the Tech Em whiteboard this evening:
A 3D printer is just like a regular printer that we are used to using, except with an extra dimension. A regular printer (2D) prints in two dimensions (X and Y), whereas a 3D printer prints in three dimensions (X, Y, Z). The Printer we used at Tech Em is a MakerBot® Replicator 2, using a biodegradable thermoplastic called PLA (Polylactic acid) -consisting of nine carbon atoms; however, that is another story! These days, 3D printers have been created to use a slew of other materials; from concrete to chocolate. The 3D printer's extruder heats this material to 230°C (really hot) to spew it out one layer at a time. The plastic cools quickly and hardens, so when the extruder travels to lay the next layer of plastic on top of the previous, it has a nice even-structured surface to print on. The printer repeats this process until you have your object! Of course, the 3D printer does not do this on its own, we have to give the instructions of our model to the 3D printer to carry out.
To design our 3D model, students were introduced to the app, Autodesk 123D Design software. This is an iOS app that lets you mold, and create things on the iPad. The challenge was to design something that serves some purpose or solves a problem. With that said, we are essentially printing an object that is considered technology. Once we have finished our 3D design we then save the file as an ASCII STL file (saved as filename.stl), one that the MakerBot software can recognize.
Quickly test out ideas in days instead of months
3D Printing can lower your prototyping costs by thousands
Making mistakes isn’t costly, and allows you to learn by trial and error
Learn using a hands on approach
“If you use 3D Printing for prototypes, you will simply be able to go to market faster!” – Joris Peels; i.materialise
During class, we had discussions on what a 3D printer can do, i.e. 3D printed hearing aids, prosthetics, organs, duck feet, and soap bar holders. Take a few moments until next class, to figure out a 3D design that would serve some function or make something easier (what's called "a hack" these days).
Autodesk 123D Design
We took a look at our newly printed 3D objects we designed last week. We designed our objects serve some function. Designs ranged from door handles and hooks, to pencil/pen holders and phone cases. We recalled that 3D printing allows us to test out design ideas quickly. If we make a mistake, we can quickly redesign and reprint. We discussed any design flaws in our first prototypes. For some, we revisited the design.
To incorporate animations objectives, we introduced ourselves with the visual programming language, Scratch. Here, we can create programs and games using a 'drap-and-drop' method. In terms of computer science, "Scratching" means to reuse our code. Reusing code increases efficiency and adaptability of that code. We related this to our experience in the Lightbot app and Python (when we worked with the turtle module). We then took a look at the user interface of Scratch; including, Controls, Events, Motion, etc. Sprites are heavily used in this program and animation in general. A sprite is a graphic made on the computer ( i.e. a character) that can be put in motion and solely changed. To break that definition down, for a character to smoothly run, jump, and turn on the screen, an individual snapshot of that character performing those actions must be created and called upon.
Follow the steps to download Scratch here
Draw your own character on Scratch.
Give the character instructions to move by using your keyboard.
When the character moves, have it move smoothly by creating a sprite for each movement.
The class took a look at the steps to take to solve a general problem. This served as a precursor to make a rough tree model of student's objectives (or goals) from the first day. We discussed abstraction. In computer science, abstraction is used to rule out details and make the use of code and data a little easier. You can think of abstraction as a way to remove differences and details, so you can see how one solution might work for many different problems. "What?" -essentially, abstraction is the art of breaking down a concept or problem to make it seem more manageable.
To understand how to approach a problem, we used George Poyla's mathematical view of solving problems. By replacing some of the context within Poyla's "How to Solve It" list, we made it applicable to our hypothetical problem. We started by discussing a hypothetical task: Our house is a mess, and we need to clean the house by a certain time.
First, we'll understand the problem, then we'll find a connection between the information we are given and the solution. Let's break it down: Adapted from Poyla's How to Solve It list 7, here are the steps we took to solve this problem as a class:
the house is a mess
Are there any special cases?
needs to be cleaned by a certain time
How will you know when this problem has been solved?
Look for Familiar Things
Think: Divide and Conquer
Make an algorithm
The task of cleaning the whole house is a large abstract problem. This may seem overwhelming at first. But, you can think of it as a large task divided into subtasks, which are defined by cleaning each room separately, hopefully making the original task seem more manageable. For example, we can start with the kitchen. The kitchen can be divided into smaller tasks, or details i.e. washing the dishes, or wiping the counters.
To summarize: first we ask questions. Second, we look for familiar things. Then, we make the problem more manageable by dividing and conquering. Then we make a plan to solve the problem, or make an algorithm. See if the plan works! 7
3D animation, designing games, learning Python, learning Java, learning how to create and use mods in Minecraft. These are just a few of the goals for the class. We will strive to relate each interest to work on a class project together. This may seem overwhelming at first, but we can make it more manageable by devising a plan to carry it out. We tackled this as a class by taking what we learned from the problem solving discussion in the beginning of class, and implementing that to make an objective tree with construction paper and other materials:
For those interested in animations,
download Unity and Blender onto your computer.
Complete the "Ball Tutorial" on Unity and we will go from there next week.
Unity is more about creating detailed games where Blender focuses on 3D designing animations.
Next week we will take a look at Unity and Blender.
For students interested in game making and creating 3D animations, we grouped off and took a look at the Unity program. Plenty of 3D games are created by using this platform. Though, the creation process is very detailed and time-consuming, you are able to manipulate countless parts of your project to eventually end up with something very well-rounded.
For students interested in the LED pendant project, we formed another group to learn the binary number system involving the whiteboard and binary flashcards. There are plenty of ways to learn the Binary Number system, a base two number system. In other words, this number system uses two digits: one and zero. The number system we are most familiar with, the Decimal Number system, a base ten number system. So, this system uses ten digits: 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9. By using binary flashcards, students learned the different place values in the binary number system. This activity is great for quickly understanding how to convert numbers from decimal to binary and vice versa.
For those that are familiar with the LED pendant, we will incorporate unique and functional 3D designs to house our freshly coded LED pendants. We started coding the LED pendants using Arduino by typing zeroes and ones. The LED pendants relay these zeroes as 'off' and ones as 'on'.
Next week we will finish our pendants and start drawing up plans to design a 3D printed 'house' for the pendants. For those students interested in creating 3D animations, we will start to master the Blender program, which is great for learning what it takes to successfully design 3D animations.
For those interested in animations, continue touring Blender and bring your newly acquired animations into the studio next week.
For those working towards finishing their LED pendants next week, physically draw up ideas (at least three) for 3D design to hold your LED pendant.
To further master the binary number system, create your own set of binary flashcards. You can use the picture above as a template. Remember, from our problem solving techniques we learned during the previous week, 'never reinvent the wheel'.
We reviewed binary with a fun binary quiz! Then jumped into finishing the transfer of our LED pendant designs we drew up last week by converting them into zeroes and ones.
We were introduced to Morse code; what it is and why it was/is important. Learning Morse code helps us to further our understanding of computer software and hardware; specifically, the 'hidden languages' of computers. Just like when we programmed with Python and in Arduino, a person relays information via a Morse code machine (this can be a range of models, from empty Altoid cases to flashlights) and that information is interpreted by others. All about communication! Morse code works with "short" or "long" blinks, which can be relayed using a flash light or coding in Python on a Raspberry Pi to control LED lights. To show Morse code on paper, we use "dots" and "dashes". In other words, Morse has two possible outputs, like binary, "ON" or "OFF".
We coded our own messages in Morse code, and had each other decode those messages. Then we jumped into an introduction on the Raspberry Pi by learning all of the components of the 'mini computer'.
What is GitHub? A Git (a version control system) repository hosting service on the web. 9 It is a site used by millions of software developers, including large companies like Apple and Google, and small startups like Tech Em. This site allows developers to easily store projects and collaboratively work on projects. 10 Due to the features of publicly storing projects and tracking the work on these projects, the site acts like a live portfolio, so it has become an important part of the hiring process. We will use this site to save and track some of the projects we have been working during the class.
Students learned the mechanisms of GitHub and how we'll use it. We learned what GitHub repositories are, the difference between commits (local commits vs. GitHub commits), pulling (syncing) and pushing. To wrap our heads around all of this, think of a repository as a folder full of files, a directory containing sub-directories. If we start at a repository (or repo) on GitHub, we can clone (make a copy) of it, to save on our computer. On our computer, the cloned repo is known as the "local" repo. So, a 'branch' was made. We can essentially follow that branch back to its "parent" (or "master"), the repo on GitHub.
We can either make changes to files in the repo directly on the GitHub site or on the local repo. When you make a change in the local repo, it does not automatically update the repo on the web. To update your change, you must first pull, or get the latest changes others have made to the repo. The you can "commit" your change, and 'push' that change to the repo on GitHub. Now the GitHub repo shows the changes you have made. There are neat features that show the history of changes, or collection of all the changes made by people collaboratively working on the repository.
Phew, right? Don't worry, it will all make sense before you even know it.
To make our very own (sort've intelligent) Slack "BOT". In other words, we are going to work together to make a Siri/Alexa 'machine'. We will harness our computer science and programming skills by using Python to give instructions for the bot to carry out.
To help explain, we'll write a blog with a nice flow diagram to understand the process. In the mean time, check out the awesome deck made by Wray (using GitHub of course!): http://techemstudios.com/decks/slackpi-to-alexa
Sign up for Slack if you have not already. To help get started, visit Chris's blog for an guide/introduction to Slack and the Slack Bot.
Create an account on GitHub. From the Tech Em blog about Slack, follow the links at the end to direct yourself to the GitHub blogs. These will hopefully help you with setting up your own GitHub account.
After familiarizing ourselves with creating a command-response program using Pythonsita, we used git commands with the Raspberry Pi, as well as the app, Git2Go to push our code changes to the repository for our Slackbot.
When we made changes and saved those changes to our local directory on the pi, a series of steps followed. To show how we can skip a fancy user-interface, we could do all we needed while in the command line on the pi. Here are some commands we learned after we made changes to our files and saved them:
git clone https://github.com/wray/code_em.gitclones the repo to the pi, now we have a 'local working directory'
this allows us to make changes to the GitHub repo right on the pi
git pull gets the latest updates to the GitHub repo we are working on
git status shows us what files we changed during our session
git add* adds the changed files, then ready for a commit
git status typing this command again just confirms our recent added file
git commit -m "description here" takes a snapshot of our changes
git log shows us a 'history' of activity
git push origin master pushes the snapshot of our changes to be permanently saved to the GitHub repo
git pull gets the latest
The Git2Go app allows pretty much all of the features you can do on a Raspberry Pi or other computer, on an iPad. We started by cloning the repository for our Slackbot. The looks are a little different on this environment, but overall visually appeasing and easy to use. Students continued their practice in understanding git flow, by making Python code changes to their own directory and performing all the actions listed above (in the command line on the pi) by using this app, Git2go.
If you have your GitHub account, try creating commands and responses in your own directory at home. You can do this by cloning the repository to your computer and making the changes using Python or your favorite test editor and committing, then pushing those changes to the repository. Or, if you have not yet received/accepted an invitation to collaborate, you can "fork" the code_em project and do a pull request. Look to the blog on Slack and/or ask a question in the Slack team.
Students continued there practice with the flow of git and started 3D design projects on Minecraft. Students would start by designing an object on a laptop. They kept in mind what they learned from their previous designs (functional designs) of what makes a good 3D print. There are still limitations for 3D printing, so being weary of potential design flaws recognized previously can save time and material. Students used the program, Mineways to render there object designed in Minecraft to a ASCII file (stl file) that the 3D printer could read.
Projects were started using the Raspberry Pi as a machine to relay morse code. For this project, students will use what they learned about morse coding, a Raspberry Pi and use a speaker, to create a telegraph machine. Students will write Python code (or set up a switch mechanism) on the pi to relay messages coded in morse! Projects were also started on Python text-adventure games and continuation of animation projects using Scratch.
Students made final tweaks to the LED pendants using Arduino, continued text adventure programs, and finished up setting up the Raspberry Pi, breadboard, and switching devices to mimic a telegraph to relay messages in morse; a speaker as the output device.
Thanks for a great session, see you in the Winter!
Also, don't forget... We are moving! New address:
1123 Gaskins Rd
P.E. Cerruzzi, A History of Modern Computing (Cambridge, MA: The MIT Press, 1998):217. ↩
Dale, Nell, and John Lewis. "Problem Solving and Algorithms/How to Solve a Problem." Computer Science Illuminated. 4th ed. Sudbury, MA: Jones and Bartlett, 2011. 196-200. Print.
Petzold, Charles. "Codes and Combinations." Code: The Hidden Language of Computer Hardware and Software. Redmond, WA: Microsoft, 1999. 5-9. Print. ↩