I officially graduated last weekend ending an undergraduate effort that started at the University of Texas at Austin 20 years ago in 1989 and stalled in a hiatus that turned into a full-time career.
With the help of my employer’s generous tuition reimbursement plan and the flexibility of the distance learning program at the UMass I finally managed to not only wrap things up and earn a BS in Information Systems, but in doing so earned the Chancellor’s Medal for Academic Achievement. Who knew I had it in me to graduate at the top of my class for my college?
The experience of going back to school so many years later has been eye opening and has provided a lot of context to my recruiting efforts for greenhorn programmers. That is, I’ve walked a mile in their shoes and seen what is currently being taught in college level Information Technology programs.
The Good News
Contrary to my expectations forged from my previous collegiate experience, the problem of professors teaching outdated technology and theory has been remedied to a considerable degree, at least in the UMASS program. Many of the classes were taught by adjunct professors that worked at least part time in the real world in addition to their academic duties. This made the lessons much more relevant and practical. Also, I’m glad to see they have moved on from Turbo Pascal and 68000 Assembly, but then I am dating myself.
The Bad News
The curriculum is still very centered on learning specific technologies and was conspicuously weak on best practices or practical preparation for aspects of software engineering outside the scope of software construction. Given the relatively small percentage of time that a working programmer spends on writing code versus other elements of the software construction process, this is not ideal.
As a hiring manager, I’d greatly prefer graduates with a good grasp of basic software construction and project management skills than proficiency in a specific programming languages. Software platforms exhibit such a short half-life that I’d question the long term value of them anyway aside from the foundational ones like C++.
Proposed Curriculum for Software Engineers
The following course of study is a recommendation based on the skills that I’d like to see when I interview entry level software developers. I am not saying that existing programs don’t include some or all of these elements, but I rarely see many of these skills when interviewing recent college graduates. I’ve broken the topics out for clarity, but clearly some should be combined or split into multiple courses.
Freshman Year – The fundamentals
- Overview of Operating Systems: Working knowledge and exposure to at least 3 of the most commonly used operating systems, i.e. Windows, Linux, OSX, etc. The ulterior motive is to derail platform bigotry before the mental cement dries.
- Overview of Programming Languages: Exposure to a variety of languages by writing very basic programs in each. (C#, C++, Ruby, VB.NET, Perl).
- Scripting 101: Familiarity with the most basic programming concepts such as variables, methods, control structures, etc. without the overhead of more advanced programming concepts to provide a comfortable “wade-in” point for those new to programming.
- Application Architecture: Become familiar with common application architectures, associated issues, and relevant technologies. (Desktop, Client-Server, N-Tier, Web, Embedded, AJAX, etc.)
- Intro to Electrical Engineering: Hardware level programming as an analog for software development. Boolean algebra, basic circuit design, logic gates, etc.
- Database Design Principles and Theory: Set Theory, Normalization, OLAP, ROLAP, etc.
- Networking Basics: Topics including, networking hardware, topologies, the OSI model, basic signaling, and protocols.
Sophomore Year – Filling the toolbox
- Reporting Tools and BI: Crystal, Cognos, SQL Server Integration Services
- Database Query Languages: Query language and technique in ANSI-SQLsome coverage of PL/SQL and t-SQL.
- Programming in <Student’s Choice>: In depth programming course in the language of the student’s choice.
- Source Code Control Tools and Best Practices
- Technical Writing: Best practices for creating of software documentation and help systems that are useful to real people.
- The Build Process and Change Management
Junior Year – Sharpening the tools
- Programming for a Diverse world: I18N, L10N, Unicode, etc.
- Writing Secure Code: Common application security vulnerabilities and how to avoid them (SQL Injection, XSS, Buffer Overflows, etc.) Suggested Text – “Writing Secure Code”
- Programming Technique: OOP, Design Patterns, Refactoring, Coupling Cohesion.
- Usability / User Experience: Suggested text – “About Face 2.0: The Essentials of Interaction Design”
Senior Year – From machinist to craftsman
- Designing Software: Requirements Gathering, Use Cases, Prototyping.
- Software Project Management and Estimation: Agile, Waterfall, etc.
- Team Programming: Code review, pair programming.
- Testing Software: Tools and technique (Unit, Automated, Load, Regression, Integration)
- Profiling and optimizing code: Static/Dynamic code analysis, Big-O Notation.
- Debugging/Troubleshooting:I am amazed at how impressively bad a lot of working programmers are at this. Suggested Textbook: “Debugging: The 9 Indispensable Rules for Finding Even the Most Elusive Software and Hardware Problems.”
- Problem Solving in Code: Problem solving and more in-depth exposure to the programming language of the student’s choice.