Learning and Software

Michael Gove's speech on the digital literacy campaign, currently underway in the UK, got me thinking about how software developers go about learning new software systems.  The digital literacy campaign aims to resolve deficiencies in the educational system.  This is a fantastic initiative and I think other nations follow suit.  Without transitioning from traditional teaching techniques we're used to, our children will be left behind.

What I'm thinking about isn't so much the education system.  I'm looking at the young working adults, many of whom don't have a formal education to speak of — friends and colleagues of mine that have gone on to lead promising careers in IT. The positions they hold require they really know their stuff.  How do they obtain this knowledge?  How do you beat the competition when it comes to know-how?

The Ecosystem
There is an important difference between learning the principles of computer science, and learning how to work with pre-built components.  If those entering the field were taught an important lesson, they'd know that re-inventing the wheel is a no-no.  It's highly probably that you can build what you need by assembling parts, possibly customizing them slightly along the way.  With computer science, everything is from the ground up.  And that's important too, to have a sound theoretical understanding of what software is made of.  Competing in the job market requires that you have at the very least a rudimentary understanding of everything that goes on between the keyboard and the screen.

The software ecosystem of today is uninterruptedly growing and evolving.  Some software components stabilize over time, attracting a wider development audience and thus making further improvements.  Some software components don't gain acceptance in any communities — they subsequently die off.  Understanding the context in which these open source software packages are used is a valuable asset.  It would be a much better learning opportunity to participate in the development of something with staying power.  Something that has proven feasibility and impacts a large group of users for a long time.  Before embarking on a new software project — an experience where you learn a new programming language or a new problem domain — do some research into why you prefer one project over another.  Is there a real future for this project?  Is there an alternative that might better suit your learning goals for the long term?

The way software systems work with one another is increasingly relevant — a lot of development work these days is integration rather than writing new code.  Reusing existing components, utilizing the best tool for the job — skills that matter.  If you spend enough time practicing this evaluation exercise, you'll be able to identify when, exactly, there simply isn't anything suitable for the gap you're trying to fill. This is your time to write something new.  This is how the ecosystem evolves. Maybe you're new software package will acquire a following and become a huge success.  Maybe it will serve as the basis for a superior project, earning you a reputation.  Or maybe it will be a spectacular failure, in which case you take away some valuable lessons.

Teaching by Learning
One unique property of doing software development in an open environment is the shared roles of teacher and learner.  That is, anyone participating in a software development can, and should, fulfill the role of teacher.  Software development is a nascent field — it's constantly changing because we're constantly building better components.  There is no such thing as a dedicated teaching role because it's impossible to keep abreast with everything new that's happening.  That responsibility is distributed throughout the team — everyone should be making discoveries on their own and sharing them with their peers.

Learning to write software is an  enlightening experience.  It has never been more accessible to anyone, regardless of stature, this ability to acquire new knowledge and to apply it.  Simultaneously.  With software development, theory and practice are tightly integrated.  This is why I love my job — my education didn't end with college — it only just got interesting when I started building real software for real customers.  The open source ecosystem serves as an ideal launchpad for anyone looking to further their experience.  Understanding how this ecosystem evolves and how to best utilize it's inhabitants is a skill no school can teach.  You have to do it yourself.  And it's no trivial investment, but well worth it.  Maybe we'll start seeing educational institutions adopt these new methods of software-based learning in the not-too-distant future.

Learning Computer Science

There is no doubt that in today's computer-based, technology-driven, network-connected, information-intensive environments, that computer science is an ever more pertinent discipline. Not just computer programming, not just software development for everyday components, but the underlying fundamentals that generates new research and insights. The challenges information technology presents are only going to get harder as our data grows larger. We need more computer scientists. Instead of seeing a growing trend in the computer science student population, it has fluctuated wildly over the past decade – enrolment jumps, enrolment dips. There is no single factor that explains rising or declining interest in computer science. I'm sure of the reasons are directly related to the the teaching institution, not the discipline itself. I wonder, is a degree the only way to master the most challenging theoretical and applied aspects of computer science?

I don't have a degree. This fact means different things to different people. Not having a top-notch education obviously doesn't help in finding employment. However, I also didn't want to spend half a decade learning without doing. This isn't to say that a degree is a bad thing. To the contrary. I've worked with several people in my life with computer science and math degrees who've changed my understanding of what I do every day. However, I was more motivated to join the workforce sooner rather than later. Accumulating student loan debt wasn't on my to-do list either, so I finished a 2 year program and started working.

Finding a job in information technology isn't easy – there are plenty more reasons not to hire someone than to hire them. The biggest roadblock for finding employment is lack of experience – I had zero at once point. Not only did I know nothing about working in the real world, I had a miniscule diploma while seeking out jobs that require a degree and experience. It felt like I had no chance of getting hired and would have to return to school. This went on for quite a while – over a year. That's a long time to list professional job hunter on your resume.

Things got interesting when I found Enomaly. Not only it seem like an awesome start-up to work for, but they did open-source consulting gigs! The main reason I got hired was because I started and worked on an open source project at the time – a little tool that parsed XMI files and ran activity UML activity diagrams. It wasn't the project that made an impression – it was the idea of taking on an open source project they valued. This got me thinking, and to this day I still think about it, maybe open source software development can serve as an education in computer science.

The same stuff you'd find in a computer science course of any kind, you'll find in an open source software project out there. Its all in the code. This is how you learn how to write your own code by studying someone else's. The lessons learned accumulate as you read more code and write more of your own.

However, if you're young and just getting started, this task isn't so straightforward – you need a starting point. How do I know which open source project to study? Well, maybe it is straightforward after all – find an open source project you enjoy using yourself. Don't read the source code of a image editing program if you can't see yourself using it. Reading code for applications you have no interest in won't help you learn the science behind it all. Instead, its more of a chore. And this is one area where an open source computer science education really shines – the sheer variety of what's out there to learn about.

Once you've found an application you enjoy using and find interesting, you're ready to start reading code. I find the best way to start is not by jumping down to the low-level stuff and working my way up. Instead, I like to find something specific the user can do with the application – import a foreign file format say – and drill down in the code structure using a top-down approach. There is plenty to learn about on the way down.

The best part about learning computer science by studying open source projects is that it often spawns a series of learning projects. If you learn all about Django, maybe you'll want learn about other Python web frameworks and how they tackle similar problems. Maybe you'll investigate further on how sockets work or buy a book on network theory. Maybe you'll start reading the Python source code and learning about programming languages. The possibilities are endless. As you learn the fundamentals, you'll hone in on the specific ideas of what you're really interested in.

Open source software as a learning tool is great because its open. There are no barriers hiding the conceptual bits and pieces for those interested in how they work. So who are your instructors in an open source software education? Your peers are. The same people who took an active interest in the project, spent the necessary time to understand and contribute to it. Contributions come in many forms – code, monetary donations, and knowledge itself. The aspiration of any open source project community is that it will grow, steadily and for the long run. The only way to make this happen is by educating those who are willing to learn about it.

If you're already enrolled in a computer science program, use an open source project as an opportunity to expand what you already know or as a way to devise the right questions. You might find something you wouldn't have otherwise.

Cheating Computer Science

Apparently new computer science students these days love to cheat. I wonder how this will affect these students once they have completed school and have jobs. Will this rigorous process of plagiarism detection lead to less code reuse and constantly reinventing the wheel?

Programming Skill

It is amazing how many people apply for programming positions who simply can't do it. But it also sounds like people are getting hired. It begs the question, how soon are these people that are clearly out of their field given a programming task after they're hired?

This actually reminds me of school. Computer Programmer sounded like an attractive field to be in but once it came time to write something functional, many people just had blanks looks on their face. I don't think they were around the following semester.

Developer Education

This entry asks what type of developer you are. White collar versus blue collar. What the question essentially comes down to is what level of education do you have. White collar developers are considered to have a four-year college or university degree while the blue collar developers have less education. So, are these degrees really necessary to become a software developer?

This question really needs to be in a less broad context. For instance, is it likely that as a developer you will need an advanced computer science degree to build typical web applications? Not likely. Will you need one to do optimization work with embedded software. Probably.

Computer scientists have the theoretical know-how that is an absolute must in certain circumstances. Other developers have more experience in what is the more practical way out of a given situation. The important thing to note, I think, is that either one has limitations. It is the job at hand that dictates who is best for the job.

In addition, not being able to produce a degree for highly niche jobs doesn't necessarily mean a road block for some developers. If you can show, through software that you have built in the past, the knowledge you have, it is a good alternative.

Three Languages For Learning How To Develop Software

In an interesting discussion, the question of which programming language is best suited for teaching computer science students is raised. It is an interesting question because it seems that there isn't any real consensus among schools as to what the standard language should be. This brings up another question; should there be a standard language that should be taught to computer science students? Or should a more adaptive approach be taken and teach a language geared more toward some specialization?

I think the introductory-level courses need at least some level of language standardization amongst schools. Later on in the computer science program, if there is a specialization the student is interested in, the language best suited for that purpose should be taught. However, there are countless specializations a computer science graduate could strive to be an expert in. I don't think it is possible to realize them all, but the schools that teach these computer science programs should at least open a few broad categories of computer science specializations rather than just a single end point.

During the introductory courses of a computer science program, the concepts take the top priority. I think three languages could serve as a powerful tool in teaching these concepts. First, the C programming language. C allows for a good introduction to low-level programming concepts. It is also a good example of language design and is still heavily used in the industry. Second, the C++ programming language. C++ is a natural progression from C in order to introduce object-oriented concepts. Still heavily used in industry and still low-level. Lastly, the Python programming language. Python gives a good introduction to high-level languages. Not as heavily used in industry but is always gaining popularity. Python and C are highly interoperable.

Teachers and open source

An interesting entry about teachers and their ignorance toward open source software has made me happy. Not the teachers, the fact that people are willing to voice the problems caused by proprietary software in the education system.

The entry states that Canada is making larger steps than the US to improve open source adoption in schools. Unfortunately, I highly doubt that is true.

I think there should be a huge sense of urgency here. Instead, it seems some of the teachers that aren't completely oblivious think "OK, there is Linux, but there is nothing I can do about it".

Perhaps teachers should encourage students to use Linux and other open source projects outside of the classroom. Rather than merely "allowing" it. Let the students insist on bringing open source into the education. I would think this would be a much easier task with student support.