I'm about to start (with fellow programmers) a programming & algorithms club in my high school. The language of choice is C++ - sorry about that, I can't change this. We can assume students have little to no experience in the aforementioned topics.

What do you think are the most basic concepts I should focus on?

I know that teaching something that's already obvious to me isn't an easy task. I realize that the very first meeting should be given an extreme attention - to not scare students away - hence I ask you.

Edit: I noticed that probably the main difference between programmers and beginners is "programmer's way of thinking" - I mean, conceptualizing problems as, you know, algorithms. I know it's just a matter of practice, but do you know any kind of exercises/concepts/things that could stimulate development in this area?


Pseudocode should be a very first.

Edit: If they are total programming beginners then I would make the first half just about programming. Once you get to a level where talking about algorithms would make sense then pseudocode is really important to get under the nails.

Jacob T. Nielsen
+2  A: 

Linked lists - a classic interview question, and for good reason.

Airsource Ltd
+2  A: 

I would try to work with a C subset, and not try to start with the OO stuff. That can be introduced after they understand some of the basics.

Lance Roberts

The content in Deitel&Deitel's C++ programming is a decent introduction, and the exercises proposed at the end of each chapter are nice toy problems.

Basically, you're talking about: - control structures - functions - arrays - pointers and strings

You might want to follow up with an introduction to the STL ("ok, now that we've done it the hard way... here's a simpler option")


Start out by making them understand a problem like for instance sorting. This is very basic and they should be able to relate quite fast. Once they see the problem then present them with the tools/solution to solve it.

I remember how it felt when I first was show an example of merge-sort. I could follow all the steps but what the hell was I for? Make then crave a solution to a problem and they will understand the tool and solution much better.

Jacob T. Nielsen
+10  A: 

Make programming fun!

Possible things to talk about would be Programming Competitions that either your club could hold itself or it could enter in locally. I compete in programming competitions at the University (ACM) level and I know for a fact that they have them at lower levels as well.

Those kind of events can really draw out some competitive spirit and bring the club members closer.

Things don't always have to be about programming either. Perhaps suggest having a LAN party where you play games, discuss programming, etc could be a good idea as well.

In terms of actual topics to go over that are programming/algorithm related, I would suggest as a group attempting some of these programming problems in this programming competition primer "Programming Challenges": Amazon Link

They start out with fairly basic programming problems and slowly progress into problems that require various Data Structures like:

  • Stacks
  • Queues
  • Dictionaries
  • Trees
  • Etc

Most of the problems are given in C++.

Eventually they progress into more advanced problems involving Graph Traversal and popular Graph algorithms (Dijkstra's, etc) , Combinatrics problems, etc. Each problem is fun and given in small "story" like format. Be warned though, some of these are very hard!

Edit: Pizza and Soda never hurts either when it comes to getting people to show up for your club meetings. Our ACM club has pizza every meeting (once a month). Even though most of us would still show up it is a nice ice breaker. Especially for new clubs or members.

Our supervising teacher would literally kill us if we brought food into CS classroom. ;)
Mike Hordecki
Mike Dunlavey
I agree that you should stay away from data structures and algorithms, but the abstraction of OO programming used to fascinate me as a non-programmer. I couldn't fathom how a screen full of text could turn into these strange "objects" that could communicate with each other, but I desperately wanted to find out.

I think your club should include two parts.

The first one would be strictly for algorithms. There you could teach them simple algorithms like floodfill. But you should absolutely also show them more useful ones like Dijkstra. There are numerous other tree-based algorithms that one should absolutely know. (BSF, DSF, ...)

Then there should be a more fun part in which you create simple GUI or web applications, something that can be used to build applications directly and to learn the C++ language.


start out with a simple "hello world" program. This introduces fundamentals such as variables, writing to a stream and program flow.

Then add complexity from there (linked lists, file io, getting user input, etc).

The reason I say start with hello world is because the kid will get to see a running program really quick. It's nearly immediate feedback-as they will have written a running program right from the start.

Stephen Wrighton

IMO, Big-O is one of the more important concepts for beginning programmers to learn.

Hank Gay
Definitely. Although I wouldn't consider it fun enough for easily scared wannabe programmers :)

Have a debugging contest. Provide code samples that include a bug. Have a contest to see who can find the most or fastest.

There is an excellent book, How Not to Program in C++, that you could use to start with.

You always learn best from mistakes and I prefer to learn from some else's.

It will also let those with little experience learn by see code, even if the code only almost works.

Jim C

In addition to the answers to this question, there are certain important topics to cover. Here's an example of how you could structure the lessons.

First Lesson: Terminology and Syntax

Terminology to cover: variable, operator, loop (iteration), method, reserved word, data type, class

Syntax to cover: assignment, operation, if/then/else, for loop, while loop, select, input/output

Second Lesson: Basic Algorithm Construction

Cover a few simple algorithms, involving some input, maybe a for or a while loop.

Third Lesson: More Advanced Algorithm Topics

This is for things like recursion, matrix manipulation, and higher-level mathematics. You don't have to get into too complex of topics, but introduce enough complexity to be useful in a real project.

Final Lesson: Group Project

Make a project that groups can get involved in doing.

These don't have to be single day lessons. You can spread the topics across multiple days.

Marc Reside

Thanks for your replies!

And how would you teach them actual problem solving?

I know a bunch of students that know C++ syntax and a few basic algorithms, but they can't apply the knowledge they know when they solve real problems - they don't know the approach, the way to transcribe their thoughts into a set of strict steps. I do not talk about 'high-level' approaches like dynamic programming, greedy etc., but about basic algorithmic mindset.

I assume it's just because of the poor learning process they were going through. In other sciences - math, for example - they are really brilliant.

Mike Hordecki
I would use a comparison to mathematical proofs. You know what you want the result to be, and you have a set of tools you can use to get from your starting point. In most cases designing an algorithm to solve a problem is strikingly similar to proving a Theorem.
Marc Reside
Give examples of how other programmers do problem solving. Come up with a program, and go through it step by step with them. People tend to learn best from examples.
+1  A: 

Well, it's a programming club, so it should be FUN! So I would say dive into some hand on experience right away. Start with explaining what a main() method is,then have students write a hello world program. Gradually improve the hello world program so it has functions and prints out user inputs.

I would say don't go into algorithm too fast for beginners, let them play with C++ first.


Just because you are familiar with algorithms does not mean you can implement them and just because you can program does not mean you can implement an algorithm.

Start simple with each topic (keep programming separate from designing algorithms). Once they have a handle on each, slowly start to bring the two concepts together.


Wow. C++ is one of the worst possible languages to start with, in terms of the amount of unrelated crap you need to get anything working (Java would be slightly worse, I guess).

When teaching beginners in a boilerplate-heavy environment, it's usual to start with "here's a simple C program. We'll discuss what all this crap at the top of the file is for later, but for now, concentrate on the lines between 'int main(void)' and the 'return' statement, which is where all the useful work is accomplished".

Once you're past that point, basic concepts to cover include the basic data structures (arrays, linked lists, trees, and dictionaries), and the basic algorithms (sorting, searching, etc).

Mark Bessey
+2  A: 

Breaking it Down

To me, what's unique about programming is the need to break down tasks into small enough steps for the computer. This varies by language, but the fact that you may have to write a "for loop" just to count to 100 takes getting used to.

The "top-down" approach may help with this concept. You start by creating a master function for your program, like


You have no idea how that will work, so you break it down into further steps:

(Note: I don't know C++, so this is just a generic example)

filterItemsByCritera() {

Then you break each of those down further. Pretty soon you can define all the small steps it takes to make your criteria list, etc. When all of the little functions work, the big one will work.

It's kind of like the game kids play where they keep asking "why?" after everything you say, except you have to keep asking "how?"

Nathan Long
+1  A: 

Someone mentioned above, "make programming fun". It is interesting today that people don't learn for the sake of learning. Most people want instant gratification.

Teach a bit of logic using Programming. This helps with(and is) problem solving. The classing one I have in my head are guessing games.

  • Have them make a program that guesses at a number between 0 and 100.
  • Have them make a black jack clone ... I have done this in basic :-(

Make paper instructions.

+1  A: 
  1. Explain the "Fried eggs" story. Ask the auditory what they would do to make themselves fried eggs. Make them note the step they think about. Probably you will receive less than 5 steps algorithm. Then explain them how many steps should be written down if we want to teach a computer to fry eggs. Something like:
1) Go to the Fridge 
2) Open the fridge door 
3) Search for eggs 
4) If there are no eggs - go to the shop to buy eggs ( this is another function ;) ) 
5) If there are eggs - calculate how many do you need to fry 
6) Close the fridge door 
7) e.t.c. :)
  1. Start with basics of C - syntax semantics e.t.c, and in parallel with that explain the very basic algorithms like bubble sort.
  2. After the auditory is familiar with structured programming (this could take several weeks or months, depending how often you make the lessons), you can advance to C++ and OOP.

Have your club learn how to actually program in any language by teaching the concepts of building software. Instead of running out an buying a dozen licenses for Visual Studio, have students use compilers, make systems, source files, objects and librarys in order to turn their C code into programs. I feel this is truly the beginning and actually empowers these kids to understand how to make software on any platform, without crutches that many educational institutions like to rely on.

+2  A: 


I think you are getting WAY ahead of yourself in forcing a specific language and working on specific topics and a curriculum.. It sounds like you (and some of the responders) are confusing "advising a programming club" with "leading a programming class". They are very different things.

I would get the group together, and the group should decide what exactly they want to get out of the club. In essence, make a "charter" for the club. Then (and only then) can you make determinations such as preferred language/platform, how often to meet, what will happen at the meetings, etc.

It may turn out that the best approach is a "survey", where different languages/platforms are explored. Or it may turn out that the best approach is a "topical"one, where there topic changes (like a book club) on a regular basis (this month is pointers, next month is sorting, the following is recursion, etc.) and then examples and discussions occur in various languages.

As an aside, I would consider a "language-agnostic" orientation for the club. Encourage the kids to explore different languages and platforms.

Good luck, and great work!


As for the language of choice - congratulations - you'll find C++ is very rich in making you think of mathematical shortcuts and millions of ways to make your code perform even better (or to implement fancy patterns).

To the question: When I was beggining to program I would always try to break down one real life problem into several steps and then as I see similarity between tasks or data they transform I would always try to find a lazier, easier, meanier way to implement it.

Elegance came after when learning patterns and real algorithms.


Hank: Big O??? you mean tell beginning programmers that their code is of O(n^2) and yours is of n log n ??


I could see a few different ways to take this:

1) Basic programming building blocks. What are conditional statements, e.g. switch and if/else? What are repetition statements, e.g. for and while loops? How do we combine these to get a program to be the sequence of steps we want? You could take something as easy as adding up a grocery bill or converting temperatures or distances from metric to imperial or vice versa. What are basic variable types like a string, integer, or double? Also in here you could have Boolean Algebra for an advanced idea or possibly teach how to do arithmetic in base 2 or 16 which some people may find easy and others find hard.

2) Algorithmically what are similar building blocks. Sorting is a pretty simple topic that can be widely discussed and analysed to try to figure out how to make this faster than just swapping elements that seem out of order if you learn the Bubblesort which is the most brain dead way to do.

3) Compiling and run-time elements. What is a call stack? What is a heap? How is memory handled to run a program,e.g. the code pieces and data pieces? How do we open and manipulate files? What is compiling and linking? What are make files? Some of this is simple, but it can also be eye-opening just to see how things work which may be what the club covers most of the time.

These next 2 are somewhat more challenging but could be fun:

4) Discuss various ideas behind algorithms such as: 1) Divide and conquer, 2) Dynamic programming, 3) Brute force, 4) Creation of a data structure, 5) Reducing a problem to a similar one already solved for example Fibonacci numbers is a classic recursive problem to give beginning programmers, and 6) The idea of being, "greedy," like in a making change example if you were in a country where coin denominations where a,b, and c. You could also get into some graph theory examples like a minimum weight spanning tree if you want something somewhat exotic, or the travelling salesmen for something that can be easy to describe but a pain to solve.

5) Mathematical functions. How would you program a factorial, which is the product of all numbers from 1 to n? How would you compute the sums of various Arithmetic or Geometric Series? Or compute the number of Combinations or Permutations of r elements from a set of n? Given a set of points, approximate the polynomial that meets this requirement, e.g. in a 2-dimensional plane called x and y you could give 2 points and have people figure out what are the slope and y intercept if you have solved pairs of linear equations already.

6) Lists which can be implemented using linked lists and arrays. Which is better for various cases? How do you implement basic functions such as insert, delete, find, and sort?

7) Abstract Data Structures. What are stacks and queues? How do you build and test classes?

8) Pointers. This just leads to huge amounts of topics like how to allocate/de-allocate memory, what is a memory leak?

Those are my suggestions for various starting points. I think starting a discussion may lead to some interesting places if you can get a few people together that don't mind talking on the same subject week after week in some cases as sorting may be a huge topic to cover well if you want to get into the finer points of things.

JB King

You guys could build the TinyPIM project from "C++ Standard Library from Scratch" and then, when it's working, start designing your own extensions.