Software engineering is the study and an application of engineering to the software development lifecycle, including requirements, design, architecture, development, testing, and maintenance. It is important that Universities teach students not only the theory underlying these phases, but also allow students to practice using real systems.
Quoting Arie van Deursen:
When teaching software engineering [architecture] it is hard to strike the right balance between practice (learning how to work with real systems and painful trade offs) and theory (general solutions that any architect needs to thoroughly understand).
To address this, inspired by TUDelft's Software Architecture course, we decided try something different in the Software Engineering course of the University of Porto's Master in Informatics and Computing Engineering:
- Teams of 4 students had to adopt an active and complex open source GitHub project and contribute to the project, mostly by documenting these projects.
- Following "How GitHub uses GitHub to Build GitHub", communication among team members and external stakeholders took place through GitHub where possible.
- To ensure that students actually digested software engineering theory, we made them apply the theory to the actual project they picked in sprints of two weeks. Hence, we made them follow an Agile process to software development (Scrum in particular).
At the start of the course, teams had to choose a project on GitHub. The students could pick any project that was sufficiently complex, have multiple contributors, have test cases, and be active.
There were 23 teams working on mostly different projects. Selected projects, which students managed to have pull requests accepted, are: Terasology, Kodi, 0 A.D., and Supertux.
There are several Software Development Life Cycle models (following this link for a detailed discussion). All of these models have a set of common phases:
In the context of the Software Engineering course, students were asked to document the projects they adopted for each of these phases, except coding. The testing and maintenance phases required students not only to document these phases but also to code tests, fix bugs, and evolve features.
After project selection, students were asked to fork the project, create a ESOF-docs folder, and adopt a Git branching model as described in the following link:
The course asked the students to hand-in (that is, push into the repository) their reports documenting each of the software development life-cycle. The documents the students had to produce are to document/contribute in the following domains: software processes, requirements elicitation, software architecture, software testing, and software evolution. By following the links of the projects above, interested readers can see the contributions of the teams to the projects.
As for bug fixing and feature evolution, the links for the pull requests are below:
- Terasology
- Kodi
- 0 A.D.
- Supertux
Using GitHub to teach software engineering help us create a more hands-on course, using real software projects. Students were very motivated because of the feeling that they could contribute to a project that is used by many people. Interaction with stakeholders (project owners developers) also helped students to develop soft-skills (e.g., convince stakeholders that they fixed a bug, or that some feature needed evolution). Students could also experience what it takes to contribute to an open source project. Many are even committed to contribute to open source projects further.
Teaching this course was an overly rewarding experience. Students came up with remarkable results. In the future, we will ask students to use parent-less branch in order to better organize the documentation (see git checkout --orphan).
These are the links to the all the forks with the contributions of the teams:
- https://github.com/andrelago13/Terasology
- https://github.com/rppc/react
- https://github.com/Famarante/WordPress-Android
- https://github.com/Digas29/bazel
- https://github.com/jrfcabral/atom
- https://github.com/frankpunx/Terasology/tree/master
- https://github.com/PedroRomanoBarbosa/libgdx
- https://github.com/lpinto93/meteor
- https://github.com/carvalhofilipe1995/Caldroid
- https://github.com/leonardo95/citra
- https://github.com/Pedrock/xbmc
- https://github.com/cassos/mgba
- https://github.com/pmpontes/tomahawk
- https://github.com/SofiaReis/django-cms/
- https://github.com/pedrofraga/tribler
- https://github.com/Wargyy/reddit/
- https://github.com/mariateresachaves/bigbluebutton/
- https://github.com/martapips/rust
- https://github.com/dimamo5/Terasology/
- https://github.com/quartz55/mopidy
- https://github.com/up201306506/geotools
- https://github.com/Ncf16/0ad
- https://github.com/joserebelo/supertux
- https://github.com/hpnog/jpacman-framework
The successful implementation of the ideas discussed here was mainly due to all students who participated in the Software Engineering Course, edition 2015/2016.
Very interesting! Great that you will offer BetterCodeHub.com to your students for next years course.