On learning thru Open Source Software

I read an interesting blog post on adopting open source at university as a way of teaching computer science, and I posted also a comment
on such article.
Here I would like to extend my point of view about the subject.
Having worked in an university for a few years, having done computer science at both sides of the desk, and having a quite good
experience in what became my day-to-day work, I believe I can express some opinion about.

Adopting open source as a teaching methodology should just be.
Period!
Instead of asking students to produce the same crappy software all over the time (a database layer, a GUI layer, a music store,
a calculator), put them on a real piece of software that someone in the world could use and adopt.
Why?

1. motivation: students will be happy to work on some real stuff with the main author(s) thanking them for their help, time,
   and work;
2. learn something useful: real programs do things in the real world, and things in the real world must work, and work fast, and work
   in accurate way. That is:
   
   • work on real data: nobody will ever notice your crappy homework do a full table scan each time you need to display one of your
     fake music titles out of ten, but a real program will freeze once you try to do a full table scan just to display out a detail
     out of a million records. This is something university cannot teach you, trust me!
   • deal with problems: university will teach you a lot of theory about using natural keys, algorithms to sort structures, avoid
     data replication, and so on. Not always these approaches will drive you to a manageable software: learn to deal
     with surrogate keys, duplicate data when it makes sense (e.g., network latency, historical reasons and so on).
   • learn the tools: developers around the world need to coordinate. Learn to use bug reports, stay on mailing lists, IRC channels,
     and alike. Don't ask stackoverflow for someone to do your homework, learn how to find documentation and search for answers. Become
     acquainted with revision control, compilers, linkers, and different platforms.
   • document for someone else: it is easy for you to explain what you have done to your teacher, in particular if you did it in the very
     previous period of time (typically a semester). But can you document something so that another developer, even another student like
     you, can understand one year later why and how you did a task?
3. do not start a project from scratch: typically the university cycle during semesters is something like design-implement-compile-run-explain-_throw away_
   and then you start over and over again every time you got an assignment, homework, or project. This is wrong! Real life does not work as such:
   in real life you are often assigned to maintain or refactor an existing piece of code without having to throw it away.
4. learn idioms: developers around the globe are smarter than you. It is not they are more intelligent, it is just they are more expert
   and know better the subject. Reading someone else (smarter) code is a great way to improve your knowledge and become smarter too. Learning idioms,
   seeing patterns applied to real world code is a great start to become a professional coder.
5. fun: developers have their habits. They meet together in so called conferences, and usually got beers while talking about code, travel
   around the world, and have a lot of fun. And even if you stay closed in your room, doing your homework, having a chat, a video call
   or an email in your in-box with a "thank you" or "good job!" is really fun.

There are other reasons, but the above are my main choices to push students to the open source world.
So far, it seems that you are going to have only advantages and no drawbacks, but that's not true.
Becoming an open source contributor you are going to become smarter than your own university teacher, and this is a drawback so far as
the teacher signs your curriculum. It is something that is really hard for a teacher to keep in mind, but it is so true.
I was always saying to my student, in the very beginning of each class, that at the end they will know better than me the subject, and the reason
for that is that "I'm not going to spend whole nights studying before the exam!".
So, if you are a teacher, simply accept that.
Accept that a student could prove a better algorithm, or an idiom you don't know that works. Ask him for the details, learn from him.
Learning is not a one-way process, with a god-like teacher and an idiot-like student; learning is a cooperation where someone expert provides the sparkle to someone else.
Would not be nice to see if both can grow during the path?

There is also another drawback: open source is not something you can teach without knowledge. You have to know the tools: revision control, IDEs,
bug tracking, issue tracking, wiki, testing and alike.
Most teachers urge teaching C pointers arhitmetic instead of basic tools, and that's not good.
Allow me to provide my very own example: I spent five years in a computer science degree, and nobody told me about revision control. While
doing my master thesis, being afraid of loosing some change or to mistakenly do a single line change (that will not blow up your project, right?),
I did my very own backup shell script that was running every hour to keep an historical copy of my work.
Shame on me, in the very same time I could have learnt rc or cvs (no, it was before git).

So my advice for students is be a part of an open source community, you will surely learn something that will make the difference in
your real job.
And my advice for teachers is accept smarter students and promote the adoption of an open source code base. There are a lot of "mini-hackers"
initiatives around the world (CPAN Pull Request, Hacktoberfest, etc.), pick one and try let your student do the rest.
You'll be happier, your student will be happier, the open source community will be happier and, who knows, your employer could also
become a partner in an open source community.