Software Engineering Minor Proposal Jonathan Aldrich, David Garlan, and William Scherlis Institute for Software Research Rationale Effectively building modern software systems at scale requires not just programming skills, but also engineering skills. These skills include the ability to interact effectively with customers to gather the requirements for a system in a precise way; to develop a design that resolves competing quality attributes; to make tradeoffs among schedule, cost, features, and quality to maximize value to stakeholders; to work effectively with other engineers; and to assure the quality of the delivered software system. We hear regularly from industry that these skills are crucial to them, and that they would like to see a stronger software engineering background from our students. We propose to offer a minor to teach the fundamental principles of software engineering, and to certify these engineering skills to potential employers. Overview The software engineering minor is designed to teach the fundamental tools, techniques, and processes of software engineering. Through internships and a mentored project experience, students gain an understanding of the issues of scale and complexity that motivate software engineering tools and techniques. The core curriculum includes material both on engineering the software product and on the process, teamwork, and management skills that are essential to successful engineering. Graduates of the program should have the technical, process, and teamwork skills to be immediately productive in a mature engineering organization. Target Audience and Market The minor has several potential audiences. The most common is probably CS majors who want to be better prepared for a software engineering position in industry. As more than half of our undergraduate CS majors go on to development, quality assurance, or software management positions in industry, the market for a minor in these areas is potentially large. Our undergraduate advisors hear regularly from students interested in software engineering coursework, and enrollment in the new 15-313 course, Foundations of Software Engineering, has been positive for a first course offering (currently at 16 students). Finally, the interest from employers in students with strong software engineering skills is very likely to drive student interest in the minor. CS majors interested in studying software engineering in graduate school will also find the minor valuable. Finally, many other fields are becoming increasingly computational in nature: not just engineering disciplines, but also biology, physics, chemistry, and even mathematics. As software in these fields becomes more complex, programming skills become insufficient: students need software engineering skills as well. We therefore expect the minor to be of interest to students across many engineering and science departments. Software Engineering at Carnegie Mellon Carnegie Mellon is arguably the world leader in the field of software engineering. In addition to 5 core tenure-track faculty in software engineering, the Institute for Software Research includes a large number of teaching and research faculty. More broadly, the SEI is a highly-visible center for software engineering research and education, and CMU’s School of Computer Science is also the world leader in related fields such as programming languages and formal methods. The software engineering minor proposal builds on a strong track record of SE education, including mature Masters and Ph.D. programs in software engineering. Intellectual Content and Curriculum Design Principles Software engineering is the subdiscipline of computer science that infuses engineering principles into software development. The field is founded on core computer science concepts, and we believe that a strong foundation in computer science is essential to be an effective software engineer. Software development, however, applies this science in a rich context of diverse stakeholders, complex business relationships, and coordination among members of a team. This context requires skills that lie at the core of any engineering discipline: the ability to make principled tradeoffs among schedule, cost, features, and quality attributes, despite imperfect knowledge. Carnegie Mellon’s view of software engineering recognizes elements of both engineering judgment and scientific analysis. Like other design-intensive disciplines, making effective decisions requires the perspective of experience and an understanding of solutions to similar problems in the past. However, these decisions also draw on analytic scientific principles such as economic models and formal analysis methods. Like other disciplines involving close teamwork, effective software development requires following a carefully structured process. However, quality ultimately comes not from following a fixed development process, but from tuning that process based on direct evaluation of the software artifacts we produce. Software engineering is also unique among other engineering disciplines. Software is design-intensive to a greater degree than any other engineering field; manufacturing costs are a very small component of product costs. While other disciplines may be based on physical laws and the continuous mathematics that govern them, software is symbolic, abstract, and primarily constrained by intellectual complexity. Because there are few physical limits on what software can do, there is constant pressure to innovate. This endless innovation in turn contributes to a level of complexity that exceeds any other engineered artifact, together with a greater pace of change than seen in any other engineering field. All these factors mean that while engineering principles from other fields apply, very different practices and tools are required to be effective in the software domain. Our curriculum design is founded in the Carnegie Plan for Education, which emphasizes teaching enduring principles along with immediate competency in the field. In order to instill in students the maturity, judgment, and independence to be lifelong learners, our curriculum focuses on reflective practice as a foundation for learning engineering skills. The topics we teach are driven not just by the needs of industry today, but by the long- term trends we have identified in the field: a movement towards systems that are larger, more interconnected, and more decentralized; an increase in the criticality of systems, be it for reasons of safety, security, or profit; and the increasing role of technologies and tools in system development. Pedagogical Goals The goal of the software engineering minor is to instill a core set of competencies in alumni of the program: • Solid computer science fundamentals, to the level of 15-211 plus 15-212 or 15- 213 • SE product competencies, including means of structuring systems (e.g. design patterns, frameworks, and architecture) and evaluating those systems (e.g. modeling, testing, and analysis) • SE organizational competencies, including teams and collaboration; negotiating with customers and other stakeholders to gather requirements; and management, estimation, and software engineering process • Understanding the larger context of software, and how engineering is driven by business, society, and policy considerations • Engineering maturity, in terms of making engineering tradeoffs with limited information and under resource constraints, working in teams, and following a process. Firsthand engineering experience is a necessary but not sufficient condition for this maturity • Effective communication skills, both written and oral Curriculum Requirements Prerequisites: These prerequisites are intended to establish a solid foundation in computer science. • 15-111:Intermediate/Advanced Programming (students with no prior programming experience take 15-100: Introductory/Intermediate Programming and 15-111) • 21-127: Concepts of Mathematics • 15-211: Fundamental Data Structures and Algorithms • 15-212 or 15-213 (rationale: ensures some software maturity) Core Course Requirements: 15-313 is intended to teach the basic product and organization competencies of the minor. 15-413 makes these competencies concrete and reinforces them through reflective engineering practice. These courses are new in 2007 but are intended to be core electives in Computer Science as well. • 15-313 Foundations of Software Engineering • 15-413 Software Engineering Practicum Technical SE Elective: One domain-independent course focused on technical software engineering material, to provide students with depth in the sciences underlying software engineering. Approved, existing courses include: • 17-606 Software Systems Security Engineering • 17-610 Risk Management for Software Intensive Projects • 17-619 Introduction to Real-Time Software and Systems • 17-651 Models of Software Systems • 17-652 Methods: Deciding What to Design • 17-653 Managing Software Development • 17-654 Analysis of Software Artifacts • 17-655 Architectures for Software Systems • 17-690 Seminar in Software Process Engineering Elective: One engineering-focused course with a significant software component, to provide students with a deeper engineering experience. Approved, existing courses include: • 15-437 Web Application Development • 15-540 Rapid Prototyping of Computer Systems • 15-610 Engineering Complex, Large-Scale Computer Systems • 17-643 Hardware for Software Systems • 18-649 Distributed Embedded Systems • 18-749 Fault-Tolerant Distributed Systems Computation, Organizations, and Society Elective: One course that explores computer science problems related to existing and emerging technologies and their associated social, political, legal, business, and organizational contexts. Approved courses are those listed in the proposal for an Undergraduate Minor in Computation, Organizations and Society (COS). Engineering Internship and Reflection. A software engineering internship of a minimum of 8 full-time weeks in an industrial setting is required. The student must be integrated into a team and exposed to industry pressures. The intern may work in development, management, quality assurance, or other relevant positions. The director of the SE minor program has sole discretion in approving an internship experience based on these criteria. Students should confirm that an internship position is appropriate before accepting it, but internships that fulfill the criteria will also be accepted after the fact. • 15-XXX Internship Reflection. 15-XXX is a new 6-unit course focused on critical reflection about the Internship. Each student will write an issue-focused reflection and analysis of some personal software engineering experience, typically (but not always) based on the engineering internship above. This report must be passed by one SCS faculty member and one SE Ph.D. student, for both technical content and effective written communication. Initial course meetings will cover the reflective, writing, and speaking process. In later meetings, each student will present his or her experience through a 30-45 minute talk, which will be evaluated for communication skills and critical reflective content. Note: there is a precedent for these activities in the SE Ph.D. writing and practicum requirements, and the CS Ph.D. speaking requirement. At most 2 of the courses used to fulfill the minor requirements may be counted towards any other major or minor program. Administration and Required Resources The program will be coordinated by the Director of the Software Engineering Minor Program, with assistance from one of the ISR administrative assistants (to be determined). The Director will meet with students in the program to advise them on courses, help them identify appropriate internships, approve course substitutions, and certify that they have completed the minor. The administrative assistant will keep a list of students enrolled in the minor and file the appropriate paper work with the HUB when they have completed their requirements. Of the core courses, 15-313 is being co-taught by Bill Scherlis and Jonathan Aldrich, who intend to teach the course again in 2008. 15-413 is being co-taught by Jeff Eppinger and Jonathan Aldrich this fall. All three core courses could be taught by any of the tenure- track faculty in software engineering, as well as the many experienced teaching track professors in the professional Master of Software Engineering program. The SE faculty is committing to teach these courses in the CS program regardless of this minor offering. Other electives are drawn from existing courses. While many of the electives listed are numbered at the masters level, many have a record of successful participation by undergraduates. In addition to teaching, administration, and advising, software engineering faculty and Ph.D. graduate students will be involved in evaluating written internship reflection reports. Given the number of SE-related faculty in ISR, and assuming less than 30 students per year in the major, this load should be reasonable, at 2 reports per faculty per year. Given the resource requirements of offering the minor (in particular, reading reports, identifying internship opportunities, and advising 15-413 teams), we will initially limit enrollment in the minor to 15 students per graduating class. Admission will be competitive, and handled similarly to admission to the HCII double major. Minors will have preference in registering for 15-413. We believe that it will be possible to raise the limit to around 30 students per year in the near future, but we plan to get at least a year’s worth of experience with the minor before committing to the higher number. Jonathan Aldrich has been asked to serve as director, pending approval of the minor. Implementation of the Minor We propose to advertise the minor to students immediately; the first students could conceivably (though with a heavy load) graduate in Spring 2008. As the minor reuses existing courses, there is no absolute minimum number of students, nor are there substantial startup resources required. However, we believe the minor should attract at least 5 students a year in the steady state to be worth continuing. The minor should easily scale up to 30 students per year as currently envisioned. Beyond that, we would likely have to either impose a limit on incoming students, or identify additional teaching and advising resources, as coordinating engineering internships and evaluating practicums could become too burdensome to existing faculty. Appendix: Software Engineering Minor Core Course Descriptions 15-313: Foundations of Software Engineering Students gain exposure to the fundamentals of modern software engineering. This includes both core CS technical knowledge and the means by which this knowledge can be applied in the practical engineering of complex software. Topics related to software artifacts include design models, patterns, coding, static and dynamic analysis, testing and inspection, measurement, and software architecture and frameworks. Topics related to software process include modeling, requirements engineering, process models and evaluation, team development, and supply chain issues including outsourcing and open source. This course has a strong technical focus, and will include both written and programming assignments. Students will get experience with modern software engineering tools and, later in the semester, create one of their own. Prerequisites • 15-211 • 15-212 or 15-213 (rationale: ensures some software maturity) Topics • Testing • Inspection • Design: principles, patterns, and frameworks • Static and dynamic analysis • Software architecture • Requirements engineering • Software lifecycle and process • Project and risk management • Special topics: e.g. security, open source, outsourcing Postconditions • Understand several common process models, why they are important and how to choose between them • Able to work effectively with design patterns and frameworks • Understand how to make tradeoffs among competing designs • Know how to effectively test code and inspect code and design documents • Have used a static analysis tool, and understand its benefits and limitations • Understand why software architecture matters and how to pick a good one • Familiarity with basic SE tools such as bug trackers, debuggers, source control, UML models • Know basic principles of requirements engineering and project management 15-413: Software Engineering Practicum Prerequisites: 15-313 (waived with permission of instructor, for students with appropriate background) This course is modeled after the successful MSE studio and MSIT practicum experiences used in the ISR software engineering masters programs. Students will carry out a semester-long project for a real client in small teams. A few lectures at the beginning of the course will introduce the process, tools, and documents to be used in the course, all of which will be specified by the instructors. Throughout the project, groups will be mentored through weekly team meetings with faculty. Teams will make regular presentations on the following topics: risk management, project planning, requirements, architecture, detailed design, quality assurance, final product presentations, and reflections on the experience. Teams will also deliver documents on each of the above topics. Evaluation will be based on the in-class presentations, process and product documentation deliverables, how well the teams follow SE practices as judged by their mentor, and finally the client’s satisfaction with the product. Individual grades within a team will be influenced by peer reviews, individual reflection documents, mentor impressions, and presentation performance. Students will leave the course with a firsthand understanding of the software engineering realities that drive SE practices. They will have concrete experience with these practices, and will have engaged in active reflection on this experience. They will have teamwork, process, and product skills to support immediate competency in a software engineering organization, along with a deeper understanding that prepares them to evaluate the new processes and techniques they will encounter in the workplace.