« Never Mind The Bollocks - It's The Agilisti! | Main | IDE Wish List »
August 14, 2004
To Sir - With Agility
I spent a considerable amount of time masquerading as a university lecturer/tutor before I started masquerading as a consultant, and I loved and dearly miss my time in the classroom. Perhaps it's not surprising then that I frequently relate my current career to my previous one. Recently, I've begun to realize how successfully Agile practices like those embodied in Extreme Programming could be employed in teaching software development to university students...
Some of the biggest problems I found in teaching in an undergraduate computing degree were:
- Students are naturally bad at requirements gathering and analysis. It's generally not their fault as these skills come with age and experience. The current solution: specify requirements explicitly up front.
- Likewise, software design is also a skill that is difficult to "teach". I think we develop an eye for good/poor design through exposure to sufficient amounts of both. At undergraduate level, design is usually imposed from upon high for these reasons. Little scope is provided for reflecting on qualitative differences in implementation.
- Assessing individual acquired knowledge over the course of a subject is difficult given the ease with which software can be copied, modified and re-distributed. Traditional formal assessment techniques like exams are a poor indicator of a student's ability to develop software. Further complicating this issue in most computing degrees is the large number of students from countries where the cultural norm is for most learning to be done in private study groups.
At my university, we placed great emphasis on one-on-one student interviews at the end of each subject to accurately determine how much each student has taken on during the subject.
- Students, like professional developers, have an active dislike for documentation in all forms. They have an inherent sense for the YAGNI nature of this form of deliverable. Therefore, requiring traditional documented deliverables for specifications and test plans is problemmatic.
Wih little effort, I can see existing XP practices tailorable to address each of these issues.
- Customer Acceptance Tests
- In a classroom, the teacher is the customer-proxy. Therefore, it's expected in an XP world that the customer specify the acceptance criteria for the work they're requesting. If students had a complete set of automated acceptance tests for their assignment work, it would certainly curtail the endless series of "I think I'm finished, but I'm not sure..." statements I was peppered with towards the end of each assignment. The immediate feedback this mechanism provides would greatly reduce the need for the inspection of the teacher to ensure completeness.
- Pair Programming
- Given most student's learn best with their peers, pair programming should be encouraged at all times during their study.
- Ensure tutorial sizes are roughly
2nwherenis the number of workstations in the lab. - Enforce pair changes frequently in the semester to open students to a wide variety of programming styles, and prevent "remora" behaviour where astute but unmotivated students attach themselves to the high-performing developers for the duration of the subject.
- Continue to conduct individual interviews to assess each student's amount of individual learning.
- Ensure tutorial sizes are roughly
- Refactoring
- Given students don't have a natural feel for good program design, let them churn out the simplest thing that could possibly work on their first attempt and then allocate assessment criteria for some form of refactoring. Where possible, use automated metric reporting to give them immediate feedback that their changes are increasing/decreasing code quality, but also use some form of subjective tutor-based assessment to enforce the fact that not all quality can be codified by tools.
- Automated unit tests
- Let students generate and use an automated unit test suite in place of a written test plan. Ditto for design documentation: tools such as YDoc, OptimalAdvisor (the tool formerly known as Pasta) and others automatically derive design information from the codebase, reducing the need to produce copious reams of spurious and doomed-to-be-obsolete written documentation.
There are a whole swag of other XP concepts which would also work well in a classroom environment (e.g., Continuous Integration, automatically enforced coding standards, week = iteration, etc), but I would triage the four major point above to the top of my list given the opportunity.
Now, if only a teaching position came with a consultant's salary :-)
Posted by Andy Marks at August 14, 2004 09:58 AM
Comments
Spot on Andy! I think you've only just scratched the surface in the way that agile could be applied in an educational institute. I know of a few courses where some of the tools typically used in an agile environment have been adopted (a good step in the right direction), but I think the entire approach needs to be applied to the entire course.
Imagine how powerful this sort of teaching could ultimately improve standards in our industry if students entered it having lived and breathed agile practices throughout their entire degree! Even if their first job was to a place where software development was excruciatingly 'waterfall', any exposure to the excellent software engineering practices agile promotes will certainly help in push things in the right direction. In any case, it's worth it if it means one less person you have to persuade to do things the right way ^_^!
P.S. If you want help planning a course... drop me an email.
Posted by: The Kua at August 16, 2004 08:24 PM
Post a comment
Thanks for signing in, . Now you can comment. (sign out)
(If you haven't left a comment here before, you may need to be approved by the site owner before your comment will appear. Until then, it won't appear on the entry. Thanks for waiting.)