Forgot your password?
typodupeerror
Education

Ideas for High School Computer Projects? 633

Posted by Cliff
from the slashdot-does-curriculum? dept.
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?
This discussion has been archived. No new comments can be posted.

Ideas for High School Computer Science Projects?

Comments Filter:
  • by 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
  • by 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
  • by 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...
  • by Anonymous Coward on Wednesday August 02, 2000 @11:20AM (#885302)
    Oh, so that's where they recruited the Mozilla team.

    *DUCK*

  • by Bill Currie (487) on Wednesday August 02, 2000 @09:51AM (#885306) Homepage
    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 :)

  • 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!

  • http://www.libsdl.org/ [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.

  • A.K Dewdney wrote a fictional account [rustrans.co.uk] 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.
  • 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.

  • by DG (989) on Wednesday August 02, 2000 @09:29AM (#885313) Homepage Journal
    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!

  • 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.)
  • 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.)
  • by jCaT (1320) on Wednesday August 02, 2000 @09:05AM (#885318)
    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.
  • 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.

  • by Zachary Kessin (1372) <zkessin@gmail.com> on Wednesday August 02, 2000 @09:00AM (#885320) Homepage Journal
    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.

  • by bunco (1432)
    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.
  • by jd (1658)
    • 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?
  • 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.

  • 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!

  • by PD (9577)
    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.
  • 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.
  • by TrentC (11023) on Wednesday August 02, 2000 @09:11AM (#885347) Homepage
    I'm sure many of you have heard of the Iditarod [iditarod.com] -- 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 (=
  • How about have them put together a simple resistor ladder Parallel Port DAC [mediaone.net]? 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.
  • 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
  • Hey, and since Daikatana started the naming genre, I propose: Jon Katz's Hellmouth
    • 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 [php.net]. 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!

  • by grappler (14976) on Wednesday August 02, 2000 @09:43AM (#885361) Homepage
    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"

  • 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.

    ---

  • 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.
  • 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.
  • 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!
  • 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.

  • 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
  • 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.

  • 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.
    --
  • 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 [barnesandnoble.com] or just the first book [barnesandnoble.com] from barnesandnoble.com.

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

    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>
  • Like, say, tell them to write Carnivore lookalike using freely available libraries (team one) and method for passing data without detection (temat two).

    --
  • 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.
  • Yorktown High School Linux User's Group [tux.org] 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!
  • by harmonica (29841) on Wednesday August 02, 2000 @11:48AM (#885424)
    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.
  • 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

  • by IntelliTubbie (29947) on Wednesday August 02, 2000 @09:26AM (#885426)
    Prove or disprove: P = NP

    Good luck!
    IT
  • by Bart van der Ouderaa (32503) on Wednesday August 02, 2000 @11:18AM (#885428)
    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

  • by sugarman (33437) on Wednesday August 02, 2000 @09:08AM (#885432)
    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 =)

  • 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!
  • by Silas (35023) on Wednesday August 02, 2000 @09:07AM (#885440) Homepage
    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.

  • by rjh (40933) <rjh@sixdemonbag.org> on Wednesday August 02, 2000 @09:38AM (#885447)
    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. :)
  • 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

  • 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!)...
  • 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
  • by detritus. (46421) on Wednesday August 02, 2000 @10:21AM (#885457)
    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
  • Get the ascii data from the genome server [nih.gov] 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

  • 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
  • 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.
  • by xtal (49134) on Wednesday August 02, 2000 @09:08AM (#885463)

    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.

  • 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.
  • 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.

  • by CrayDrygu (56003) on Wednesday August 02, 2000 @09:24AM (#885471)
    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.

    --

  • Build an ICQ clone!

    Lord knows we need another one of those...

  • 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.
  • 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.
  • 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?
  • program 3d games!!! woo hoo!!
  • by MJN222 (66958) on Wednesday August 02, 2000 @11:00AM (#885492) Homepage
    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.
  • 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.
  • by NoWhere Man (68627) on Wednesday August 02, 2000 @09:12AM (#885499) Homepage
    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.

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


    That reminds me: I think that having a class-wide RealTimeBattle [lysator.liu.se] 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
  • by jacobm (68967) on Wednesday August 02, 2000 @09:41AM (#885502) Homepage
    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
  • 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).

  • 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.
  • 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...
  • 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.
  • 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.

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

  • 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

    -------------
  • 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

  • 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.

  • 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
  • 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.

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

    Dev tools and information are available online here [execpc.com], here [psxdev.de] and here [consoledev.com].

    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 [mkp.com] 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 [wisc.edu].)

  • 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).
  • 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 [uwaterloo.ca] (run by the University of Waterloo [uwaterloo.ca]) 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'.
  • by Amokscience (86909) on Wednesday August 02, 2000 @10:12AM (#885551) Homepage
    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.
  • by Amokscience (86909) on Wednesday August 02, 2000 @10:31AM (#885552) Homepage
    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.
  • by cot (87677) on Wednesday August 02, 2000 @09:00AM (#885561)
    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.

  • by atripp (104393) on Wednesday August 02, 2000 @11:30AM (#885595)
    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.
  • My company's parent company, New Mexico Technet [nm.org] runs a program, in conjunction with Los Alamos National Labs [lanl.gov] called the High School SuperComputer challenge [nm.org].

    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).

  • by StevenMaurer (115071) on Wednesday August 02, 2000 @09:18AM (#885612) Homepage

    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.

  • 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.
  • by Malk-a-mite (134774) on Wednesday August 02, 2000 @09:00AM (#885665) Journal
    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

  • by Tassach (137772) on Wednesday August 02, 2000 @09:19AM (#885672)
    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'
  • by MattLesko (155081) on Wednesday August 02, 2000 @09:05AM (#885715)
    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 [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.
  • by Chops (168851) on Wednesday August 02, 2000 @10:08AM (#885744)
    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.

  • by Chiasmus_ (171285) <ayatollah_hyperbole&yahoo,com> on Wednesday August 02, 2000 @09:03AM (#885751) Journal
    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.
  • by Golias (176380) on Wednesday August 02, 2000 @12:31PM (#885764)
    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.

  • by Golias (176380) on Wednesday August 02, 2000 @09:49AM (#885765)
    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.

  • by BigBlockMopar (191202) on Wednesday August 02, 2000 @10:40AM (#885798) Homepage

    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.

  • by egerlach (193811) on Wednesday August 02, 2000 @09:10AM (#885802)
    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.
  • by johnnyQuaint (206406) on Wednesday August 02, 2000 @09:00AM (#885838)
    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.
  • by rackhamh (217889) on Wednesday August 02, 2000 @09:04AM (#885894)
    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."

  • 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.

UNIX was not designed to stop you from doing stupid things, because that would also stop you from doing clever things. -- Doug Gwyn

Working...