A key element of the teaching framework is an "arc" of progression through the curriculum, as a computer science student advances from freshman to graduating years. In terms of activities and artifacts produced, this arc parallels the growth curve of a maturing software developer. In terms of intellectual and academic themes, the progression provides a computer science equivalent to the Dewar-Bennett Mathematical Knowledge-Expertise Grid which was, in turn, adapted from Shavelson's science knowledge typology and Alexander's model of domain learning (MDL).
In a Recourse curriculum, freshman courses focus on the study, testing, and fixing of existing code --- corresponding to the initial phases of participation by a software developer in an open source community (or any other team development effort, for that matter). These activities reflect an acclimation phase in a computer science student's development, during which most motivation is completely external (i.e., assign-and-grade) and overall confidence is still relatively low: problems must be limited in scope, with highly focused solutions. Sample code and rigid syntax form the student's factual and procedural environment, with mimicry (i.e., seeing and imitating "how it's done") forming the primary activity. These goals all but necessitate apprenticeship-style teaching and learning during the freshman year, an approach that has been taken at Loyola Marymount since the late 1980s. Schematic and strategic knowledge begins on a superficial and compartmentalized level, which corresponds to the highly focused and well-bounded nature of pre-existing software. Pre-existing is a key component of this stage: conventional teaching at this level usually involves writing "toy" programs from scratch. By teaching basic programming techniques in the context of pre-existing code, a student may be exposed to big-picture ideas sooner and as a result may realize the value of cleanly written, well-documented code from the outset --- a concept which is traditionally very difficult to teach, but critical to learn in practice.
Sophomore courses, which typically introduce data structures, algorithms, and computer system organization (outside the context of a specific programming language) provide an appropriate foundation for coding specific functions and modules from scratch, accompanied by unit tests. This activity corresponds to the software development stage where a programmer begins to implement new but well-bounded functionality. From the open source culture's value of community and accountability, unit tests serve as an unambiguous (and easily automated) mechanism for validating the correctness of submitted work.
From a knowledge-expertise perspective, the sophomore activity of building and testing new functionality reflects a transition from acclimation to the subject matter to early stages of competence. Students begin to gain personal, internal interest in the problems and concepts at hand, moving from the concrete (i.e., sample code) to the abstract (i.e., data structures and algorithms) with an increasing ability to handle greater functionality and complexity. Syntactic issues become second-nature, giving way to semantic concerns. The enforcement of unit tests provides a level of rigor and concrete confirmation that a student has properly translated computer science concepts into programmatic form.
Junior-level courses (and beyond) introduce subfields within computer science, expecting sufficient programming proficiency as the general concepts of sophomore courses find specific applications in operating systems, programming language design and implementation (i.e., compiler construction), networking, interaction design, databases, computer graphics, artificial intelligence, and others. Activities for these courses take the form of term-length projects: students now design and implement software from scratch. At this level, the software conveys the lessons learned from two years of looking at --- and trying to fit --- other people's code. An open source software developer finds an analogous milestone when starting his or her own open source projects. At this point, students come full circle, as the long life of code becomes apparent: software written at the junior level finds its way back to the freshmen, as pre-existing code that must be examined, fixed, and completed.
Finally, the senior year expects students to demonstrate proficiency in computer science, through capstone projects that synthesize prior material based on individual interests. These capstone projects break out of the focused domains of junior courses, enabling students to connect accumulated knowledge areas into a greater whole. LMU has implemented such projects since the 1980s, and in the context of an open source culture, they gain renewed meaning as they correspond to an open source developer's growth into a mature, confident, and self-motivated creator with the skills and experience to take on and even initiate formidable software projects.
In the context of the rest of the Recourse curriculum arc, senior capstone projects continue to "live" on in their own right beyond the graduations of their creators, becoming bona fide open source projects with their own communities and repositories. Future students are exposed to this code and may contribute to it in their own courses.
At the end of the four phases and themes of this curriculum "arc," a student will have acquired the knowledge and skills of a computer science bachelor's degree not only through conventional texts, lectures, and exercises, but also through collaborative programming, shared code, and accountability for one's work. Graduates of such a program would be both better computer scientists and competent software developers who can hit the ground running immediately, whether in industry or research.