Ideas for High School Computer Projects?

rcmpcbf asks: "HELP A TEACHER OUT! My Computer Science students often get bored doing stuff that the AP Curriculum or School Board asks us to teach. I would really appreciate the input of Slashdot members on interesting Computer Science projects for high school students. You would be helping other students, just like yourselves, not me." What kinds of computer projects do you feel would be stimulating for the high school age group?

Comments

So what if they're bored?

[Anonymous Coward]

Do you really want to teach them something other than the AP curriculum, or do you want more interesting projects that teach the AP curriculum? I'd hesitate to stray from the suggested curriculum too much because the concepts it teaches are good concepts to know and understand. Learning about the basic structures like stacks, lists, queues, etc. has helped me enormously in my career, and I have worked with people who didn't learn them, and they write worse code.

However, if you want to teach them about the same structures and algorithms, but with more interesting projects, try real world things. One project I did in my AP class (in '88), was working with word processing files. We would read in the files and do things like count words and lines, spell check, and things like that. In other words, some of the stuff an actual word processor would do. In college, I really enjoyed learning about image processing. The main problem with graphics, though, is that you have to tie the class to a specific platform, which bites.

Maybe you could teach some of the concepts and relate them to networking, since the internet is such a big thing these days. I would have loved to do stuff like that in high school.

-D

"Fastest" Program Contest

[Anonymous Coward]

One of my favorites back in high school was who in the class could write the fastest prime number generator - the key to this was the Sieve of Erastosthenes (sp?) - and even then there were many incarnations (props to Bob Markowicz at Glastonbury HS for that one!!!!!)

And one I thought of just the other day which bit me on a trading system - write a program to convert decimals to fractions...the key there is Euclid's Algorithm, I believe...

And over the course of the project drop little hints pointing the students toward these old formulas and hypothesis, don't just give it all away

Whoever's got the best one in the class gets an extra A or something who knows...these are great for not only programming but critical thinking and scientifically/mathematically thinking...we were coding in GW-Basic...I think some of these concepts are lost in the days of VB where UI's are often the focus of projects

Choose a topic you know

[Anonymous Coward]

I've seen suggestions here that are just absurd: grabbing something from sourceforge and hurling code at it or hacking the linux kernel (!) If I were a project maintainer I wouldn't want to be assaulted with code from a team of high schoolers whose interest in the project will likely drop once the course is over.

That said, encourage the students to do something in an area where you have some expertise. If the students want to make a search engine but you know nothing about searches and NLP, their project will probably fail. Encourage teamwork -- too many of my college assignments and projects are individual efforts.

And here's an obligatory list of ideas, grouped by area:

AI. Stick to "easy" problems in search and scheduling. Maybe something like a course scheduler to plan times for course sections. Simulations and games are good too.

Theory. Challenge them to write a program that prints its own source code as output. Implement an interpreter for a simple language like LOGO or basic.

Systems. Write your malloc/free (or new/delete) or a garbage collector. Design an instant messenger protocol or chat system.

Graphics. Show them the basics of OpenGL and set them loose. Have them do some basic image filtering stuff ala Photoshop.

Again, it helps to steer the students to an area which you know so you can support them. I'm too lazy to register...

Re:No Class has actually completed the project

[Anonymous Coward]

Oh, so that's where they recruited the Mozilla team.

*DUCK*

Re:A couple ideas

[Bill Currie]

One of the best (IMHO) chaotic systems to implement is N-body motion (gravitational orbits). It's dead simple to imlement (though getting reasonable accuracy can be tricky, but then that can be part of the project:), and has the fringe benefit of possibly generating more interest in space.

As a slightly more complicated to implement chaotic system, simulating a rocket in the vicinity of Earth is also good. This is more complicated because of the need to take the earth's atmosphere into account. Very good for generating interest in aerodynamics.

BTW, I've done both (from a book, "Programming for Scientists and Engineers" iirc). I learnt a lot from that book, including just how a cross product and works :)

I wholeheartedly agree!

[knghtbrd]

In my programming classes in high school, games were verboten on the school machines. Writing or playing them was considered by the school to be grounds for disciplinary action which at the very least would include being no longer allowed access to the lab or library computers. If you were in a class that used the lab computers, you would fail it.

How do I know? I moved too fast for my instructor. I learned everything he had to teach me in a matter of weeks. So he asked me if there was any project I wanted to work on. I told him and he agreed. The assistant principal came to the class one day and happened to notice first that I was using the expensive laser printer instead of the cheap dot matrix printers (needed to so I could read the result - had permission) and then saw me go straight from reading the printout with a highlighter pen to change three lines of code and start testing out this game ...

I was pulled out of class right then and spent the next forty minutes listening to this dumbass yell at me how I was going to fail the class, be suspended for a week, etc, etc, etc.. After that point, the instructor just happened to overhear the shouting walking down the hall on his way to lunch... It was all resolved by the week, but I wasn't allowed to work on the game again until next monday. I hear the AP got an earfull from the instructor for screwing with his students without talking to him first.

So what did I learn, besides that administration people suck? Arrays, sorting, pointers, linked lists, text processing, simple 2D graphics, 286 macro assembly, high-speed serial port communications, program overlays and later protected mode programming in DOS, the basics of DLLs, and a little OOP. Did I mention this was first semester Intro to Programming class?

Give them something they enjoy working on and watch their productivity soar. I did all of this on a 16MHz 386. What could someone learn with a Pentium, a 3D card, and an API like SDL which takes the OS-specifics out of video, networking, sound, input management, and window handling? They'd learn how to code, that's for damned sure!

Simple Directmedia Layer

[knghtbrd]

http://www.libsdl.org/

LGPL'd multi-platform framebuffer, OpenGL, window housekeeping, input, sound, networking, and multithreading. Embeds nicely as a static library optimized to include exactly what you need and no more instead of a big shared lib.

Build a rope computer

[smartin]

A.K Dewdney wrote a fictional account of a rope based computer in an issue of Scientific American. I always thought that it would be a lot of fun and an educational experience to try to implement a simple component, such an Adder, using the ideas in this article.

You're getting too deep :)

[DG]

I think it's entirely possible to do fun projects and lectures on low-level, hardware-based computing, without having to go into the exhausting detail, or involving the really gritty stuff like Karnough maps.

For example, most digital IC-based circuits use a +5V DC value for a logical "1". The reason why a "1" is +5V DC has to do with the contruction of the transistors used to build the gates. It's sufficient to state something like "transistors can be used as switches, and they switch between 0V and +5 V because of the way they are made" without having to get into the guts of semiconductor theory.

Similarly, one could present a diagram of a 2-bit adder circuit made of logic gates, and demonstrate that it really does add 2 2-bit numbers, even following the states of the gates inside the circuit, without showing the Karnough map that led to the circuit's design.

I envision the hands-on portion of the class using slightly more complex chips than raw logic gates. Shift registers, ALUs, small static RAM chips, and the like can be wired together fairly easily and do fun things without having to get into the undergrad stuff.

But even so, exposing kids to difficult concepts and forcing them to THINK is not a bad thing at all. School should be challenging! I'd rather see kids struggle with difficult material than have them bored with pablum.

Basic Hardware Projects

[DG]

One of the failings (that I see at least) of high school level CS classes is that they don't pay any attention to the real low-level hardware bits, down at the level of individual logic gates.

A lot - and I mean A LOT - of basic understanding of "why computers are built the way they are" comes from wiring up really basic componants, flipping some switches, and watching LEDs flash on and off.

For instance, I remember doing a project where I wired up 2 shift registers and an ALU chip to a rack of switches and 8 LEDs. By flipping the switches, one could input a pair of binary numbers into the shift registers, and then another switch (wired up as the clock) would trigger the ALU, and the resultant sum would show up on the LEDs.

After doing something like this, you gain understanding of such things as: Why do computers work in binary? How do instruction sets work? How do data busses work? What is the signifigance of the clock? And so on.

The only downside to projects like this is that you need some hardware - breadboards, power supplies, a selection of cheap ICs, a bunch of wire, and LEDs. But tinkering with this crap is just soooooo worth it - and it's fun!

Re:Basic Hardware Projects

[Amokscience]

This is actually more along the lines of eletrical/computer engineering or embedded systems programming. Mostly I don't think the HS's have the resources to teach all the background needed to fully utilize these sorta of projects (logic, boolean algebra, Karnaugh maps, state graphcs, etc).

My HS had some sort of 'advanced technology' center where people got to work with actualy hardware but for the most part CS remains entirely software based. In college I did have to take logic and circuit design but the rest of the courses (including computer architecture) were always dealing with hardware from the software viewpoint.

Re:Basic Hardware Projects

[Amokscience]

That's a cool projects page (although rather hideous) but I don't really see where "Redlight = On" teaches you anything about how computers work at the level that the original poster explained. IMO to truly understand that stuff you really need to understand gate logic and circuit design which is an entire semesters course at most colleges. In fact, at my college it was the primary weed out course for CS and engineering students. Personally I think the original poster's level of detail is too low level for most HS students, even many of the geeks.

That said these projects would definitely work in HS for HS kids. With a few thousand dollars you could build one fun tech lab. I would have really gone for this stuff in HS or even MS.

Re: Build a rope computer...or model a computer...

[Phil Gregory]

When I started on my computer science degree, the first project in computer science I was to write a series of functions to do basic mathematical calculations. The catch was that we couldn't use any math operators or external math functions, except for two simple functions, one of which added one to a number, the other of which subtracted one from a number. On those building blocks, we had to implement (IIRC) addition, subtraction, multiplication, integer division, modulo division, greatest common denominator, least common multiple, and integer exponentiation. These had to return correct values for all positive integers.

This would probably be a decent project for high school students. If the class is advanced, the parameters can be expanded. Ensure that the functions work for negative integers, too. (Not too hard, and I remember taking this step with my project just to make it slightly more interesting.) Add other mathematical functions, such as factorials or integer roots (square roots of square numbers, etc.). Add, perhaps as an additional project, the requirement of creating a rudimentary calculator with functions. There's a good bit of room for expansion; it depends on how good the students are.

--Phil (I can't remember most of the other projects I did in those classes--they weren't as interesting, I suppose.)

Emulate a Machine

[Phil Gregory]

Depending on how advanced your students are, they could write a rudimentary machine code emulator. I remember writing one of these for one of my computer science courses, and it was quite interesting (to me, at least). We were given a list of opcodes and a description of what each was to do. Our program had to assemble them, creating a file with the binary output, and then run the file.

IIRC, it was a simple assembly language. Each opcode was an int long, as were the opcode's parameters (although some parameters were floats). Space was always reserverd for two parameters, whether they were needed or not (this allowed jumps to specify the number of instructions over which to jump--there were no symbolic labels). IIRC, the main opcodes were mathematical ones. There were also load and save for memory addresses, but the addresses were always immediate--no indirect references. There were two registers.

I beleve the opcodes included

• add registers A and B, put result in A
• subtract A - B, result in A
• multiply
• divide (all numbers were floats)
• load from memory address to register (There was a space of about 16 floats for memory. memory locations were for sequential numbers--the intent was to implement memory locations as subscripts on an array of floats.)
• save to memory address from register
• put literal number in register
• jump N instructions if specified register is zero
• end program, final result (to be reported by the interpreting program) in register A

Those are all I remember. There may have been others, but those are enough to write simple mathematical test programs.

This may be a bit advanced for a high school class, but it was certainly an interesting project for me. If the students can handle it, I suspect that they will like it, too.

--Phil (The fun thing is that I'm pretty sure that I did this project before I took assembly.)

good, basic, computer science

[jCaT]

I was very fortunate to have an excellent AP CS teacher in high school. We moved fairly quickly, and by the end of the year we had studied all the common sorting algorithms, and most of the common data structures. We looked at bubblesort, quicksort, merge sort, stacks, queues, linked lists, doubly linked lists, binary trees, etc. On top of all that we did some GUI projects for kicks, like a calculator, and an application of our choice. I didn't bring away much from the projects, but all the basics- that helped me more than anything.

By the time I hit data structures in college, it was a breeze- I had already learned the stuff a couple years back. The best advice I can give is to nail all of those topics before doing any projects. It was fairly interesting, but I didn't realize the full benefit of the stuff until much later.

Re:One thing that would be good

[Zachary Kessin]

Well try to not turn them off on programing. The PHB etc does reflect reality but that does not meen you should show it to HS students.

I think the best idea is to let them come up with something on their own. Throw out a few proto ideas and let them run with it. Let the kids with the best ideas play project lead.

And if you want a pro programer to play mentor I'm sure a number of us here on /. would be happy to help.

Most importatly make it fun.

The Cure of the ills of Democracy is more Democracy.

One thing that would be good

[Zachary Kessin]

Would be to get your students used to working in groups and planning projects. If they become real world programers (or do much of anything else) they will have to work in groups and share a project.

But also the writting a functional specification on their own is a very good expierience for anyone going into any form of technical field.

Ofcourse you can then assign them something more complex and interesting.

The Cure of the ills of Democracy is more Democracy.

Re:One thing that would be good

[deefer]

And what better way to give them real life experience than to team them with their art school counterparts? Then they'd get used to being project managed by someone who can barely switch on the computer, far less use one...
Make a point of keeping your art students tired, so they'll snap at the protonerds. Once a project spec has been decided, make it an integral part of the art students role to keep the objectives changing.
And the art school project managers should never, ever thank the protonerds... Just like real life!!!

Strong data typing is for those with weak minds.

Bot wars

[bunco]

We had a "bot wars" program where you wrote a C/C++ program, and then the arena program uses the resulting executable to represent your bot in a graphical arena. There was a basic command set, and a set of rules. It was great fun. Teaches you how to program and the basics of AI. Does anyone know where I could get this? I've looked all over. I know about redcode... but ASM isn't my forte.

Some ideas

[jd]

• Micromouse Project - build a self-navigating machine which can navigate a course and learn the optimal path.
• Robot Table-Tennis - write software that can steer a robot arm, based on input from sensors, to hit a ping-pong ball in flight.
• Distributed Life - write a distributed package based on the Bugs program documented in Scientific American, allowing for "cell stickiness" and multi-cellular life.
• Emulate a massively-parallel CPU cluster, where each processor is loaded with the microcode for a unique class, and where each CPU can hold each instance of an object in an array. What would the communication between CPUs be like? How could the design be improved to maximize performance?
• Design different caching algorithms - some using basic predictive algorithms (LIFO, FIFO, etc), and others using some form of adaptive, learned cache. (eg: Most Probable Path, where you pre-load/retain information based on where you are in the code. Most Probable Access, which does the same, but based on last accessed information. Both would create their probability tables based on use.) How do simple (and therefore quick) algorithms compare to complex (and therefore slower) ones?

Procedural Thinking is good

[rho]

The hard part about programming is thinking in a sufficiently formal manner in order to carefully plan and execute a design project (like a database backed web site).

Learning SQL is a great way to start. It's fairly simple, applicable to a lot of programs (Oracle, Sybase, MS-SQL Server), and is good at teaching somebody how to think formally.

Build a database backed web service (something that would do the school good would be great, but not neccessary), maybe a school calendar. The hard parts are handled by the database program and the web server -- the fun parts can be built in modules.

Break the class into groups, and have them work on individual modules -- what data must go in, what must come out, and how it should be formatted. Then, the groups work together so the modules can talk to each other (this teaches some basic OOP-thinking as well). Then, start building. You can divide the semester into three chunks:

• Planning and organization
• Building the modules and testing
• Rewriting modules to finalize the design

Why rewrite? Well, it's not bad practice to assume that the first go-around will be thrown away as you learn new things after the first build -- you can make up for those mistakes in the rewrite.

I sure do wish something like that was available to me in HS. SQL is easier than basic, and much more useful in teaching concepts.

Project ideas

[Signal 11]

Well, there's quite abit you could try, depending on your skill level. If you're into electronics, how about making an RC car which is computer controlled? Mount a small camera on it, and then hook it up to a little short-range transmitter, and have the computer control where it goes. That'll get you a few "coolness" points.

Something alittle less adventerous might be writing a client-server app that accepts math formulas and then spools the result back out in a nice 2d/3d graph. Maybe use gnuplot as a backend? That would show that you know networking, advanced math, etc. For bonus points, write both a linux and a windows app to show you know cross-platform stuff. You could use this outside of highschool too - demonstrate it to prospective employers! :)

Okay, moving down towards simpler stuff, how about writing a program that takes all the bus routes in your area and you provide which destinations you want to go that day, and it spits out a route for you. Be sure the routes aren't hardcoded. This is the infamous "Travelling Salesman" problem in CSci. This was done way back in the 70's on the PDP-5 by a few hackers for the subway system in NY. Read Steven Levy's "Hackers - Heroes of the computer revolution" for additional historical information

Hmm.. Another idea might be to write a simple webserver. Or a chat client/server like IRC.

That should get you started.. Cheers!

Seniors

[PD]

Seniors have taken trig already, right? Maybe they've learned about dot and cross products too, right?

Have them write a simple ray tracer! Some of those kids will be thinking "why do I need to learn trig?" You can show them that they can do fun things with it, and that's a good a reason as any.

Conrad's Game of Life

[ToastyKen]

Everyone should be exposed to Life at some point. It really stimulates your thinking about emergent behavior and complexity stemming from simplicity and such things.

What students in Nome, Alaska used to do...

[TrentC]

I'm sure many of you have heard of the Iditarod -- the dog race from Anchorage, Alaska to Nome, Alaska over 1100 miles.

High school students in Nome were given an awesome project by their high school CS teacher -- we wrote the program that was used to keep track of the mushers during the race.

This was pre-internet explosion -- I'm talking mid- to late 80's here -- and we wrote the program in BASIC on our trusty Apple IIe's. It was a simple database; the users would enter a musher number, checkpoint number, time entering or leaving, and number of active dogs on the team. Once an hour we had to print off a report that was given out to the media reps sitting in Nome.

The ultimate perk was, once the race actually started, students could sign up for 8-hour shifts manning the computers at the Iditarod HQ in Nome. (Yes, even during school hours, but you had to sign up for 2 non-school shifts for every one school shift.)

About the time I graduated from school, Alascom (Alaska's big telephone corp) was using the data from our program to do the updates on their 800-number voice-messaging number. ("The current leader is Libby Riddles; her last checkpoint was in Ruby" and all that.)

Granted, we re-wrote the program from scratch every year -- not the best model if you want to teach code re-use and modularity (but then again, it was the mid- to late 80's). I suppose it's likely that, should a class totally screw off for the semester, that they'd pull an old copy off of the shelf to use. But it was a project that stimulated the creative drive of the students. Even the ones who weren't in the class; kids also helped out with feeding and caring for the dogs when they got into town. It was a real community effort.

I suspect that, since the Iditarod has become more "professional" a la the Olypmics, that this project isn't being done anymore. It's a pity.

Jay (=

Re:What students in Nome, Alaska used to do...

[Amokscience]

I would just like to say that you are one of the most fortunate bastards in the world!!! I'm rather jealous. The neatest thing I ever did in HS CS was find a non-recursive way to do Hanoi's Towers and then make that graphical =(

Man that would have been awesome to work on. (real world use, pressure to be accurate, etc)

How about have them make a parallel port DAC?

[Guppy]

How about have them put together a simple resistor ladder Parallel Port DAC? They're easy to make, and the parts are available from Radio Shack (although other places will probably be cheaper). I really don't have any electronics experience (I'm a Biology geek), but I still was able to put one of these together back in high school following a set of instructions that was included with the docs for some .MOD player. I later added a volume control and simple op-amp without too much hassle. And since I put everything on a breadboard, I didn't even have to solder.

The sound quality you can get is surprisingly good. I used mine for playing Star Control II (There's a command line switch for parallel port DAC support, I forget what it is). If this is a more programming related class, perhaps you can then have them write a few little programs that use the device.

File Transfer Program

[Lord Kano]

I'd say that you give them a loose set of rules.

It has to use TCP/IP, and it has to be easily portable to multiple OSes.

Wish list features to include download resuming, searching the host for certain file names, a GUI, chat while downloading, and et cetera.

If the program ever happens to make it into widespread use, I'd like to see the RIAA try to sue a bunch of high school kids over their school project.

LK

Re:Columbine

[HardCase]

Hey, and since Daikatana started the naming genre, I propose: Jon Katz's Hellmouth

A couple of suggestions:

[sammy baby]

• Pick a worthy open source project and try to suss the entire thing out as an assignment. Extend its functionality as a class project - for example, using ext_skel as a start, write a new module for PHP. When you're done, offer the maintainers the fruits of your students' labors.
• Think of an application that would benefit your school in general - say, a web discussion board for planning extra-curricular events - and code one up, from scratch (or from a much smaller project.

I get warm fuzzies when I see educators at the high-school level trying to make classes interesting and relevent to students in an immediate sense, as opposed to merely informative. Good luck!

AP computer science

[grappler]

I took that class the school year before last. That was the first year AP CompSci had been updated for C++ (previously it was Pascal). I was bored to tears, it was so easy. I got the test back recently (usually you don't but I sorta ran into an administrator that had it) and I had gotten every single question right, which is very unusual with AP tests, their being very hard. I know I didn't do that well on any of my other AP tests.

So that year, the AP CompSci test was just ridiculously easy. My entire class got 5's on it (the highest possible score) and a lot of them hadn't used a computer before in their life and couldn't do a lot of the assignments.

For good assignment choices, I would look at some of those programming contests that are all over the web, and definately give the kids the option of coming up with their own project if they have a good idea for one. I asked my teacher if I could skip the regular assignments because I already knew C++ and work on a program that would play Connect 4 against a human instead, and I had a great time of it and came up with a cool program.

"What a waste it is to lose one's mind. Or not to have a mind is being very wasteful. How true that is"

More information...

[sterno]

A few questions:

1) How much time can you spare to commit to this?
2) What is the experience level of the students? (I know the AP CS stuff used to be in Pascal, what is it now?)
3) What resources are available to you? For example, can you get a computer to run Linux on as a server or anything like that?

Ultimately those three questions are going to limit what you can reasonably accomplish.

---

Computers and Amateur Radio

[Ice Station Zebra]

How about having the students get their Amateur licenses and write programs for things like sending web pages over packet, or using a sound card as a packet or psk31 modem. Not only would they learn about programming, they would learn about communications too. This also tries to make up for the fact that computer science is taught in High School, but not engineering. I bet some of the ham gear makers would donate equipment for a project like this.

Look at college curricula

[ottffssent]

I'm not in high school anymore (graduated this spring), but second semester Senior year I took an introductory programming course at the university here in Madison (WI, that is--CS302, if you're interested).

If college freshmen can understand it in a semester, HS students can get it in a year, esp. if they're taking an AP CS class anyway. Check out the TA's wepbage (http://www.cs.wisc.edu/~davin/), which used to have the list of class projects, but still has useful information, including sample exams. As the fall semester progresses, he'll be posting information for his own class that you can take a look at for ideas.

Alternately, LOGO is a good language to learn. Before I get yelled at here, it's not practical to use but it's an excellent language to learn because of the way it's structured. It's simple, easy to debug, and will run on just about anything. There are versions that will run on an old Apple ][, a 386, or whatever. My personal favorite is MSWLogo (http://www.softronix.com/logo.html), by George Mills of UC-Berkeley, using the UCBLogo core developed by Brian Harvey. Yes, it's a windows program, but it's excellently done, and incredibly full-featured, and has only crashed on me about 3 times in as many years. It's got a primitive (now--it's under constant development by George Mills' graduate students and was just updated in the last version, 2 weeks ago) GUI toolkit, 3D support (check out the demos!), sound, commands to control serial and parallel ports, open files, read from the game port, etc. The language is interpreted (though compilers exist if you really want one--this defeats the purpose though), but within the constraints of an arbitrarily-sized 'page', your students can do literally anything they want.

I agree with other posters who have said that you should have your students work on their own design documents before they begin coding--this is incredibly helpful, esp. on large projects, or those they'll only be working on in class.

Top Ten Things To Teach Your Computer Class

[Randy Rathbun]

10. How to install Linux/*BSD
9. Show them the proper methods of beard grooming
8. How to dress appropriately for any occassion with only jeans and a t-shirt.
7. Teach them to drink coffee - lots of it.
6. It's never too early to turn them on to cigarettes.
5. Give them a web connection to /. and teach them to hit reload every 2.5 minutes.
4. Get them turned on to Linux and teach them to make inane comments about how much KDE sucks if they like Gnome, and vise versa.
3. Make sure they never get to bed before midnight and make them get up at some ungodly hour.
2. Give all of them pagers and call them every few hours in the middle of the night and say "My computer has a message on it that says 'Press any key to continue.' What do I do now?"
1. Teach them how to be a BOFH!

Re:An idea....

[scheme]

I did this sorta thing on my own once, and I made an AI that would always beat the random player (and not by cheating and finding the next rand() number). Theres a contest every year that people make there own AI's for RPS. people who use random never win.

According to game theory, random choices is the optimal strategy. The best you can do against a random choice strategy is to draw. In the short term, you may win due to statistical fluctuations but in the long term you will draw.

Reason why random bots lose the contest is that there are other bots in the contest that play strategies like always playing stone. Random bots don't take advantage of this and so lose points to bots who do.

Yes!

[PsychoKiller]

I totally agree. Your kids will learn about networking, administration, security, etc.

Check out www.beowulf.org and ltsp.org for more info. This is something that they can easily do in a semester (4 months?) and they can get started on parallel programming in C or Fortran. There are a lot of resources available and I'm sure they will have fun.

A suggestion for the program to write would be something that takes the student's class choices and fits them all into a nice schedule.

Alex

Re:Punch through the "Magic Box"

[double_h]

So - if I was going to teach a high-school class, I would have them make computers out of physical devices - gears, tinkertoys, or even paper.

Good idea. I can't think of a better starting point for researching this kind of exercise than learning about Turing machines. I became most enamored of Turing machines when I learned that, in theory, you could build one entirely out of, say, wood.

It bothers me somewhat that as computers become more and more complex, there are further layers of complexity which hide the dirty details. As computers continue to grow in sophistication, this process is inevitable, but it's a shame that most kids growing up with computers today won't have the same exposure to things at the chip level as was the case 15 or 20 years ago.

Not what I did

[FascDot Killed My Pr]

I remember writing a program (on a TRS-80!) that simulated those order-taking consoles at McDonald's. LAME!

Some suggestions:

1) Lego Mindstorms. Get enough of them so your can put 3-5 kids on each and have them compete (cross the room, soccer, whatever).
2) Games games games. Find out what this year's class' favorite game is. Write a (simplified) emulated version of it.
3) Simulation. Have an ongoing "physics simulator" (or something similar) project. The first year the students can do some design and basic coding. The next year they can do more advanced coding. Etc.
4) Simple AI. Do some theorem-proving AIs or ElizaBots or something.

Really, thinking up ideas for a CompSci class is as close as your nearest tech mag.
--

Re:Not what I did

[jacobm]

1) Lego Mindstorms...
2) Games games games...
3) Simulation...
4) Simple AI...


That reminds me: I think that having a class-wide RealTimeBattle competition would be awesome. RealTimeBattle kind of incorporates all of these four elements: you have a computer-simulated robot that competes with other computer-simulated robots in a simulated world where they (what else?) try to blow each other up. Really easy to make a dumb robot, really hard to make a great robot. I have always thought that RTB would be a great way to suck kids into liking CS.

IIRC, RTB is GPLed but currently only runs on Linux. On the other hand, the robots can be written in anything (server spawns child processes and talks to them via stdin/stdout) and I bet it wouldn't be too much of a trick to write a "wrapper" robot that ran on Linux and just forwarded requests and responses over a TCP connection, so the robots themselves could be running on a Windows or Mac box.
--
-jacob

Get The Knuth!!!

[Crutcher]

I wish someone had pointed me towards the Knuth when I was in high school. It is the ultimate source of CS projects, and the ultimate resource upon their theory.

The Knuth (aka The Art of Computer Programming) is available from all reputable bookstores. You can get the boxed set or just the first book from barnesandnoble.com.

You can also go to Donald E. Knuth's homepage, or to his TAOP page

Please believe, if there is a deep and magic tome of computer science, this is it, and if you will ever truly have the love for CS, then you will love these books NO MATER YOUR SKILL LEVEL! Every chapter is filled with projects ranging from in your head to graduate thesis level, and they are labeled by difficulty and mathematical requirements.

-- Crutcher --
#include <disclaimer.h>

Keep with the times :-)

[MSZ]

Like, say, tell them to write Carnivore lookalike using freely available libraries (team one) and method for passing data without detection (temat two).

--

Normal Projects+

[flymolo]

The way my first college CS tacher handled this was adding extra optional assignments to all the assignments.
TIC-TAC-TOE(experiment with 2d arrays) had the added assignment for producing a computr player for it.
Our sorting assignment for arrays had the optional assignment of replicating it with a linked list.
Our binary tree assignment had the optional assignment of implementing it in C as well as Java.
Basically you can keep the curriculum you have if it fits the low end CS Student and tack on other assignments for the more interested students. Also ask them to produce demos for a walkthrough for open house. Hand them the IEEE former problems from their programming contests.

Visit Yorktown High School Linux User's Group

[jocknerd]

Yorktown High School Linux User's Group in Arlington, Virginia is a good place to get some ideas. Those kids are getting more experience than I do in my programming job! I want to go back to High School!

No games!

[harmonica]

I've had a problem with that in our computer science course. Everybody could choose either a game or some library book database, the majority vote would be the project for everyone. I was the only one against the game and one of maybe three persons with advanced programming skills.

The project was a complete disaster -- nobody knew what the heck they were doing or where to start, the teacher couldn't coordinate the thing, I ended writing most of the code with one other guy.
I think it's best if the teacher already does the modulization (so classes in Java, units in Pascal) etc. and simply gives away the tasks. Everything else will probably fail due to inexperience in software engineering.

Punch through the "Magic Box"

[davevr]

The problem I see with most young programmers (and, surprisingly, even people out of graduate school) is that they really have no idea how a computer actually works. They can write programs, hack websites, made Quake mods, but at some level, the computer just becomes magic. Very few people now-a-days have any idea how to add numbers mechanically. Many of the CS grad students that come through my work couldn't make a half-adder out of NAND gates to save their life.

So - if I was going to teach a high-school class, I would have them make computers out of physical devices - gears, tinkertoys, or even paper. Get a simple CPU (or a simple CPU simulator) and teach machine code. Paper computers (where the person plays the role of the CPU, like the old "cardiac") were great for this. Even very young children can understand paper computers - I've taught my 6 year old daughter this way. And most smart kids (like those you would expect to find in an AP class) enjoy learning the "secrets" of how things really work.

Feel free to contact me if you want more details.

- davevr

Here's a Challenging and Stimulating Project

[IntelliTubbie]

Prove or disprove: P = NP

Good luck!
IT

Re:Here's a Challenging and Stimulating Project

[dolanh]

Obviously tralse!

..or maybe fue, now that I examine it more closely.

The question is, does ;) == :P ?

Can one find zen in a state of entropy?

try a complete web application

[Bart van der Ouderaa]

I've been reading all suggestions and most focus on programming something(even with c++, common it takes about year to properly understand OO) while CS should embrace much more
So why not do something simpler, yet still interesting. Let them design a web application. Something like a dynamic generated website.

The following things should be considered:

1. What are the requirements of the application?
2. What technology will you use (asp/php/jsp, and for db mySQL/postgreSQL)
3. how should the user interact with the site?
4. how should the interface look?
5. how will it be tested?
6. documentation
7. setting up the technology
8. creating the business code
9. learn reuse by reusing your interface design (you prototype in html ofcourse :)
10. testing the application

You can make this as simple or complicated as you want. Both good programmers and the clueless can work on this and learn (basicly because most talented high school programmers learn nothing about testing,documentation,interface and interaction design, while these are 60-70% of the struggle).

I never learned you should make a testplan before writing software(and yes I'd rather just start coding, but for industrial strenght applications knowing what to test for is better because it shouldn't depend on your design!), I won't even talk about documentation and interaction design. All because (appart from taking every CS course our university had on offer (we didn't have a CS degree course, so there are not that many and deep)) most is self taught or from courses my employer send me to.

Don't just teach them how to code

Make a MUD

[sugarman]

Well, not the whole thing. Take one of the existing codebases and have the students modify it. They can add there own parts (snippets), and it would probably allow for division into project teams.

This would let the students gravitate to the area they may be most interested in (coders, builders, whatever) and will also allow you to share ideas between more than one class (if you have one, or if the other teachers are into it).

As the actual building requires a lot of creative writing, you may want to see if some of the English teachers / students want to participate as well.

I can't speak for eveyone, but this is the sort of thing my freidns and I were doing in our spare time during highschool anyways, so why not comhine the 2?

Just don't make it too much like work =)

Let them choose.

[proboy256]

One of the best things that I've done in school is to choose a project, work on it, and get credit for it.

Work with the class to choose a project that will reinforce the AP curriculum. Then, as a class talk about the design of the application. Once you have a good modular design, create small groups to work on each small, well-defined module. Make them create the stubs so that each group can see exactly what methods they can call and what they can receive from them. Then, implement the darn thing. This teaches good design, good teamwork, and good modularity.

I think that a chat client is a good project. It involves using the network, creating a GUI, interesting data representation questions, and a plethora of different design directions they can choose from.

This was one of the most rewarding things that I did in my Intro. classes at college and it worked out very well. The key for you to remember is that it is the learning process here that is important, not the actual product. YOU are trying to get them to learn the curriculum, not to demonstrate that they already know it. If they do already know it, they will have fun coding anyway!

Have them join existing open-source projects

[Silas]

Instead of trying to create exercises or projects that will only be useful in the context of your particular classroom environment (although that could be very instructive), consider having the students sign up to work on existing open-source projects.

Even if they are contributing small amounts of code or insight or peer review or documentation, they are still benefitting themselves AND lots of others in the process.

There is such a wide variety of projects out there - just look at SourceForge and the like - that would allow students to make significant contributions to real-world projects while utilizing the principles and practice of good computer science. You would probably have to be the one enforcing that last part, but I can't emphasize enough the value of real-world experience as a complement to the AP/IEEE curriculum.

You would also have the advantage of having lots of infrastructure already set up - no need to worry about establishing project workspaces, titles, task assignments, etc...many projects will already have these in place.

Crypto -- stop laughing, no, really!

[rjh]

First, I'm a certified, certifiable cryptogeek, so I'm probably biased here. That being said:

Crypto.

The first rule for teaching (or maybe the second, right after "No matter how much they're the spawn of Lucifer, love the kid anyway") is that you don't have to teach a subject; if you can make the subject something the kid wants to learn, the kid will tear into it with the kind of unholy abandon that only teenagers can muster.

Think about the virtues of crypto, and how you can make your students enjoy it. Make it a point to teach the real stuff, not something watered-down. Emphasize that this is "military-grade" stuff [*], and that nobody--not the NSA, not the CIA, not anyone--can break these ciphers [**].

Tell the kids this, and they'll figure out pretty quickly that there are a lot of things they can do with crypto. Some of them will undoubtedly give your principal gray hair, but hey, that's the price of education. Not as if some of those Satanspawn don't already give him more salt than pepper. :)

There are a lot of ciphers which are fairly simple to sketch out on the whiteboard. I'd suggest Blowfish or RC4; both of them are exquisitely simple in theory, and straightforward in practice. There exists a lot of source code for Blowfish, at least a dozen different implementations in the public domain or Free Software, and RC4 (also sometimes called "arcfour") is almost as widespread.

You'll wind up teaching them about number theory, groups/sets, Boolean logic, the whole nine yards. You could easily spend most of a quarter writing this, and each day in class you'd cover a different aspect of computer science, along with a surprising amount of mathematics.

Crypto is a surprisingly comprehensive discipline. Good crypto libraries require that the programmer have a master-level knowledge of software engineering principles, advanced knowledge of their programming language, and sophistication in how they think about problems.

And when the kids start sending each other PGP-encrypted email over the school network, plotting the violent overthrow of the school and how to best string up their most-hated teachers from trees, you can sit there with a beatific, immensely satisfied smile and say--"Those are my kids."

If you want to know more about crypto and the classroom, feel free to drop me an email. I've got a C++ library for Blowfish which I wrote to teach some younger friends good software engineering principles--it's well-designed, with a boatload of documentation.

[*] Gloss over the fact that there is no accepted definition for "military grade".

[**] Gloss over the fact that there are easier ways to attack ciphers than by cryptanalysis. :)

collaboration and development skills

[sirinek]

First of all, if C is not being taught in your school, it should be. Second for teaching C on a non-microsoft operating system. Have a couple systems set aside running Linux or one of the BSDs that these students can use. Allow these students to spend time contributing to open source projects of their choice to demonstrate and expand on their knowlege of C programming, and distributed development.

Bill

Re:collaboration and development skills

[Tassach]

C and C++ are, IMHO, poor choices to teach as first languages. Granted, I learned C when I was in HS (on my own, mostly. My AP Physics teacher gave me some unofficial tutoring after school), but by then I had already been programming in BASIC and Pascal for over 5 years.

If I was teaching novices, I'd start with either Python or Java as a first language. They both have simple syntax (python moreso than java), encourage good programming habits, and hide a lot of needless (for a beginner) complexity.
"The axiom 'An honest man has nothing to fear from the police'

Best project...

[cr0sh]

Is a game.

It doesn't have to be a great game (don't even attempt to do an FPS - ok, maybe you could do a Battlezone clone), but it should have levels, some sound, and graphics.

Maybe funky 2D vector graphics, ala Asteroids, perhaps? Maybe a maze game, with various levels (a Bolo clone?).

The kids will learn about database creation and management (at a simple level, for the various levels), array handling, graphics (from the sprites or vector stuff), sound (for fx and music), disk handling (need to write the high score table somewhere) - maybe even networking (head to head playing - multi player too, perhaps) and AI (for the enemies, of course).

In fact, I don't think any other project would allow for as many disiplines to come into play as designing and programming a game. Just don't try for the ultimate game - some ideas:

1) Virus Hunter - Guide the nano-ship through the human body, hunting down killer viruses.
2) Dungeon Qwest - Simple 3D style dungeon, done up as line drawings (check out Dungeons of Daggorath for an example)
3) Do an Ultima clone (2d top down tile game).

The list could go on, but these three would be fun to do, and could be completed, to a good extent, by most learning students in a semester (maybe it would be a good reason to come back, and take the class again - just to finish that %$^$!? game!)...

Re:Keep the advanced students not bored

[detritus.]

I know in my case I could never have learned any programming at all if I didn't have some actual projects put in front of me as assignments.

True, however there is quite a difference between "exercise" programs and building applications that could actually benefit someone.
Even having the whole class work on different parts of a program (Like if they were developing Q3 for example: the advanced kids write the engine, some write the AI, some create the graphics, some do the sounds, and rotate as well as communicate with eachother to build a solid understanding of each part of the process).

The language is also a very big part. At least for me, I didn't want to waste my time writing apps in Visual Basic 4 - Perl seemed to grab my interest. While it's understandable that there it would be impossible for a teacher to understand every programming language fluently, a student who wishes to study up on a language himself or perhaps become an apprentince with some perl hackers should be offered.

The biggest part of programming I hated was I felt like I was seriously wasting my time. The teacher didn't know VB, we all had to sit with our faces in a book and go chapter by chapter, doing the program exercises (all he had to do was correct the tests). The programs had no point to them whatsoever - no one would ever had any use for them. My instant-messenging program, however, became incredibly useful and quite popular among the guys in the CS class to communicate back and forth when we weren't allowed to talk.

- Slash

Keep the advanced students not bored

[detritus.]

I can remember in High School I became incredibly bored with Computer Science, being I already had advanced knowledge of computers, and took it just to get an "easy grade".

One thing that I had trouble with was keeping busy - the Teacher I had was bright, but not very skillful in computers. He knew I could run the class and that scared him.

I would suggest is asking your students *what* they want to learn - some might want to learn networking, some might want to program, others repair computers. Give them research time to browse the HOWTOs and other more in-depth information.

I got into alot of trouble in my CS class and ended up dropping out because I was at the point of losing my sanity.

If the subject is programming, don't tell them what kind of program to write - just tell them to make one! This is what motivated me. My friend and I spent all of our time writing a instant-messenger over IPX (it was a Novell LAN) while everyone else was writing "exercise programs". We didn't get a grade for it, even though our program was much more advanced than the others'.

Secondly, I would put your IT department to a test. Put $50 on the table and tell them the first one to hack the school's server will get it. This is not only beneficial to your security, it will keep the kids motivated. Make them share how they did it with the class and make a "lesson" out of it. Also, keep the kids busy by having them do computer work in the school. In my school most teachers would have a downtime of over a week before their terminal was fixed. It's free help for the school, and very educational for the student(s). Pair up the smarter kids with some of the not-so-smart-but-able-to-learn kids.

Have a "LAN party" day when everyone who has a computer brings it in and setup a game of "Worms Armageddon" (in this "post-columbine world" as JonKatz would say) Doom or Quake would not be acceptable if you are worried about your job. Have them setup the network and get all the clients configured and have them go at it.

Hope these help... I wish I had these to do in High School...

- Slash

Analysis of the Human Genome

[superid]

Get the ascii data from the genome server and then do some basic analysis. Something like a histogram of basic sequences would probably be very interesting. Start with maybe a length of 10, tally up the number of "AAAAAAAAAA", then the number of "AAAAAAAAAC", etc. Then repeat for different sequence lengths. The hypothesis might be that there are sequences that occur more often than others with statistical significance, and the null hypothesis would be that they are uniformly distributed.

Obviously text processing of a 33MB data stream is pretty intensive. A simple project might just take a subset of the data. A more complex programming exercise might be to make it a beowulf-aware application.

SuperID

Re:games!!

[Devil Ducky]

I think games are a great idea. Depending on the level of interest and skill of the student, 3D games may not be the best choice.

Why not have the whole class devide into groups where each group builds an entire games from the ground up. The game doesn't have to be as hard a 3D, but it does have to be a game that they feel they know intimately. You can't build a game of Bridge if you do not know the rules of Bridge.

If they're are pretty well rehearsed in the world of programming, have them write a card game even one as semmingly simple as Go Fish, or Old Maid. That way they are pretty much sure to know all of the intricacies of the game, ubt it is complex enough to require various coding skills.

I suggested working in groups because if your school year is any where near as short as mine was in high school they won't be able to complete any interesting project in time by themselves. Plus all of the additional reasons for wanting students to work in groups.

Devil Ducky

Coming from an AP CompSci Student.

[glitch_]

Hopefully, somebody will see this even though it is rather late to get mod'ed up.

When I was in computer science, my friend and I were rather experienced in programming so we were able to design our own project. After looking through books and other projects we decided to go for a simple poker game with AI. I know that the project was simple, but it taught us alot about programming teams and modulizing code. Learning to work with other programmers on projects, is a skill that a book can't teach. We learned to divide projects and work with strengths of certain programmers. The concept is applied all over, but for some reasons school systems seem to neglect the fact that people always work with other people on projects.

Hopefully I have been of some help, and realize that there are so many skills that books can't teach, so focus in on those and let the students learn how they want to learn.

Please forgive the lack of structure...writing is not one of my strong points.

Neural Networks

[xtal]

See if any of them are interested in neural networks. It's not a beginning project, but some students are likely to have some experience with programming and AP math should be enough to get started. Here's some reasons:

• It's an area that's actively being researched commercially, and has lots of interest from academia and the public.
• The difficulty can scale from trivial to PhD Graduate work depending on how smart the students are.
• You can do useful things that interest kids at that age, like, show them how to find patterns in stock prices. (There's a book I have that does this as an example; Email me and I'll hunt for the ISBN)
• The results and propagations through the network are great for graphical representations! So you can see what's going on in a picture instead of just number crunching, and it gives the game programmers a problem: How to visualize the network? (Hint: 3D works real kick ass)
• There's LOTS of sample code and problems/learning sets to get you started.
• Not to be discounted, but a cool project might get you national or state attention.

Just some ideas. I don't think it's beyond the scope of some bright high school students.

Re:Neural Networks

[PrestoChango]

That is a really good idea. Some friends and I are playing with neural nets, and having a blast.

We decided to start relatively simple, and spec the whole thing out before we wrote any code. That took a few hours and we were able to code most of it the next afternoon.

Of course, we were all experinced programmers, but with a little guidance and a few teaching projects, a neural net is definitely possible.

Reply to this if you'd like any info on how we scaled down the complexity. We're going to try to teach it to add once we finish.

Also, check out the news group comp.ai.neural-nets. They have a lot of good material and FAQs.

Weblog

[Hard_Code]

Hmm. Create a weblog? If database stuff is too complicated you can avoid using a database and just write to flat files on the file system or something. Should be rather interesting and able to be broken up into parts, to teach encapsulation.

I.e., one group of 3 does the file storage/database structure, another does the backend scripting/programming for manipulating user accounts and preferences, and a third group does the web page scripting (jsp, perl), to take use the library provided by the second group to actually serve requests and fill in content.

So you have three layers of abstraction: content layer, logic layer, and finally data layer. Each group has to depend on the good design and encapsulation of the other groups' stuff.

Re:AP Curriculum?

[oxygenated]

I took AP Computer Science (I and II) last year and it is totally C++ based. You learn the basics of C++, but you are always using header files generated by the College Board apstring.h for text strings, apvector.h for one dimensional arrays, and apmatrix.h for two dimensional arrays. At the end of the year, we spent about three days on creating our own header files.

Perhaps my class was a bad example, but we were totally unprepared for the AP exam and the final where the teacher simply copied a practice AP exam.

Though the teacher attempted to make (somewhat) realistic situations out of the assignments, they still failed to be interesting because of the limits that were imposed upon us. If you really want to make it interesting, assign projects where the students have an open end to think of their own solutions.

What my APCS teacher did

[CrayDrygu]

Or at least, what he wanted to do...

My teacher had plans to have our class work on a program as a team. It never got past the planning stage, which was limited to exactly what I just told you, so I can't really give you details. But I can give you my ideas.

First you need to come up with an idea for the program. It should be fun or interesting (or both) so you'll keep their attention. You should probably write main() yourself, but:

Have the students write -- individually or in small groups -- the functions that actually make the program work. Each team/individual should only be given information necessary to writing their part of the program, probably limited to what inputs they need to take, and outputs they need to give. You'll probably need to write test programs for each of these functions, too.

The idea is to have everyone work on an independant part of the program, and then watch and see how their part helps out all the rest, even though they weren't involved in those parts, and probably don't even know what they're doing.

It's a great way to show how teamwork in programming can pay off.

--

I've got an original project!

[MrEd]

Build an ICQ clone!

Lord knows we need another one of those...

Coming from a High School CS Student

[valaxer]

I took AP Comp Sci last year from one the best teacher ever! He's also been around AP CompSci forever (since 1985). He is an AP Grader too. So we definitly got one of the best AP CompSci teachers there as.

As far as AP curriculum, it's all in C++. Nothing real crazy is involved. First year students need to know basic class structure, arrays, matrices, but nothing even touch pointers or data structures. We're talking VERY basic. The AP Board even makes an easy to us apstring class so that students don't have to deal with pointers in strings either. The focus is on the algorithms.

As for the second year students they get a little bit more. You learn pointers, basic data structures (linked lists, doubly-linked lists, binary trees) and learn new sorting algorithms. You still don't touch any powerful features of C++ such as the STL, class inheritance, polymorphism, etc.

To keep myself busy in that class and not become bored I used to play with the graphics package that we had. It was severely limited but I was still able to create a primitive (VERY primitive) 3d engine that could draw cubes and tetrahedrens and rotate them. Another fun activity that we did was draw fractals with recursion. You can get some unusual results especially add in color.

Well that's what my experience with AP Comp Sci is.

Changing programmers.

[ucblockhead]

Here's one project I'd give if I were a high school teacher. A lesson in the real world:

Have a simple database project that runs in two phases. Phase I is basic functionality. The project would be to get the thing working. Grade A-F.

Next, take all the B,C and D designs. Assign the D designs to kids who got A's and B's the first time around, C designs to C students, and B designs to the rest of the students. Add some new requirements, like reports that need to be run off of the database, as Phase II.

Students are then graded on how well their program meets both the Phase I and Phase II requirements.

Sadistic? Perhaps. But that would be great training for how programming works in the real world.

games!!

[ARColeslaw]

program 3d games!!! woo hoo!!

Re:games!!

[ddwalker]

How so? When I took AP Computer Science, the latter half of the second year was a game programming project (and this was 10 years ago). The first half was AP exam related, but once that was finished, we had nothing more to learn. Programming a game utilizes a broad spectrum of programming disciplines and concepts. Its perfect for school and not only that its fun. Learning shouldn't be boring.

Re:games!!

[jdwilso2]

Actually, when I was in High School (Western Guilford/Weaver Center) our rockin AP Comp Sci Teacher had groups of people learn something not explicitly covered and teach it to the class.

A friend and I decided that I would be rockin if we learned how to use the Windows API and create graphics. We created a 3D graphics program that manipulated convex polygons. We did translation, rotatation, scaling, zbuffereing, back face culling, lambert shading (flat shading), and wireframe or solid modes. And we were working on gouraud shading but never finished it. Anyway, when we taught the class Windows API and graphics (even though we tried to teach them the API, we were kind enough to provide them with a shell program within which they could insert their code). We had them all write a connect 4 program using WinAPI and graphics. Very fun. Very cool

What we did in my HS CS class...

[MJN222]

This past year I was in a CS class in which we didn't concentrate on the AP exam (we have a separate AP class for that, which I took the year before). For about half of the semester we undertook a simple (relatively) project that consisted of making the game "Battleship" for the computer, making it Multiplayer, and putting it on the Internet for people to play. We only had 7 people in the class, and of those 7 only 3 or so were really interested in the project. The difficulty in the project centered around the fact that 6 of the 7 people were learning java, the language we were coding it in, at the same time. At the end of the project, which was aborted by the teacher since we were wasting too much time, we had a semi-functional server and a workable UI design on top of a fully functional client. This was also the first year the class was taught, so everyone was sort of testing the waters. What stopped us the most (outside of apathy on the part of some students) was that the specifications were changing quite frequently. Primarily because the people programming the server couldn't figure out how to do something, and our instructor would help them, but didn't (understandably) want to do all the coding for them. This lead to the requirements becoming constantly less and less complex.

To sum my experience up; whatever project you decide to do there are a few things that _must_ be done ahead of time. A working knowledge of the language the project is being coded in, a formal specification of the project that is rather difficult to change (unless absolutely necessary) and interest in the project are all very important to the success of the project.

The problem

[NoWhere Man]

The problem with High School, and even now college is that they assume those who are taking the course don't know a thing about computers. Most of the time this is nt the case at all. Especially in high school.
(College tends to be a place of re-learning for those who come into different trades, I know, but that does not mean the rest of us have to suffer.)

I just pasted my first year of Computer Systems Technology, before that I took the first year of Computer Science. It was boring as hell. It was like being back in Grade 11 again, because everyone else had to catch up. They should really design 2 different programs.

Keeping that in mind. One of the things we barely touched on was actually how video is displayed, and how to manipulate it from the most basic levels.
And what about the hardware aspect? (Using Parallel and Serial ports). Why not create a computer controlled robotic arm from scratch? Or some other device.
Show them how computers recognize hardware from the basic levels. Get some bread boards and dip switches, make some devices the computers can recognize that they exist as a hardware component (they don't actally have to do anything however).

I think more teachers should ask the students what they would like to accomplish from the course. My electronics teacher did that this year, but he had to give everyone the same, fair chance. Originally the last project was to build a device that recognized keyboard outputs and display them on a breadboard on a few led bars or numeric display. But instead the last project was a 10 base binary counter, because most people couldn't get there timers to function correctly or kept blowing the components.
I am not saying we should leave people in the dust if they don't know as much, but the course should and can be designed around the individual student, if you plan it right.

6 degrees...

[jacobm]

My favorite beginner's CS assignment was from an intro class in college (might work for high school students too, I don't know what their ability level is). It was a simple program that read in /usr/dict/words and then was supposed to enter a loop in which it would take two 5-letter words from input and produce as output the smallest list of words that were each one letter apart from each other that went from the first input word to the second input word. So, for example:

Input
Word 1: slash
Word 2: troll

Output
slash
flash
flask
flank
blank
bland
blend
bleed
breed
bread
tread
triad
trial
trill
troll

One of the requirements was that it had to be somewhat efficient, so we had to compute the one-letter permutations of a word at most once and preferably not at all (in the case that program never needs to know).

It was a terribly fun project: it was possible for me even when I didn't have much programming experience but it made me stretch my brain a bit, and it was a whole lot of fun to play with.
--
-jacob

Re:AP Curriculum?

[Bullschmidt]

I took it in 1997 being told it was in c++, but alas, it was still in Pascal. Terribly boring, terribly easy. I think we wrote a simple database program for our project. I took the MIT software engineering course (6.170 for anyone who knows). Couple of interesting things here:

• The main focus was on engineering the system, not coding. This meant data models and modules dependancy diagrams, thinking before coding.
• We worked in teams. This meant you also had to deal with organizational issues. Not fun, but important lesson. It also requires that you develop good specs for others to work with, have a good plan ahead of time, and aren't coding on the fly.
• The projects were usually pretty interesting: One year they had Anti-chess (try to lose all your pieces, if you can take a piece you must. Also had optional AI contest), another pinball. My year it was a marbles game called abalone.

Now, I'll admit a lot of these lessons aren't necessary for the AP test. The AP test was pretty easy though (but my school only did the easy one, CS A, I think).

Important Considerations

[tarsi210]

From the: Betcha-can't-do-that-with-only-a-stick-of-gum dept.

In the course of my education there have been two overriding things that have helped me the best in learning. While these do not always point to the best way to teach, they are certainly something to consider, and many projects can stem from them.

1. Individualized Learning - Find out what some of the individual students in the class would like to learn. No doubt many of them have no clue. But some just might, and they might have neat projects in mind. For instance, when I was in HS, I sure would have liked to dabble with Apple Assembly, but of course we couldn't deviate from the pre-prescribed curriculum. I'd suggest some talking with the students. They want to learn HTML? Have them teach themselves! (individual or group, teach them to work in a software team)
2. Group Projects - Group projects, while sounding cliche-ish, are actually a good medium in which to learn technology as well as excellent people skills. So many of us are used to communicating with an electronic entity that when we have to communicate with the wetware in the world it is a less-than-ideal situation. Programming a game can be fun and educational. Everyone likes a neat game, but to actually do it, get it planned, figure out the specifics, etc., can be a big project!
3. Make It Real - If you don't make the meaning of the project apparent to Real Life(tm), students will be turned off from it. I hated abstract math when it was explained in a purely theoretical viewpoint and had no relevance to what I might use it for someday. Have them program or design a tool - recipe book, game, inventory calculator, webpage analyzer, etc. Even something silly (bubble-gum speed calculator) can teach skills and bring motivation to the students if presented correctly.

Just my $0.02 as usual. Some good considerations.

Software women like

[DoomHaven]

From personal experience, the three pieces of software that I have to kick women off to use the computer are:

Microsoft Greetings 99 (creates HallMark-quality cards)
PuzzleMaster (jigsaw puzzles)
Diablo II

IMHO, women generally like software that they can express themselves in a creative, non-violent fashion. My mother and aunt will spend hours, nonstop, making b-day cards on the computer; they just can't get enough of it. And puzzles...don't even get me started...

On the other hand, my girlfriend wants me to teach her Diablo II, and my best friend's wife and him are constantly wrestling to play Diablo II (only one computer; it's horrible. She loved Diablo, BTW). While both games are pretty violent, there are very simple and fast to learn, with an excellent rewards-based system ("leveling up"). Of course, the fact that you can "dress up" your character *may* have something to do with it...

hypo-machine

[Jonavin]

When I was in highschool (Grade 11 computer science) we did this interesting project where we create a hypo-machine. We would develop a quasi-assembly language interpreter with some simple instructions. Then we wrote some programs in this new language to show that it worked. Very simple stuff like adding and multiplying numbers and output to the screen.

It was great in teaching me how memory addresses and instructions work in a CPU. I think it's learning fundamental things like this that really helps the students understand want happens when they run a program.

AP CS Project

[Datafage]

Well, in my AP CS class, after we finished what we needed for the Ap test, we modded Quake time after time, and even taught our teacher how to play. That was even more fun, because he had said no skill was involved in these games. But seriously, Quake is written in QuakeC, which is damn close to the C++ taught in school, and the differences are simple for anyone with half a brain to figure out by just looking at the code. I know I learned a lot about both Quake and coding from that.

-----------------------

Yet another suggestion(or 5)

[Unknown Lamer]

I've just read through all three pages of comments, and my eyes burn. Lotso f htem are good ideas, but I'm going to guess 90% CANNOT BE DONE IN A HIGH SCHOOL COMPUTER CLASS! Why not? Well, at least at my school, the typing class gets 400Mhz pIIs, with lots of extras, and the programming classes have 486DX2s. Oh yeah, and they have win2k, and we get win3.1. And, the pascal class was so boring, someone cracked hte bindery and made everyone intruders(they beat me too it). But that doesn't matter. The reason it was so boring was because all we did was stupid stuff. Let's sort waffles. Sounds fun? Nope. Well, here are my suggestions(Maybe I can use my soon-to-be-founded LUG to force MY school system to do this stuff too).

1. Don't use windows. Or borland products. That will screw your students over for the rest of their lives. Give them a copy of linux and the GNU Compiler Collection. They should run fine. If you can't do that, then running windows is fine. Just try and use DJGPP with rhIDE, or Cygwin. What I wouldn't give to be taught how to make 32-bit linux programs. Since UNIX is the past and the future, why not teach them that?

2. Go above and beyond the AP curriculem. Or, allow the ones who don't need to go over the same thing for 3 weeks to move on. Networking is a good thing to teach. Networking is fun. Make them adapt current programs to, say, grab the data from a file on a remote server, and be able to save to the server. That can't be too hard, can it? Possibly teach CGI too. I would personally find that fun(hmm...index.app instead of HTML= frames on my site can stay, but users can go directly to an area of intrest)

3. Make them read source code. Just make them read some. And then try to improve it. Give them the lynx source code, and tell them to make it better. Add features. Customize it. Make it disply tables correctly. Do it with any program. If they are 2nd year CS students, give them linux to mess around with. Give them a project to write a kernel module. Start with a simple one, and then move up. Or, give them a peice of hardware that linux can't use, and see if they can make it work[although that is probably WAY above their heads]

4. Let them write a game. Quake is too adavanced. Get the doom source code, or the legacy doom source(because we all know legacy doom is better than doom). Tell them to either:
(a) Clone it
(b) Add stuff to it
Just a thought. They'd be able to learn a lot about graphics programming along the way too...which brings me to number 5:

5. Teach them / let them learn how to use Gtk+ or Xlib. X-programming fun(after the fear goes away...), but I wish somehow I could get taught to use Gtk+. It is very scary, and I don't have money to buy a book on it. I'm sure the school could pay 50 bucks for one copy to teach from. Gtk+ runs on window nowadays too, so if you have to use windows, it works too.

I hope you use these suggestion

-------------

individual creativity

[daniell]

People that age, not that I'm really that far from that age still, generally feel a need to define themselves. Such expression can take many forms, from being "good" at attending and participating in parties, dressing up for that sort of thing, to learning to play an instrument, writing material, performing on stage, creating artwork, debating and reasoning well; etc.

My highschool teacher had a very strong emphasis on allowing people to spend most of the time in various classes working on a project of their own creation using certain tools, and demonstrating certain understood concepts. Most of these projects ended up being hypercard stacks, logo or apple-soft basic programs, but they were still fun, expressive, and taught people about programming concepts.

If your students have had a chance to familiarize themselves with working in a Unix environment, then asking them to program in it would probably be appropriate to avoid frustrations involving rebooting, and restoring code.

Personally I would suggest you allow them to design simple games, something with points and scoring. I recall people made programs that played card games, did brick-out, followed some sort of sci-fi plot of chasing aliens using game-paddles and a simple sprite collision thing. At the end of the class, the games could be made available for a class day or two to all the students to play each others games. This puts a friendly amount of pressure to impress and polish while it encourages students to lean over to their neighbor and ask, "If you were using my program, would this interface make sense, or would this one?" We actually did something like this in most of our programming classes.

Breaking out some of the older tech, like paddles and apple-][s with simple, documented, peek/poke interfaces to most things really helped to make it simpler to develop something fun without frustration. While these days it may take a pretty geeky kid to be proud of a program that doesn't have menus or dialogs and doesn't multi-task, they should still have something to point at and say, "I made that."

This brings me to my second point; have them work on this project individually. They won't ask too much about the policy because its just like writing an essay or painting some watercolor paper, it needs to express the creator. Working in groups throws up too many questions when people look back and think, how much of this cool thing can I take credit for? Did I really write much of it, was it my idea? Further problems arise with common high-school lazyness that allows team members to leave the work to one dedicated person.

Recently, if your students are up to a bit of threading or whatever, I've thought that a networking project might engage them more. Perhaps something of a chat program that can handle say 5 users at once in a peer to peer chat with a very simple, specific api to which all the students can write a different program. Perhaps even writing a central server for them and specifying how communication should be handled with it, to let them each write "my-nifty-client" would keep them happy.

Of course, while most of the class time should be dedicated to writing one program of their choice, there should be a few other assigned tasks. Some simple, small, comprehension of concept programs might be nice. Also a writen test is never too bad an idea, but don't take it too seriously there or some students won't care what they write because they'll feel they can't resurect their grade from the test score. Of course encouraging students to have programming time after school may help get most projects actually done, and will help add glitter and glam to the over zealous programmer's projects.

Basically, you want them to think little about common sorts, fifo stacks and such and concentrate more on some arithmetic and random number generating fun, with use of some interface, be it text or graphics. That is if you want them to remain interested in the class. Particularly, if they have a program in mind already, they may get bored as you explain a merge-sort, because it doesn't in anyway apply to their arena gladiator simple RPG.

-Daniel

idea

[bdavenport]

this was our freshman level project in college - a giant group project, taking customer specs, writing fucntionals, technicals, then building, debugging, and turning in only an EXE.

we used C++ (or VC++ if we wanted) and tools like ErWin and iSQL.

this was for a 'group' grade, so the team was the only important part and we competed among groups.

this was one of the best projects that i was invloved in during school b/c it involved alot of time and alot of work, but the payoff was great.

the project involved a print shop and the need to have a daily printed schedule for employees to use for machine set up. the DB was to have a front end to input jobs and then a master screen to print out the days work. no crystal reports, etc. pure programming work only. print outs had to be able to be tailored to user need, ie sorted by day, by type, by materials needed, etc.

it was the prof's brother's real company and real job that had been done for his shop a couple of years earlier. the prof acted the part of his brother - we set up meetings, showed him milestones, WIP, etc. was alot of fun.

since these are AP highschool kids (my brother was one who just graduated in 2000) this is well within their reach.

Can you imagine

[Lxy]

a beowulf of these? Ok seriously. If your high school is anything like mine was, you've got labs upon labs of decently sized pentium boxen that sit unused all day long. Why not set up a beowulf project? You can set up linux to be hidden on the machines when normal classes are going on but when CS class starts, boot them all into linux and explore the world of clustering/multiprocessing. When class is over, reboot and the normal OS/networking stuff comes up so other teachers/classes are unaffected by your project. If I had known about beowulf when I was in HS, I sure would've tried it!

I grep, therefore I am

Playstation games

[mrogers]

Get them to write a Playstation game as a class project.

Dev tools and information are available online here, here and here.

The hardware's inexpensive (very cheap compared to PCs).

You can introduce abstract concepts like pointers and pipelining without boring them, because they can see where it's leading.

MIPS assembly language is quite sane, and there's an excellent text book which teaches architecture and assembly programming using MIPS.

Splitting up a large project like a game into managable chunks, then sitting down and writing one of them in C/assembler and seeing how your decisions affect the game as a whole will be a much better introduction to OO analysis and design than cramming Java down their throats.

The amount of performance you can get out of 2 Mb of RAM and a 33 MHz processor should make them think a bit about OS bloat.

Last but not least, when they finish their project they'll have something to play with.

(You'll need to fit the Playstations with mod chips if you want to test CDR copies of your game. For simpler/earlier testing a MIPS simulator is available here.)

Let them pick

[astrophysics]

Just give guidelines. If your class focuses on data structures require an array, hash table, linked list, stack, queue, red-black tree, etc. If your class is on discrete algorithms quick sort, radix sort, random number generator, etc.
If your class is on numerical techniques Romberg integration, Runge-Kutta integration, Monte Carlo integration, or whatever.

If your class is less focused, you could say they must use everything on a list, or you could let them choose one thing from each of several lists.

Also specify what they're allowed to use. For example, if they use STL, implementing a stack doesn't require understanding it. If they use a linear algebra package, finding eigenvalues of a triangular matrix is trivial. However, if they code these things themselves, it will require they understand how the algorithms work, but also require much more of their time. I guess whether you allow things like qsort is a matter of what the point of the class is and your (and their) taste(s).

suggestions

[nconway]

Since I'm currently a high school student enslaved in a school without a CS program, I've got some ideas.

• Get the students involved in the adminstration of the school's computer systems. They could also design the school's website, or possibly do some dynamic content (e.g. 'online report cards', etc).
• Optional programming contests. Like the math department at my school does, give students the possibility to write programming contests. If you're Canadian, the CCC (run by the University of Waterloo) is a good start (and not too difficult). You could also invent your own 'contest', including fun events like Remote Controlled programmable cars, Computer Jeopardy (e.g. 'What does UNIX stand for?'), Quake deathmatch (with student designed levels), etc. These were all features at a recent programming contest I went to, and it was a blast.
• Depending on how advanced the students are, you could get each to help out with the development of a Free Software project which interests them. The work woulnd't necessarily be too technical - for example, web designers could help out filing bugs and making testcases @ mozilla.org
• Try introducing the students to 'Software Development', not just 'coding' (i.e. how to design a program, not just how to use a specific programming language). If you're enthusiastic, when you ask them for a relatively simple program, get them to write out an outline, object structure, design guidelines, and then finally implement it. There are plenty of books on this (sorry I can't be more specific - I've never been taught it).
• A good bookshelf would be a good idea. Personally, I've had to buy more than 20 books, because the CS section of my school's library consists of 'Windows for Dummies'! I would definately appreciate having some reference material available at school. You could also give people class time to read (and possible write up book reports) on some of the books - depending on the level of the students, this might be too simplistic.
• Depending on your level of ability, write some code yourself (say, from a University CS curriculm), and take your students through it. I would love a guided tour of a filesystem, for instance. A more simple topic, like Quicksorts (and optimization) would be good for less advanced students.
• This isn't so much an activity as something you should be doing all the time. Critique people's coding style and design techniques. Stop bad habits from forming early - don't accept badly written or designed code. As long as the guidelines are reasonable (and don't get into religious issues like bracket placement), students will soon tire of rewriting code, and eventually learn to do things to 'write way'.

Re:Actual applications

[Amokscience]

Hehe, sounds like you teacher was very capable. I'm in daily touch with (sometimes painful) software projects that have problems so I felt I had to bring up some of the negatives. The negatives are also the entire reason why software engineering exists in the first place so it needed mentioning.

You're right though: CS wasn't just for programmers/geeks and the project makes more sense in that light. (Been too long since I was in HS =)

Re:Actual applications

[Amokscience]

You know, part of doing such a project is to limit it in scope to be manageable in the time allotted. My college software engineering course did basically what you mention except we had teams of 5-6 who bid on projects then had to actually deliver (part of the grade). Part of our job was to figure out which project(s) we were best suited and also to define exactly what we were going to do for the project. Almost always this was less than the original grand plan. We had to estimate the resorces we had, the time allotted, the difficulty of the material, our knowledge level, add in a dose of reality (unforseen delays) and come up with a neat project (usually for elementary students).

Now maybe it's not such a big deal in HS but it seems like somebody needs to notice that you guys never got anything done. That means the scope of the project must be scaled down (a real world skill) and project management has to be more efficient. Being a CS course and not a management course it seems to me that it should have focussed more on programming than managment. This *especially* in light of the huge numbers of people applying to colleges when they are not even remotely capable programmers. (In fact most colleges expect you to be a competent programmer by the time you arrive on campus)

I'm not trying to knock the class but as you progress into college and the real world not completing projects means no passing grade or no food on your plate. Granted it is decent practice for *management* activities but you won't usually be doing that for several years. Seems like your teacher was simulating the 'below average' programming project year after year. I hope (s)he pointed out how much programmers underestimate the time it takes to do a project.

Re:Ideas for projects:

[Amokscience]

BTW: If you pick programming contest do *not* choose timed contests. While they are exciting (I participated in quite a few) they don't really _teach_ you anything useful. Pick a contest that has a meaningful goal in mind like creating the neatest shell features, or smallest byte code, or fastest ray-tracer, coolest fractal algorithms, etc. (ingenuity, size optimization, loop optimization, creativity) but don't do the kind of crud like "write a minimal number of coins algorithm given the amount in cents" where the quickest correct ansmwer wins.

Speed programming turns into typing contests when the programmers are good. They learn shortcuts in proramming which is gerenally a bad habit. They also learn not to plan and think things through, etc. I think you get the picture.

Re:AP Curriculum? (Well, the test at least)

[cnj]

First off, our school had no AP CS class. A friend and I took the AB test without much (any?) real knowledge of what was to be on it (quick glimpses the day before). We took the test May, 2000.

The test is insanely easy. The only way to get a number of the multiple choice questions wrong is if you just brease through it without paying attention (easily done), the so-called ''case-study'' doesn't need to be read before hand (though you might want to, I guess).

The ''free-response'' isn't. They tell you exactly what they want you to do, step-by-step, and you just write code. It is basically a C++ test, with little to do with any ''science.''

Both my friend and I finished part II (free response) with well over 30 minutes remaining. The worst part of the test is not that it focuses more on C++ than the underlying concpets at times (I guess it does a decent job over all), but that uses a bastardized version of the STL. They AP library was supposedly written by a grad student who later stated that he really didn't do that good of a job, and that they were not completely compatible with the STL.

Anyway, to the initial question: group project desiging a game. Keeps 'em interested, helps them work in groups. I've never taken any course other than PascalII, where we basically had a study hall (all six of us). Eh.

--

OpenGL with GLUT

[given_to_fly]

First its usually pretty interesting to kids playing video games.
Second, with GLUT much of the hardwork is done for you(creating a window, double buffering.. etc)
Third its actually not hard to do some simple stuff(boxes ,spheres, etc) and make simple camera movemens and settings. you could even go into texturing and lighting but that might be more agressive.
I would have LOVED to learn a little OpenGL in high school.
go here for examples and tutorials: Opengl.org

Computer Modeling?

[cot]

Maybe some modeling of physical systems would be interesting?

There are many systems in biology and physics that are not too difficult to describe using a computer program.

Cool stuff

[Greyfox]

A decade and a half ago, the AP kids in my school in upstate New York (A suburb of Albany called Delmar) were programming recursive descent parsers in Pascal. I'd have gone into that class for my senior year if we hadn't moved to Montgomery Alabama where my only option was basic fortran.

Of course, I ended up programming a pretty complex graphing program using Apple Pascal and Turtlegraphics there, since the teacher pretty much gave us free rein for the last project of the year. What I came up with wasn't too bad at all and fit in 24 K of RAM.

Of course it really depends on the level of your students and the language they're using. You could do anything from "Do something simple with a GUI" to implementing STL classes to building trees out of XML (Parsing/Compiling is always fun) to writing simple internet servers to writing machine language emulators.

Some of your students will most likely be capable of all of the above while others may have trouble with more than the basics. A certain amount of freedom to choose what interests them is also in order. Ask them what they're interested in. You might be surprised.

game AI programming is interesting, though

[SEAL]

I bring it up because that's part of what I do for a living in the "real world" ;)

The instructor could create some sort of networked game arena, or use an existing one. Then let the students create bots to perform specific tasks, fight each other, or whatever.

You bring out a lot of creativity as they get their programs to react to various stimuli. With AI, I usually break their functionality down into a couple categories.

Senses: to detect what's going on around them.
Brain: to select a mood.
Movement: to handle going from A to B and avoiding obstacles
Tasks: each one is a specific goal / objective. Usually activated by the current mood.

Also, since this is an AP class, I wouldn't worry about the students ability -- they'll rise to the challenge. Go into detail, teaching them how to use trees and various algorithms. Pathfinding is a great way to learn different tree traversals and heuristics (A*, etc), without the boredom of your standard theory lecture.

You'll also be able to teach about stacks, queues, priority queues, and that sort of thing. But make sure you start really simple and teach the students a new element every couple days or week (day or 2 to teach, and a day or 2 to let them try implementing it). Then move on to the next algorithm or whatever.

Towards the end of the course, give them a couple weeks to put it all together and make a kickass bot. Then put their bots into a competitive arena and see how they fare :)

Best regards,

SEAL

Computer security

[Chairboy]

A real cool project would be to teach them about computer security. Eg, explain how TCP/IP works (down to the point of SYN and ACKs), then show them common ways systems are compromised and how to secure them. Knowing about computer security is becoming more and more important, and at the same time, the subject will have just enough of a 'forbidden' aspect to it to really involve the students. Just be sure to carefully work the hacker ethic into it so they don't go out and abuse their new knowledge. Who knows, you might even be able to keep a few of them turning into 3l33t h4x0r dud3z!

Some Good Ideas for High-Schoolers

[ari_j]

One really good idea is to have them program a "perfect match" program, that takes answers from surveys they can pass out and calculates the top 3 or top 10 closest opposite-sex matches for each person. This is certainly doable by people taking an AP CS course, and also has the advantage that you can sell the match lists to students or even sponsor a dance in conjunction with the exercise to raise money to cover AP exam costs. My AP Calculus class did this (as it wasn't AP CS, I got the pleasure of writing the program), and not a one of us paid for the AP exam. Another idea is the often-overlooked world of text-based gaming. Have students write some kind of text-based game...perhaps in groups or individually, or as an entire class, so they get a feel for programming in the large. Maybe even have them make it multiplayer, depending on time and skill restraints. Or perhaps have a competition for the best tic-tac-toe (or checkers if they need even more of a challenge) AI, pitting them against eachother in a class tournament.

Let *them* choose

[jmv]

Why not let them choose their project? Ask each team to submit a project proposal and check if it's feasable. You won't find a project that will please everyone anyway. You can still have a list of suggestions, from which they can choose, but let them do what they like.

CGI programming with Perl

[madmancarman]

What high school student into computers doesn't have his/her own web page? Well, teach them how to generate dynamic server-side content with Perl. If they have any experience with BASIC, Perl isn't that tough, and if they have any C/C++ experience, it's a breeze. Plus, it will teach them how to hand-code HTML.

One of my students (who I had in Chemistry and then Physics, because I won't officially teach computers until this upcoming year) worked with me for most of the school year on setting up an online attendance program using a web server running Linux/Apache and Perl. This student was already good at C++, but he got a lot of sysadmin experience, as well as learning the ins and outs of Perl and good CGI programming. Our online attendance system is now something the principal shows off to teachers and parents visiting from other districts (ie, 'look what we can do because our kids are so smart'), and the student now has real working code that he can pull out at any time for use on his future resume (he just graduated and is going into CS).

A fun side note: once we clean up the code a bit, we're going to open source it under GPL and put the code on our school's web site (http://www.hamiltonhigh.net/) for other districts to use. Nothing like an Open Source project to give students a feeling of real accomplishment if someone else is interested in their code (we've already had some inquiries from neighboring districts).

Anyway, get O'Reilly's Learning Perl book and maybe their CGI Programming book (I think most of the CGI stuff is included in the 2nd edition now, I don't know where my copy is), set up an internal web server in the school, and have them design their own system. Maybe have them collaborate to build a web-based email system a la Yahoo Mail or Hotmail.

-Chris

games games games

[cybercuzco]

I have a friend whos HS teacher gave the following assignment: Program a game. That was about it, his entry was barney blaster, which was a big hit with the rest of the class. The games were judged on their cleanness of code, the fact that they actually ran, and their playability.

Classic Video Games

[catseye_95051]

Many of the classic arcade games (Asteroids, Defender, Joust, etc) had VERY simple logic.

If you are teaching in Java (something I'd higlhly recommend) the learnign curve for simple graphics is quite low.

Thats what got ME started-- writing games (though back then theyw er text on a 12cps teletype ;) )

Teach them Lambda Calculus

[Tom7]

The lambda calculus is so beautiful; I wish someone had taught it to me earlier.

Re:Teach them Lambda Calculus

[NaughtyEddie]

Not forgetting that LISP is a very important language in modern industry.

Some ideas...

[Pollux]

It's a little hard to come up with advice, since I really don't know how far and smart your students are, but here's some brainstorms:

1) Obtain donations from your community (or ask all your students to bring in their computer if they have one) and set up a LAN in your classroom. Teach them the basics of networking, TCP/IP, and wiring different OS's to a network. For more fun, make a Linux/BSD server and hook it up. Set up a web page for your class by setting up Apache, and have them create their own webpages w/ HTML (NOT some GUI interface like FrontPage).

2) Teach the students how external prepherials communicate with the system by setting up a Linux machine (you could try it with a Win machine too, but I would think that more people would know how to program in C if you say your class is at the AP level) and building a driver for the joystick. This one might be a little difficult to undertake though, especially if no one has had any programming experience in C or has never learned logic trees for drivers.

3) This one I think everyone would love. Design a new mouse. This one doesn't have too much technology behind it, but you could really teach them some marketing and sales lessons by assigning them to get a whole bunch of different mouses together and go around in their school asking kids what designs they like, which feel better on the hand, and which are easier to use. Gather the results and have the students brainstorm different designs that they think would work based on what they learned. Create a design for a prototype.

Now, if you live in a big city, you might be able to have a company actually design a working prototype for you, and if it's REALLY good (now, I'm not making any promices here...), you could try to market it to some company like Logitech and see what they think. For a big company like Logitech to evaluate (or even better, see if they could participate) in such an event would really give a good experience to the students.

Re:games!! or at least graphics

[|deity|]

Programming can be rather dry to a highschool student. Show them something flashy, something interesting. Show them how to do some graphics programming and then do some simple game. Pong, pac-man, tetris or something similiar. If your students are not advanced enough to do something as complex as a game. Program a simple game and make it their assignment to alter the program in specific ways. Maybe program a simple pong clone then have them program a second ball, or create a scoring system for the game. That you are trying to get the students interested shows that your a better teacher then I had in highschool. I knew more about computers then any of my computer teachers did, however I was always forced to bring myself down to the same level as the rest of the class when doing assignments. Your going to have to let each student do what their abilities dictate.

a very basic video game

[Mechanik]

In grade 12, our class made Tetris clones with Turbo C++ 3.0, using Borland's dos-only, 16-colour VGA graphics libraries.

Granted, some of us were a bit more experienced than the others, and weren't wowed by learning such breathtaking new concepts as using bitmapped graphics in a program, but nevertheless, it was still extremely fun. The relatively low-techness of the thing kept it from becoming work to us, as you didn't really have to butt your head up against a wall figuring out how to go about designing the thing so much as it was just straightforward and you spent your time just coding up the details. Many of us even finished early and added all kinds of cool enhancements and new play modes to our programs.

In the same class that we made that Tetris program in, we also had to do a project. I made a nifty little encryption program (command-line or GUI, depending on how you invoked it). It wasn't very secure (replicated your password to fill a buffer, then played the game of life on the bits, then broke it up into 8 seeds to feed on each pass to srand, and then rand was used to successively generate bytes for a one-time-pad that was XORed with the plaintext), but it was pretty cool for high school, and impressed the hell out of the teacher.

I really miss those days... you just don't get to do fun stuff like that in university. Sure, coding up a module that implements a red-black tree for your algorithms class might be intellectually stimulating, but I don't think any of us would really call it "fun." Neither do you ever get to create an entire, stand-alone program, where you actually have to worry about making the thing a good experience for the user (for the most part anyway... HCI courses aside), with error checking and the whole bit. Instead you end up mostly implementing little text proggies that implement some data structures and algorithms, and your TAs run them through some test cases. Interesting though it may be, none of it has ever had the same magic of those days I spent churning out that crappy little Tetris game.

Mechanik

give them a taste of the real-world

[atripp]

Put them through the things they'll see later in life:

MONDAY: Assign some vague requirements for the project (say a sort program) and make the project due on Friday.

TUESDAY: Answer their questions about the requirements and tell them it's now due on Thursday.

WEDNESDAY: Change the requirements completely.

THURSDAY: Collect the assignments and critique them in front of everyone.

FRIDAY: Make each student add some minor enhancement to the project, but they must modify the code from the person on their left, NOT their own code.

Have each student's grade determined by the student who had to "enhance" the code, not by the teacher, and not even by whether the code worked or not.

What have you got? Re:More information please

[Stephen Samuel]

also: What do you have for software/hardware?
Macs? PCs? Do some of them have Linux loaded?

• Blatent linux plug:
• the source code from Linux can make for some good examples to work from.
• Source codes from shell commands varies in size from tiny to huge.
• Linux is also better designed (imho) for collaborative work
• the development environment is free.

As to what to do: I'd agree with the suggestion to ask them. Give them some ideas. Look for some simple (or not-so-simple) projects that the school could use. It could really turn some kids on if they could end the school year having created something that the school is actually using.

If it turns out to be so big that it becomes a team project -- all the better. Like was said elsewhere: Most real work these days is team oriented.

Above all: Don't underestimate the kids' abilities. Listen for their power. Even if they reach too far, they can learn from the failed attempt. Chances are that they'll do far more than most people would expect.

Extra Credit project,

[defaultXIX]

I heard about a fun little coding project where you try and write the smallest program that its output is the same as the code, you could give a prize or something for the person who gets the shortest.

New Mexico SuperComputer Challenge

[tmu]

My company's parent company, New Mexico Technet runs a program, in conjunction with Los Alamos National Labs called the High School SuperComputer challenge.

The web site has links to previous projects to give you some ideas about the kind of work that some of the teams have done, but overall I will say that the work is of remarkably high quality. This is a school-year-long event, so many of the projects will need to be shortened for semester-long use. They may also need to be made more simple.

As a side note, I should mention that although all of the projects can benefit from supercomputer time, the Challenge is over 10 years old as a program now. As a result, most of the projects run find on mid-range desktops (but are, neverthless, computationally intensive tasks).

More information please

[Vanders]

I could probably come up with loads. Except you don't give us a lot of information.

What is the current ability level of the students?
Is there anything in particular that you would like them to learn during the project?
How long will the students have?

One quick thought. Why not define loose parameters for the students, and let them choose something to do (in small groups)? They can learn planning that way themselves at least :)

Re:More information please

[Golias]

Windows is the "most prevalent platform" today, but by the time today's HS kids graduate college even Microsoft probably will have moved on to something else.

In my first CS class (back in 7th grade), we used the "most prevalant" system of the day - the Apple II. By the time I graduated HS, they were long gone.

For introducing the basics, I recomend UNIX (or Linux or whatever flavor you like) because the i/o and file system are very transparant and easy to teach. Even this is a small advantage, and not worth starting Holy Wars over.

Beyond that criteria, which OS you use in a high school classroom is utterly meaningless.

Re:More information please

[Golias]

As a former teacher now working in IT, I see a lot of good suggestions here... and some not so great.

It seems to me there are a few basic concepts that I would want a student to come with after his/her first computer class:

1. The basics of computer hardware, and file systems. A *n?x box of some kind seems to be the best choice for this, but you can teach the same concepts with a Windows PC or a Mac if you have no choice.

2. Programming. For an intro class, you can get by with Basic, Pascal, or even shell scripting... the point is to get the concepts of loops, conditions, and so on intot he kids' heads. For more advanced students, move on to an object based language. Don't chew your nails over the platform choice... whatever they use will be obsolete by the time they are out of college anyway. Just get them started.

3. Relational Databases. The school guidance counselor is probably telling your kids that database knowledge is a boarding pass for the Gravey Train. They should be, anyway. Again, don't worry about which platform you teach from. The concepts are very portable, and nobody really knows which database company will be the "it girl" of 2004.

4. Networking. Programming plaforms change, OS platforms change, database platforms change (I'm starting to sound like Avrey Brooks), but networking is the past, present, and future of the digital revolution. Make sure your kids understand TCP/IP, everything from the basics of sub-net masks to IP spoofing. Get down to the nitty-gritty of network file systems. Talk at length about client/server, thin clients, fat clients, terminal apps, web applets, ftp, http, ppp, and lots of other acronyms ending in "p". Give them an introduction to IPv6, the Common Language the whole world will be speaking in a few years. Bring Cisco geeks in as guest speakers. Then, once your kids are network guru's, have them promise when they get older they will remember to send you a photo of their yacts from their summer homes in New Zealand, and let you be a guest at their Florida country club once in a while.

5. Project Management. Once your kids have all the basic skills covered, it is time to let them use a little creativity to come up with their own projects and strut their stuff. If they want to design a game, fine... have them form a design team and get started. Applied knowledge is where the real learning begins.

The way things are going...

[StevenMaurer]

Start a company

Syllabus: 1] Write code that does nothing - but has buzzwords like "B2B" or "Sharing" in it. 2] Be written up in Slashdot. 3] Get VC funding. 4] Be written up in Slashdot again, with nearly identical commentary to the first. 5] Make the cover of a half dozen clueless magazines. 6] Be ignored by Slashdot. 7] Count stock options worth several billion dollars. 8] Get sued by some equally clueless industry group afraid their fat cash cow is going away. 9] Be written up in Slashdot, with more redundant commentary. 10] Pursue the lawsuit in front of some absurdly clueless judge who slaps a restraining order on the idea of "programming" because it could violate some businesses ability somewhere to make money. 11] Did I mention being written up in Slashdot? 12] Go out of business, because after all, the code did nothing.

Less financial crap. More databases.

[IAmSancho]

The subject says it.

Re:Less financial crap. More databases.

[vsync64]

Good idea. I just got started with SQL several months ago when I needed it for my job, and I've found it to be a lot of fun.

Here's a couple of other ideas:

• Have them play with different styles of programming... Procedural, functional, object-oriented. Languages such as Lisp, Prolog, BASIC, and Java would be good to illustrate similarities and differences.
• For the advanced (read: willing to tackle something challenging) students, learn 'em some real-mode x86 assembly and let them write a simple operating system. Minimum requirement should be that it boots off of a disk and does something interesting. (Note: I did this by myself in junior high, so it can't be that hard...)
• Sockets. Playing with network communication can be a lot of fun. Java, for example, has a fairly easy-to-use socket API, and pretty much any language has APIs for it.

The biggest thing is not to chain your students to a curriculum. Programming is mostly exploring, and you don't want to squash that. For example, don't say "Use SQL to create a database for Bob's Bookstore, and then use servlets and JDBC to create a simple front end. Make sure to use the following keywords or methods: ...". Say "Create a simple online ordering site for an imaginary business. Choose appropriate tools for each portion of the project, and make sure to allow for failed transactions and concurrent connections. Be prepared to explain the decisions you made in designing your system." The only problem is that you, as a teacher, have to have some idea what you're talking about as well.

Implement a Dining Cryptographers Network

[burris]

One of my favorite topics in cryptography is the "Dining Cryptographers Problem" It describes a method to broadcast messages with unconditional sender untraceability. It's very simple and the basic protocol can be carried out by people sitting around a table with a single coin. Everyone knows that high school boys are fascinated by secret codes and ciphers...

In fact, it's so simple, here is the description of the protocol from the paper. The paper elaborates on why it works and generalizes it and also includes a proof.

Three cryptographers are sitting down to dinner at their favorite three-star restaurant. Their waiter informs them that arrangements have been made with the maitre d'hotel for the bill to be paid anonymously. One of the cryptographers might be paying for the dinner, or it might have been NSA (U.S. National Security Agency). The three cryptographers respect each other's right to make an anonymous payment, but they wonder if NSA is paying. They resolve their uncertainty fairly by carrying out the following protocol:

Each cryptographer flips an unbiased coin behind his menu, between him and the cryptographer on his right, so that only the two of them can see the outcome. Each cryptographer then states aloud whether the two coins he can see--the one he flipped and the one his left-hand neighbor flipped--fell on the same side or on different sides. If one of the cryptographers is the payer, he states the opposite of what he sees. An odd number of differences uttered at the table indicates that a cryptographer is paying; an even number indicates that NSA is paying (assuming that the dinner was paid for only once). Yet if a cryptographer is paying, neither of the other two learns anything from the utterances about which cryptographer it is.

You can learn a lot about cryptography, networking, synchronization, etc... by implementing a basic version of the network.

A copy of Chaums paper is located here.

Burris

big project, little sections.

[SuiteSisterMary]

I find the best way is to pick a big, over-reaching project. Then teach by sections. You don't even need to tell the kids that they're doing little bits of a big picture.

One example that I've used, is, and I've seen it below, a physics-accurate space ship modeler. Start out with simple programming techniques. First, hardcode a distance, and a mass, and prints them out. Then it runs them through an acceleration formula, and prints the results. This shows basic flow, variables, and printf. Next, get distance and mass from the keyboard. This teaches, scanf, and equivalents. Next, get distance and mass, and use a loop structure to display velocity at every interval. Go from there. Eventually, you can add all sorts of neat things, until you manage to get what is basically a fairly accurate working simulation of the solar system, and a basic navigation system for ships. Then you add in the networking protocols, ship statistics, and combat models.... The important thing is, though, not to teach concepts. Write programs. From programming, learn concepts.

In fact, that was my project.

[yerricde]

My senior project in high school was to clone the SameGame (aka ksame; Same GNOME). What resulted was Insane Game for Linux, DOS, and Windows.
<O
( \
XGNOME vs. KDE: the game!

Re:Actual applications

[istartedi]

One person was chosen as the "VP" (the Pres was the prof), and had to manage a lot of stuff, as well as do some work

Spoken like a true non-manager.

A few ideas

[Dungeon Dweller]

1) Robotics. Robotics are cool and fun. Don't make it some complex mechanical beast requiring lots of electronics skills, since this is a computer science and not a computer engineering course, but something that the students can build in a day, and then write programs for, that is always a winner.

2) AI. Kids can write really simple AIs. It doesn't have to win the Loebner prize or anything, but think about the possibilities. You could have simple games, tic-tac-toe (I did that for a science fair project), and eliza's and word-chaining, and junk like that. People also get a kick out of talking to them. You could also go over different theories. You could go over heuristics and game theory and such, just nothing too deep.

3) Web design. People like flashy things, the web is flashy. It takes 10 mins to write a decent web page, and you can take all day jazzing it up. You could go over perl and CGI and JAVA, kids could post their work to the net. You could even work as a group to write something useful, like a page that gives the school's announcements for the day, weather, does e-mail, shows grades, shows sports schedules, the possibilities can really go wild on this one.

4) Games. Heck, half of the kids in that class probably got into it because they wanted to write a game, everything from the simple to the complex. Try writing a mud, or something graphical in nature. There are LOTS of simple projects and complex ones in this area. Students could use kits and libraries, or roll their own depending on how advanced/serious they are. This is good because the levels of effort and interest can vary, while still allowing for all students to produce good projects.

5) Graphics/3D. Do some rendering/modelling/so forth. Write programs that make cubes and such. If the kids have already had trig, then they can handle the most basic of the 3D algorithms and most of the very basic 2D ones. This is something that can be taught in bits and pieces, and you can really go step by step, if that is the kind of class that you had.

6) A few algorithms. In one of my college classes, we went out into the lawn by our classroom, and ran around forming various data structures. This is something that, depending on the kids in the class, could go over very well or very poorly. Discuss the algorithms in class ahead of time and after. It is MUCH more fun if the kids understand what is going on.

Stuff that I wish that you could go into in such a class, but really, you should stay away from.

1) Truly advanced CS topics. I am guessing that this is an intro class, and these kids have what one would call a "budding interest" in computer science, don't kill it by doing anything too difficult. Big-O notation might be something fun to mention, but evalutating execution times of algorithms really isn't an intro-level thing.

2) Algorithms galore. Teach your kids some algorithms, have fun with it, but I doubt that they are really going to be interested in the fastest way to form a binary search tree.

3) Really heavy topics. Anything that you had real difficulty understanding at first, and doesn't make a good puzzle in a book sold at airports, will probably lose their interest quickly.

Oh yeah, and grade syntax, but don't kill them over it, it's just HS.

Well, I figure that much of that, you could have figured out yourself, being as how you are a teacher and I have relatively limitted experience with kids. Hope I was at least marginally helpful. My ideas sure sound fun to me :-)

Well, DUH!

[luckykaa]

DeCSS -- If kids from Norway can do it, why can't Americans? :)

Because of the DMCA, UCITA, and the MPAA of course.

User interface...

[Malk-a-mite]

Back in high school I did a project exploring the different ways user interfaces work.
Wound up trimming it down to joysticks and what is a natural way for users to use them (i.e. - expected controls models and such).

With all the talk that hits the /. boards about interfaces and the good/bad points about them maybe that's something for your students to look at.
A fresh set of eyes on a old problem.

Malk-a-mite

Programming Ideas for HS students

[StaticEngine]

Well, here are some short program ideas that may be interesting to your average teenager. Most of them involve games, but are not game development projects themselves, until the final project. (I'm totally assuming some kind of MSVC development environment here, but it can probably be applied to whatever...)

1) Write a program that brute force solves the 12 hole Golf Tee (or peg) mindbender puzzle that you see at restraunts. It should use recursion to discover a solution for any given blank starting hole, and should print out the results in some format that can be read into another program that tests the solutions for correctness (ie. 4>1;6>4;...). Have your students show that the puzzle is solvable from every possible starting position (all 12 peg holes, altough the smart ones will figure out that you only need to test 4) using the software.

2) Have your students write an AI program to play checkers. It should take as an input a player move, then do some lookahead on possible moves, and output a resulting move, while internally updating the board state. Have students test the complexity of lookaheads vs. how often the computer wins.

3) Have students make a graphics program that allows for drag and drop pieces on a game board. Pieces should be bitmaps, and should have the ability to animate under certain conditions, and be added and destroyed (removed from the board). This will teach basic user interface programming, and event handling.

4) (simpler) Have students create a sound playback program that can alter the volume and panning of a sound based on positioning on 2D plane, so that sounds toward the top (rear) of the plane are quieter and the panning is based on the position. Sound playback should be event based, and should be able to be looped, or stopped suddenly. Multiple sounds should mix together currectly.

5) FINAL PROJECT. Have students create a game of Ogres vs. Trolls, a turn based game, where the computer plays one side, and a human plays the other. The game takes place on an arbitrary sized grid, with teams of 16-32 plus a King, and the goal is to kill the King of the other side. Non-King characters should be divided into three classes (for a Rock-Paper-Scissors type effect) and obsticles or special squares should populate the board at random. Each turn, each player has a number of spaces they can move their pieces. Combat is based on two pieces occupying the same square. Sound should be based on the above sound task. Interface should be based on the drag and drop task. The computer should do lookahead and brute force solution finding to mount it's attack, comparing warriors to move against the known rules of battle. Allow up to 5 classmates to work together on this project, and have them divy up the tasks of art, sound, AI, interface, and rules implementation. This should probably take two months to develop, if they work based on their existing code.

Good luck!

-pjf

Ideas for projects:

[Tassach]

Here are some ideas for interesting, instructive projects for AP/G&T HS Students. A lot depends on what language(s) you are teaching, the general intelligence / motivation level of your students, and where their interests lie.

• Game programming/ What kid dosn't like video games? There are plenty of games, in every genre imaginable, that have source code available. I'd start with an arcade classic like Space Invaders, Asteroids, or Missle Command -- the code is pretty straighforward and there are numerous implementations in almost any language imaginable. Analyze the code with them, walk them through building their own version.
• Relational Databases. not as "sexy" as games, but very good for real life. Have them design a DB for their music collection or address book. Teach normalization, SQL, client/server concepts, etc.
• Programming contests. Have your students write a program to illustrate some concept you've been teaching. Give prizes/recognition to the student with the fastest / shortest / most creative solution.
• Lego Mindstorms. Tons of possibilities here, if you can get the hardware. I'd imagine that Lego has deep discounts for educators.

"The axiom 'An honest man has nothing to fear from the police'

Personal Freedom

[Jason H. Smith]

I am now in college for computer science, so of course high school CS classes were a breeze. But the thing that I realized right off the bat was that, especially in CS classes, not everybody is working on the same level and at the same rate. The key to a great learning experience (in any field for that matter) is something that the student finds interesting and personally challenging. In my class, static, huge, final projects were either cumbersome and boring for the advanced students or cumbersome and difficult for the slower students. Nobody had fun.

The key to a good project, from a teacher's standpoint, is well-guided flexibility. Interest, not assignment, drives good schoolwork.

Post-College Prep Programming

[Eureses]

Like many people in AP cs, I'm sure that a lot of your students know already that they are going into other fields next year in college. Use their interest in other fields (bio, engineering, etc) to help you keep their interest in your class. Tell them to research a problem in their proposed field (should not be hard, there are plenty of books on algorithems in Pascal/C++/Fortan for scientists) of study and solve it with a program. If you're lucky they'll learn several valuable lessons from this such as:

1) computers are NOT fast enough yet to be a sloppy programmer. It's easy for me to overload almost any pc solving even a trivial problem to a few decimal places using efficient code.

2) that precision is an always present struggle. In some programs I have had to keep more than 10 or 12 places to get a solution within 5 sig figs.

3) maybe the field that they want to go into is wrong for them. Better to find that out now than their 2nd or 3rd year in college.

4) it will give them experience reading code in one language (i.e. Fortran or some other non-object orientated language that is commonly used by scientists) and recoding it in another.

5) the final write-up that you have them do will HAVE to be clear since you are not an expert in every field and may not understand what they are trying to achieve, what problem they are solving, why, or how.

6) they may discover a better way to do it. This happened to my roommate and me while writting a simulation and it was very exciting and challenging since we were the only experts on the technique.

One of my most useful and fustrating classes in college was computational physics for all of these reasons and more. I'm sure that they will enjoy it.

Less text manipulation please

[dima233]

I can still remember clearly my AP computer Science Classes from high school, and what bothered me was that the programs were mostly about text manipulation. Yes there were some more advanced concepts involved in the projects, such as hashes, etc. But they were given to us as tools, and we (almost) did not know how they worked. I found it a lot more interesting when in college I actually learned the implementation of things like hashes, and I dont think it would be too complex to teach in HS to those who are interested. And it would certainly be a lot more interesting than programming yet another "organizer".

-----------------------

A few humble suggestions

[PurpleFloyd]

I don't know what exactly you should do - I don't know your students. However, I have, from previous experience in an AP CS class, some suggestions:

1. Design is important, but not the entire focus of the class. My teacher last year had us do excruciatingly long design papers: he required a 'problem statement' for "Hello, World" (Really!). When we got into a few hundred lines of code, the design statements would reach 10 pages, and he still wanted more. This simply turned off the kids to design, and led them to extrapolate the design from the code.

2. Make the class fun. If kids are playing games, don't ban those games: they'll just hate you. Instead, show them the source for Doom or Quake. If they're interested only in browsing the Web, show them how to create a Java chatroom or a database in MySQL and Perl/PHP. Above all, keep them interested in computers and CS.

3. If there are kids who seem to be hopelessly lost, help them to question if the class is right for them. It may be they simply have trouble with a certain part of the curriculum, or they may be better suited in an art class ;-). We had wrestlers in our class who were only interested in looking at truck websites and had no idea what was going on: get kids like this out of the class.

4. Demand working code. In our class, people passed without ever turning in a single working application. When the AP test was over and we went to Windows programming, we were encouraged to design only interfaces! Don't fall into this trap: demand working code if the assignment calls for it.

In case you were wondering, my teacher was a former design consultant. He was actually hired for this reason! (Ugh!) One student passed the AP exam. I left with the same knowledge that I entered with. The class was, quite simply, a waste of time.

How About a Small Web Server?

[John_Booty]

How about having the students write a small text-based web server? At it's most basic, a web server is a really simple piece of software (if you're just talking about serving static pages).

That would be a pretty fun project, and hey... the web IS pretty darn relevant in today's world, I think. ;-)

If network programming is beyond them, then just have them write a function/method/class/etc that "simulates" a web server...ie, pass a URL string to the function, and the function will return the appropriate http content.

This is also a neat project because you can add to it as their skills progress. "Project #1" could just be a function that simulates a web server and returns a static page (teaches them how to read text streams).

Subsequent projects could add things like more dynamically-generated pages via include files and URL querystring parsing, etc.

This project would give them a good understanding strings, file i/o, text parsing, and a good grasp of how the stateless client-server architecture of the web works. Damn, maybe I should be a teacher! :-)

Games are OK, AI for games is better

[allanj]

Most people suggest doing games or improving existing ones. My suggestion is to take a relatively simple game and have them develop AI for computer players. The game can be really simple (simple cardgames for instance), but the challenge of having them compete against one another regularly (or constantly) would/could make it very popular. Or maybe AI for checkers? Very simple concept, easy to do basic AI for but really hard to make good AI for. Could teach them all sorts of good programming habits...

a few ideas...

[connorbd]

mustn't say it... mustn't provoke my inner troll... GAAAH! HOW ABOUT A BEOWULF OF THOSE?!?!?!

Okay, got that out of my system.

Actually, a Beowulf wouldn't be a terribly good idea because of budget issues, but if you could find a grant you could get away with it.

How about something like a hardware emulator? You could try Knuth's MIX or MMIX systems, or maybe design your own or copy an existing chip.

How about hacking into Minix? The code is under a BSD license now and anyone can do anything with it.

How about getting SCO's Ancient Unix license and porting Unix V6/V7 to modern hardware?

How about some Lego robotics?

Just a few ideas...

/Brian

High Schoolers

[MattLesko]

1) Try something they can do for pure hack value, i.e., just something that they can impress other Comp. Sci. people in college with.
2) Go to www.sourceforge.net and let them pick out a project to watch/join in. Nothing is more exhilarating than to know that code your writting is going to real use (even if the project justs rejects it as not good enough - but you as the teacher should help them), not just text-book examples on loops and theory.
Just my .02.

You are more than the sum of what you consume.

Re:Unrealistic!

[vsync64]

This is unrealistic. Most high school CS kids can't even program linked lists correctly!

I was doing that in junior high. Granted, I was definitely a "computer dork", but it's not that hard to learn.

You all are forgetting that these students are beginners, and that most of them aren't computer dorks!

Um, if they're taking a CS class, they had better be prepared to learn! If you were teaching physics, would you be satisfied with a student who said, "Okay, I'll learn about linear travel, but not acceleration"?

DeCSS

[PolyDwarf]

DeCSS -- If kids from Norway can do it, why can't Americans? :)

Have them write a simple computer

[GreenLantern]

I fear that we (as a society) are all forgetting how computers really work. Have them define a simple computer archatecture perhaps like the 8 bitters of the past. Then have them program a simulator for the computer. Finally have them write a simple program for the computer in machine code. I might suggest a 6502 as it's fairly simple. This project could be broken into several subcomponents so all the students would I fear that we (as a society) are all forgetting how computers really work. Have them define a simple computer architecture perhaps like the 8 bitters of the past. Then have them program a simulator for the computer. Finally have them write a simple program for the computer in machine code. I might suggest a 6502 as it's fairly simple. This project could be broken into several subcomponents so all the students would participate and progress through the various phases of design and development. If the design for the system was completed first, then the project could be broken into teams that have to work to the design spec. One could write the simulator, another the assembler and the third could write the actual code to run on the simulator.

My own ideas...

[JCMay]

My wife teaches at a very small private school here in Melbourne, Florida. Their athletic program includes a set of swim teams from grammar school through high school.

One problem they had last year involved the volunteer timers and spotters that worked at meets. Spotters would say that the first three finishers were lanes 4-5-3, but the recorded times would have them finish 3-4-5 or something. Obviously, the reaction times of the timers were not good enough to ensure proper scoring of races.

My idea was to build a small computer that would act as a multichannel lap timer. It would need fourteen inputs-- Reset, Start, and two stops for each lane, one at each end, six lanes maximum.

I wanted to use RF links to the different remotely placed inputs to reduce the wiring clutter and raise safety.

My problem was at such a small school it was hard to get the kids interested in a hardware project like this. When I told them we'd be designing computers, they thought I meant buying a motherboard and slapping PCI cards on it; I really intended to choose a microprocessor (68306 was a good choice) and build a little single-board computer. Not everyone thought that this was fun :(

Good luck in your search for interesting projects!

Jeff

Collaborative Work

[jreilly]

First, I'll give some background about myself. I AM a high school student, and I took the APCS (which has been in C++ for 2 years) this year (got a 5, meaningless but looks nice) and this is what I feel is missing from most APCS courses.

Every project we had was independent which is fine for learning the basics of a language, but (as I've found during my internship this summer) completely useless for real world programming. Something I would really have like to have done in class was a program that had to be done in several sections, each done by a different person. This way, students can get experience in how to communicate in a programming project, and how to define and stick to standards.

Let them pick.

[Chops]

By way of help, let me describe my favorite CS class - CS 201 in high school, with Ms. Bunn. I didn't learn as many facts/algorithms in it as in college classes (obviously), but it was a hell of a lot more fun, and I did a lot more work for it than I ever did in college, which some would argue means that I learned more of what's important.

At the beginning of the year, everyone picked a project -- two misguided students teamed up to write an OS, I picked a chess-playing program, someone did a database, someone did a simple BBS, someone did a symbolic math package, and so on. There were few restrictions on what you could pick, although you were encouraged to pick a year-sized chunk of work that was reasonably useful from a real-world perspective. We worked on these out of class for the year; she tried devoting class to status reports, but that was mostly useless -- who wants to hear the status of someone else's project? So she started devoting class to random CS tidbits, in chunks of a week or two. The only tidbits that really stick in my mind are a couple weeks' worth of Lisp (with most of the class being us solving in-class Lisp problems, on paper or in the computer lab) and a basic introduction to hashing. The in-class stuff was basically killing time, though; almost all the grades were from the projects. I think there was the occasional class devoted entirely to question-and-answer, also, although the saintly Ms. Bunn handled most project problems outside of class.

As I said, this was the most amazingly cool CS education I've ever gotten. In the course of finishing a project, you were guaranteed to pick up a whole lot of useful crap, but you also had the sense that you were doing something important (as opposed to the "Todaay, wee willl bee learnning aabout graaph algoorithmms..." style of education), and it was cool as hell once the projects got to the point that they were actually functioning programs ("Holy shit, it's really playing chess!") Most of the projects were structured so that there was no real stopping-place, so there was no risk of running out of work -- when I announced that my chess engine was as good as I could make it, Ms. Bunn smiled and gave me a book that described alpha-beta search, which kept me busy for the next several days continuously until it worked, and then until the end of the year trying to make it better. For the BBS or the symbolic math package, you could just keep adding features. The OS, of course, was barely begun at the end of the year, but what had been written appeared pretty sound, so I think the kids escaped without too bad a grade. I think a couple of people actually managed to "finish;" Ms. Bunn just let them slack for the rest of the year, but I could see you handling this differently.

Anyway, my advice to you is to try to separate the kids who want to take a class on CS from the kids who want to learn about CS, and then do something akin to the above for the ones who want to learn -- some of them will stun you with how much they produce when you let them produce whatever they want. Keep the class pretty small so you can keep track of each student's progress pretty regularly, make sure the students aren't afraid to switch projects if the one they're on is too hard, easy, or unrewarding, and throw good, informative books & websites at them like Mardi Gras beads -- if a student hasn't done any work for a week, it's probably because he doesn't know a certain syscall or file format.

A few more project ideas, somewhat modernized from when I was in HS: An mp3 player ("You're done? Okay, now write the encoder."), a side-scrolling one-player game, a simple web server, a corewars simulator, a packet sniffer (they'll love that), a file compression utility. None of these are completely beyond the reach of a talented HS student with a school year to throw at the problem, but they're all "real" programs, such that when people do start getting them working, they'll feel like gods. They'll also have long since forgotten that they're learning.

Client/Server from the ground up

[InfoMonk]

A neat project might be to build a client/server network from the ground up. Involving students in the hardware and software side of computing (including cabling) can be a lot more exciting than simply programming. Possibly give them a simple programming assignment to go along with it, along the lines of testing the network or interacting with a database on a remote computer. The first time I crimped my first cable and brought up the interface with a successful ping, I was hooked. I truly believe that programming lacks excitement until the network is brought into the picture.

Casino games.

[Chiasmus_]

I don't know how acceptable this would be in the high schools, but the applications that taught me the most programming theory were casino games.

I managed to pull off Keno and Blackjack. They were a lot harder than they seemed. Keno required a graphical interface with the ncurses library that was probably harder than most menu interfaces you'd see, like pine or capt. Blackjack was a little easier, except programming in things like split, double down, and insurance, which was a headache.

My friend pretty much catapulted himself from novice programmer to experienced programmer in two weeks with Deuces Wild. Now that one was a nightmare. Not only did he become obsessed with randomizing and shuffling the deck, but the algorithm for determining the final hand was incredibly complicated. To make matters worse, he insisted on testing the thing on a 4 megahertz machine from about 1986.

Anyway, I've written a lot of worthless software, but nothing has been as useful later as casino games.

Code small projects using knowledge other'n coding

[kadath23]

Try to get students to use what they're learning in math/physics/etc classes. Also introduce stuff that they might not know but can readily learn and experiment with using their programming expertise.
I recommend Neural Nets, Cellular Automata, Genetic Algorithms, Cryptography, Compression, etc. Basically the stuff you might find in an overview of Cybernetics.
Sound, sight and insight are all excellently rewarding results. (Graphics, music, etc.) Example: a project using a genetic algorithm for optimizing a collage theorem based image compression algorithm.
For exposure to large projects, don't start from scratch, but grab something with free source and modify it.

Programming Contests

[White Shadow]

ACM has a intercollegiate programming contest each year; here's an archive of old problems: Problem Set Archives. Granted that the question is for high school students, but there are still problems easy enough for high school students to do. You could also tweak some of the problems to make the easier. To do the problems, you could either assign them as homework, or better yet, you could run a mock tournament. Make teams of 3 students with one terminal per team and give them a few problems to do. This probably wouldn't work in a single class period, but I think it's fun as a weekend activity. Also, if you look around, some of the colleges nearby might run a programming contest for high schoolers. I know that those of us who go to the ACM programming contest from Miami University of Ohio, also host a contest for high schoolers each spring.

Help Us out

[cvd6262]

Put them to work on the Mozilla release. :)

Hardware Stuff - Build a Computer and a Robot

[BigBlockMopar]

If you have any measure of electronics skills and a good crop of kids in the classroom (which they probably are, if they're bored), try building something neat with them.

When I was in high school, one of the things I built was a small computer.

Nothing fancy, all you need is an empty piece of Veroboard or some other prototyping bits (even Radio Shack has it), a Z80 processor, some RAM chips, and an EPROM programmer.

The part of the class that is good with their hands can assemble the computer and get the hardware done. (A few chips, none with more than 40 pins, it will take them a few classes, but not too long.) The rest of the class can punch in an assembly language program that you can provide on paper (find it on the 'net, or write something quickly), assemble it, then burn it to an EPROM.

From there, you can plop the EPROM into the hardware department's product, turn it on, and either have it work, or not. <grin>

And then there's other stuff...

When I was in high school, I built a small robot arm. It was controlled by my old TI-99/4A, which used to write information to the parallel port. I used the 4 MSB (most significant bits) of the parallel port's 8 bit byte to select a given motor on the arm, and the 4 LSB (least significant bits) selected the operation: Hold, forward one step, backwards one step.

Of course, used in this manner, I could have controlled a lot more motors, but my technology at that time was primitive!

Feedback to the computer on arm position was done by using the keyboard. When the arm reached one limit or another, a switch was triggered, and that switch was in parallel with a key on the keyboard.

All the programming was in TI-BASIC, loaded into the machine from a cassette. I could make the arm do certain movement by "printing" a character to the parallel port. When the arm reached a limit of motion, the TI-BASIC "CALL KEY" instruction, which would test for key presses, detected it. A loop of printing instructions and then checking the values returned by CALL KEY gave it full feedback and allowed the robot arm to pick up objects without crushing tem, move them precisely, put them down, and even return to pick them up from the same place as it put them down.

Of course, there was no practical use to this setup, but it was cheap and easy to build: a few surplus stepper motors from old printers, a power supply, a homebuilt stepper motor controller. The arm itself was a drawer rail (allowing for in and out movement on one axis) with a piece of picture hanging wire on the shaft of a motor to turn the rail in and out. The gripper was made with Mechano and operated on another stepper motor. And there were pivots for the gripper, the base of the arm and the angle of the arm, all built with junk and stepper motors.

It was fun, and it was thoroughly useless. But it was something that my friends liked to play with when they were at my place, so I think a classroom might enjoy it. I wrote routines for it that would put pepper onto dinner, or ketchup onto a hot dog, even put a battery into a radio. Of course, all those things have to be in exactly the positions where the robot thinks they are, before it can manipulate them.

Of course, today, you could use an XT as a controller; you wouldn't need to worry about waiting for cassette-based programs to load.

Actual applications

[egerlach]

My OAC Computer Science course (OAC=Ontario's Grade 13) consisted of, among other things, a term-long project for the entire class, which was learning about how to, and creating, a full-blown application.

At the start of the term, everyone in the class applied to "jobs", with resumes and everything. According to what you applied for, and how you presented yourself (not necessarily your skillset), you got certain jobs. One person was chosen as the "VP" (the Pres was the prof), and had to manage a lot of stuff, as well as do some work. We had three departments: Coding, UI, and QA (whose job it was to make the coders and the UIs co-operate). There were department leaders, and then inside the deparments, if there were special task forces, they had team leaders, and so on. Basically, our prof tried to make it as much like a company as possible. It was a lot of fun. No class (to my knowledge) has actually completed the project, but it's the process that's important.

For me, it was really helpful to learn how to work well in teams, and how the real world operates. It was a lot of fun, and I think you learn more than doing games, or anything like that.

So the kids can get a taste of the Real World

[linzeal]

Don't let the high school programmers decide what to do, let the student body choose what they want the programmer's to do.

Metal shop could ask for a simple CAD program to aid in designing projects.

AP physics could ask for a RT physical modeling program.
etc........

Integrate projects with technology students enjoy

[arnie_apesacrappin]

I think a fun project would have something to do with what the students already enjoy doing. Take an application that supports plugins (like WinAMP) and have them create plugins to do stuff they think is cool (like output visualization).

If you want them to do something helpful to the community, try something from the unmaintained free software project. Or try to create a helpful windows tool.

At the high school level, I think integrating fun with programming will probably help future computer scientists a great deal. If you can pique their interests now, learning operating system design in college might not be so bad.

As for suggesting specific projects, what languages do you use, and what kind of things do your students find boring? That might get the ball rolling.

And on a personal note, I thought that creating a graphical output to the Towers of Hanoi problem was fun (insert geek jokes here), and it helped me to understand recursion.

Just another Idea

[Billed_190]

Get them to design a new set of protocols for something fairly well-known, such as email, or maybe a new set of file transfer protocols

Then have them write a program in whatever language they wish that will provide basic funtionality for the protocol

Sorting Graphically

[DarrinWest]

The project that got me started programming for real was a graphical representation of sorting algorithms:
- bubble sort
- shaker sort
- shell sort
- quick sort
- etc.
The graphics could be student created, if you wish. What I did was plot the element's current list location on the X axis, against the element's value on the Y axis. Initial condition looked like fuzz. When sorted, it looked like a diagonal line.

This gets the kids learning algorithms, has some graphics, has instant gratification, provides insight into the workings of the algorithms...

BTW, the idea was based on an old 35mm movie of such algorithms. I believe it also included the famous "mouse traps and ping-pong balls" demonstration of exponential growth.

Good luck.

An effective troll filter

[blameless]

The /. admins would be grateful.

This is a great question

[pianoman113]

It is encouraging to see that there are other computer science teachers out there (other than my own) who care about keeping an interest with students. Some projects we did included card games, puzzle games, and connect-the-dots games similar to tic-tac-toe. The year after I graduated, the CS department added another class which focused on Java and Visual Basic development. One suggestion I have is database interaction, such as SQL integration.
Another is to participate in an open-source project. It doesn't have to be kernel hacking, although that could be offered as an advanced class, but something that they can see in the real world. I still remember the sense of accomplishment I felt when I finished my first REAL project in class, a game called Connect Five. It felt really great to experiment with C++ to learn dynamic memory allocation and pointer handling almost a year ahead of time. I can't think of a better way to encourage that and put your class on the map that by participating in a real project.
One other suggestion is to use real tools. Obviously, most open-source projects are in Linux. I don't know what environment you are currently using, but the Unix environment is what is used at the University level, so I see a real need to familiarize your AP students with it. Get them used to using the GNU compliers, that is what we use at my college. If you are tied to Windows, make use of MFC. The value of being familiar with MFC in today's marketplace in amazing. It is an excellent way to reinforce OOD principles.
Again, I encourage you to seek out anything that will challenge your students and provide them with a real sense of accomplishment.

Tons of projects

[Fryed]

I'm a high school student, and I can think of plenty of projects I'd enjoy doing at school, many of which have been mentioned on Slashdot. I don't know if these would be appropriate for your class, but they're interesting computer-related projects:

WWWPic2 mentioned here a few weeks ago. This would also include building the Picprog Pic programmer.

Or what about building the Flash Carts for Gameboy, mentioned here.

Do the students at your school use TI-8x calculators? If so, there's lots of oppurtunities at Ticalc.org.

I hope you find some of these ideas useful.

Instant messengers.

[johnnyQuaint]

If your students are learning easy languages like Visual Basic or delphi, writing an instant messenger would be interesting for them. This is software that they use, but probably regard as being difficult to make. When all they have to do is set a few properties, they will be pleasantly suprised. And considering that they will be programming for the internet in any case ..... -John.

Entertaining is good

[evanbd]

What level of comp sci matters a LOT. I'll answer assuming intro classes, because that's probably hardest. While ideally the program should be entertaining to write, one step is to make something that is (at least somewhat) entertaining to use. Programs that play some game are good. In some sense, however, these don't emphasize basic concepts, like sorting an array or whatever, but they can instead emphasize things like algorithm design, which is at least as useful, IMHO. For example, a program that plays tic tac toe, while theoretically simple (we all know how to win this one, right?) can require some thought to implement efficiently. So the assignment becomes, 'write a perfect tic tac toe program'. This requires so little CPU power, it should be a requirement that it run very very fast -- but it won't if you don't put thought into it. Also, some kind of contest is a good idea. There was a piece on Slashdot a while back about a RoShamBo (rock/paper/scissors) contest, but that more emphasizes game theory and the like than programming. perhaps something like battleship or 3D tic tac toe (4x4x4, get 4 in a row). I think interest often has less to do with the program being challenging to write than haveing there be a purpose to the program. No one will be able to convince most students that there is any reason to sort this array using that algorithm; But if it does something, that's interesting. Conway's game of Life is also good, and fun to play with when you're done.

---

Suggestion

[bigginal]

One suggestion I have for a VERY complicated programming project is a bot for the hugely popular AOL Instant Messanger (or you could even port it to ICQ...). However, this bot should be able to use AI to intelligently respond to questions and such...I am thinking of a conversation like this:

Questioneer: Hello.
AIMBot: Hello. My master is not available at the moment, but feel free to talk to me, an artificial intelligence!
Questioneer: Alright. So where is your master?
AIMBot: My master is using the restroom.
Questioneer: And when will he be back?
AIMBot: He should be back in a few minutes.

...

This is just a sample of what is available with today's technology. And I know someone who is currently working on something like this...check out the AIM screenname AIMPerlBot, and you will actually be able to talk to the work in progress.

But this is just an idea. Feel free to pick it apart...

Bigginal

Combine with community service

[platos_beard]

Ask your favorite local community service organization if they have any thing they can think of. I'll bet they can.

Not only is this genuinely useful (potentially anyway), but it can cover the whole gamut of techie issues from procurement (begging local companies for unused computers?) on.

Installation and network set up.
Some app development.
Maybe web/internet/intranet development.
User training and education.
System documentation.

You name it, some worthwhile outfit nearby could probably use it.

Porn filter

[DunkPonch]

Sure, it won't work. But you'll be able to sell it to the administration easily. Best of all, you'll have no trouble finding kids who want to do research.

contest problems are fun, & fractals

[lightray]

A good source for concise, challenging programming problems is the archives of past ACM programming contests. Take a look at The Annual Berkeley Programming Contest. While during the contests, the only metric that matters is whether your program generates the correct output for the given (unknown) input, many of the problems raise issues that can be debated in more depth: what is the easiest solution to code? what is the most elegant approach? what is the most efficient? What are the strengths and weaknesses of using C, C++, or Java as the implementation language? etc.

When I was learning to program, my favorite source sof programming inspiration were popular math books, eg The Mathematical Tourist by Ivars Peterson, and the Amateur Scientist and Mathematical Recreations columns of Scientific American. I'd implement simulations of percolation; Conway's game of life in one, two, three dimensions; plot the Mandelbrot and Julia sets; iterated function systems fractals; simulating preditor-prey models; simulating the spread of a disease or forest-fire. Of course, all of that was on DOS using Turbo Pascal. Now that access to networked unix machines is so widely available, there are many new opportunities (eg, for network-related stuff) available.

Good reading material is a very important source of challenges, problems, and insight into computer science as a science. I'm thinking particularly of the famous Structure and Interpretation of Computer Programs, the textbook used in freshman computer science cources at MIT and University of California, Berkeley. The book demonstrates clearly that there are multiple approaches to problem solving, each with its advantages and disadvantages; SICP also convinces the student of the beauty and power of high-level abstraction.

-- Tobin

A real software project

[rackhamh]

Identify a software tool that the school doesn't have, but could use (e.g., class discussion boards and/or chat), and work with the class to implement a solution. Your students will learn programming and group skills that are more applicable to "real world" programming, and if all goes well (with your guidance) have the benefit of seeing their work put to use (unlike many programming assignments of the "everything you ever possibly wanted to know about doubly-linked lists" variety). Good luck!

- Rackham

"You can't protect anyone.... You can only love them."

Teach a real programming language

[Dopefish_1]

I don't know about other schools out there, but my HS only taught Pascal, and later added a rudimentary C course. I would vote for teaching something like Perl or Java as well.

Teach OpenGL

[James Irving]

I taught a bit of introductory OpenGL to grad students at UNC-CH, and now I'm recycling the lessons for a 14-year-old who I'm tutoring. He is a beginning programmer.

Most introductory programming books use console I/O because it's universally available. OpenGL is pretty nearly universally available, and lets kids jump straight into graphics (2D or 3D) and animation with a minimum of fuss.

Hopefully you could buy copies of the OpenGL Programming Guide to supplement whatever textbook you are using. It's an excellent tutorial for OpenGL specifically and 3D graphics generally.

Setting up OpenGL

opengl.org