Vrftsjtryk

I teach programming at a university, at 2 freshmen courses. My students are being introduced to programming for the first time, so we have to teach them about algorithms, variables, control flow, functions, arrays (lists), etc. So this course covers the very basics. And every single year I see the same outcome: they get confused, frustrated, and the common question of "what are these exercises for" always arises. We don't even cover OOP and don't teach anything GUI (only CLI programs, just for them to grasp problem solving and creating algorithms).

So this year I'm trying to take a different approach: I'd like to start my course by showing them how to build a GUI program, at first by just asking them to copy and paste, until they have a working program by the end of the first class. Of course they won't understand a thing at first. But if I show them all the topics "in action" then I can introduce them to the students during the course and review the project we made on our first class.

The thing is, I'm not exactly sure what to show them. I think something like a calculator would be far too simple and might not be too attractive to young, 18-year old students that own mobile devices and see all kinds of cool applications every day. But something like a minesweeper game might be just too big a project for me to show as an example on the first class, considering they will be watching me build a program and trying to mimic what I do without understanding yet, so if this part of my class lasts for too long it might bore them to death :P

I know my course doesn't cover GUI, but I've noticed young students are not familiar at all with command-line, so maybe I can just tell them there are things on the program I'm showcasing that they will learn in future courses. As long as they get to see examples of the more basic stuff.

So, any good suggestions?

Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.

For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.

But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.

On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.

Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.

Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.

For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.

In my experience, good introductory programming courses meet three overarching goals:

1. 
   Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


2. 
   Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


3. 
   Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with basic independent learning including debugging skills, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.

It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.

My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.

Here are some neat things that students of mine have built in the command line without any OOP:
- Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)
- Fortune Teller Games (using arrays and randomization)
- Personality Quiz
- Hangman Game
- Random Name Generator
- Text Based Adventure
- Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there
- Flash Card Application (students can even actually use this to study for tests for other classes!)
- Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)
- To do list manager
- An application that manages a student roster or waitlist for a class

I hope these ideas help!