The rationale for a new approach
Nearly every university I visit (public or private) does a great job at providing the fundamentals of computer science and engineering. However, very few spend the same amount of time teaching the more practical skills their students will need to develop sustainable software in a commercial environment. As a result, here is what I usually encounter when I hire new graduates:
- Knowledge only of a Pure Waterfall Model (something I have not seen applied on any project in the last two decades)
- Lack of knowledge of basic estimation techniques (causing many late all-nighters for their first few commercial projects)
- Little understanding — or appreciation — for unit testing and quality assurance (creating many downstream problems on their first 3-4 projects)
- Lack of experience organizing work into modules that can be split out and developed across multiple team members (resulting in lots of re-factoring and outright re-work of code)
- Little-to-no experience branching and merging code (causing fixed bugs to “reappear” in later builds)
As a result, I have spent much of the last twelve years teaching (and re-teaching) new graduates basic fundamentals of commercial (i.e., professional) software development. After doing this for nearly 500 software engineers, I have come to the conclusion that we need to do something very different to prepare students for the workplace.
Why a university incubator?
When students enter the university, their minds are the most open to new ideas and possibilities. They have not “learned” why things “can’t be done” and are willing to try new ideas. If you do not believe look at developments like: Instant Messaging (Zephyr predated AOL—I was there for it), Web Portals (pre-Yahoo!), Search (Google) and Social Networking (facebook). Imagine how much innovation we could foster if we gave students commercial-grade development environments and taught them the fundamentals of building commercial-grade software when they want to try these ideas.
Why would Universities want to do this? Doesn’t it cross the lines of making them too commercial? I do not think so. Instead, it will make them leading research institutions that can attract large-scale investment from government and the private sector (look at MIT, Stanford, Carnegie Mellon and the University of California at Berkeley for examples).
What does it take to develop this?
Universities need three things to make this a reality:
- Change the teaching approach
- Recruit industry volunteers
- Provide capital hardware and software to students for use
Let’s look at they would apply each:
Step 1: Change the teaching approach
Once professors have taught the fundamentals of computer science and engineering it will become time to begin teaching the “art” of software development.
This starts with the basic premise that one cannot perfectly plan something as flexible as software (it is not the same as building a house). Throw out any references to the Requirements-Design-Development-Test-then-Deploy Waterfall Model. It assumes perfect knowledge (and perfect requirements) at the front of the project. Instead jump right into Agile Development Methods. Pick Scrum or FDD. Challenge your students to form teams to come up with project ideas, then walk them throw the visioning and spiral approaches to developing software in sprints. This will “feel” natural and they will immediately understand that requirements cannot be developed isolation.
Once they have built something, show them the importance of testing and documentation. Teach them what positive and negative path testing is and make them write and execute unit and certification test cases for each other’s work. They will learn how many bugs even the simplest software has and begin to appreciate testing (and upfront planning for testing after experiencing it directly.
Now, take it up a notch. Assign them bigger projects, ones that require them to break up and organize work. Nothing will teach them the importance of modularity and encapsulation than having to integrate the work of multiple people working on their first or second project.
At this point, they have some experience – especially experience recovering from mistakes. This is the perfect time to teach two or three estimation approaches (see my Books I Like for ideas). Make sure you teach them to account for things like optimistic bias and omitted takes like unit testing, integration and performance testing.
Step 2: Recruit industry volunteers
Most of us in industry would love the opportunity to come share our experiences with new students. It gives students insight into how products were built (and what mistakes to avoid). It gives those of us in industry a chance to connect with new students and recruit new talent. It is also fun.
As an added benefit, industry volunteers can provide ideas (or even sponsor) projects for students to work on. This gives students more real-world experience and industry some “free” R&D.
You never know where this could lead: take at look at what Sun achieved sponsoring a little project called Network File System in the late 80s (I remember Beta testing V2 as a student).
PS – I practice what I preach. I am very grateful that Florida Gulf Coast University lets come in from time-to-time to give wild lecture on things like turning off referential integrity to enable scaling to support 10,000 plus transactions per second.
Part 3: Provide capital hardware and software
Here is where those of us in industry (especially those of us who create hardware and commercial software) need to help the most. We need to donate hardware and software (licenses and tools) to universities to enable them to create full-fledged incubation environments. Here is what they need:
- Enough hardware to setup separate development, integration, test and production environments
- Licenses to maintain web, application and database servers for each
- Integrated development environments and basic tools for version management (e.g., CVS), build management, test automation, defect tracking and performance measurement
Imagine what students could pioneer and develop if they had this. Imagine how much we would benefit if we could hire students who understood how to move code across environments, load test and optimize it, and manage multiple branches and versions.
If this is not enough incentive — donations can be costly — think of how you can use this to Beta test your new hardware and software (while writing off donations and seeding a whole market of users familiar with your newest products).
Is this possible? If so, is it possible in many places?
Yes and Yes. I was lucky enough to be exposed to all three of these things at MIT. As result, I began my career two grades higher than other new graduates who started on the same day I did on their first post-graduation jobs.
This can happen at more places than schools like MIT, Stanford, Berkeley, the University of Illinois or Carnegie Mellon. Every state should be doing this in the larger schools of their university systems. It is early-stage economic development that can pay off by driving much innovation at the state and regional level.
So let’s get started.