11:00 AM - 12:30 PM
Morning Technical Sessions
P1: Requirements and Risks - Location: Garden A

• University Meets Industry: Calling in Real Stakeholders - Slides
  Birgit Penzenstadler, Martin Mahaux, and Patrick Heymans
  (TU Munich, Germany; University of Namur, Belgium)
  Teaching the discipline of requirements engineering (RE) is slowly establishing at universities within the software engineering curriculum. While several studies have shown that case study-based education was more efficient in RE, many teachers are still reluctant to change their teaching style, and stay with classical lectures and complementary exercises. These courses often fail to relate the different steps and stages of RE to each other and do not address crucial communication and project management issues that are common in industrial RE practice. They also miss the chance for using the classroom as a near-to-real-settings research lab, and won't show students the stakes existing in doing engineering in our society. We describe our experiences in teaching RE with a case study in two universities, achieving a triple-win: putting students in contact with real stakeholders, showing students their responsibility towards a sustainable world and doing empirical research in the classroom. We report on the course design, the evaluation, the lessons learned, and the potential success factors for such courses. We conclude that case study-based approaches to teaching RE considerably improve skills valued by industry, are feasible at a reasonable cost, and are enjoyable for the students, the teachers and the stakeholders. With this paper, we want to encourage RE educators to implement such courses in their setting.
  
• Cooperating with a Non-governmental Organization to Teach Gathering and Implementation of Requirements - Slides
  Gregor Gabrysiak, Regina Hebig, Lukas Pirl, and Holger Giese
  (HPI, Germany)
  Teaching Requirements Engineering needs to be a realistic experience. Otherwise the students might not understand the repercussions of failing to gather requirements correctly. While simulated stakeholders are always a feasible option, only real stakeholders offer an authentic experience since only they are impacted by the system that is being specified. In this paper, we present our experiences of cooperating with the non-governmental organization (NGO) Wasserwacht. In a first requirements engineering course, nine graduate students elicited requirements by interviewing a dozen heterogeneous stakeholders. In a subsequent bachelor's project, four undergraduate students continued by implementing the software system based on these requirements. We discuss the authenticity of our requirements engineering setting, the influence of the collected requirements on the follow-up implementation project and how the Wasserwacht benefited from this cooperation.
  
• A Look at Software Engineering Risks in a Team Project Course - Slides
  Supannika Koolmanojwong and Barry Boehm
  (University of Southern California, USA)
  Risk identification, management, and mitigation are essential to the success of any software development projects. At the University of Southern California (USC), CSCI577ab is a graduate level software engineering course sequence that teaches the best software engineering practices, and allows students to apply the learned knowledge in developing real-client projects. This paper analyzes the risks encountered by teams, identifies the relationships between effective risk analysis and the success of the project, and discusses how risk patterns determine the students course of action. This paper also reports the top risks of software development in the software engineering class.
  

• Teaching Advanced Software Design in Team-Based Project Course
  Stan Jarzabek
  (National University of Singapore, Singapore)
  Skillful design remains one of the critical success factors in long-lived software projects. Design fundamentals have been established and are pretty stable. How do we teach design in-the-large to equip our graduates with design skills relevant to a plethora of changing software technologies and emerging new application domains? Today programs are built on top of functionalities provided by software platforms. Most often, developers extend existing systems rather than develop from scratch. Programming with application program interfaces (API) that allow newly written code to call middleware or existing application software has become a norm in software industries. While the details of API mechanisms heavily depend on a specific platform or application, the principles behind API design are universal, and can be taught in project courses designed for that purpose. Working knowledge of API design principles helps students faster adapt to new and changing technologies. In the paper, we describe a teaching methodology and 10 years of experiences teaching advanced design in a team-based software engineering project course. Our course builds around fundamental concepts in API design and use.
  
• A Competitive-Collaborative Approach for Introducing Software Engineering in a CS2 Class - Slides
  Swapneel Sheth, Jonathan Bell, and Gail Kaiser
  (Columbia University, USA)
  Introductory Computer Science (CS) classes are typically competitive in nature. The cutthroat nature of these classes comes from students attempting to get as high a grade as possible, which may or may not correlate with actual learning. Further, there is very little collaboration allowed in most introductory CS classes. Most assignments are completed individually since many educators feel that students learn the most, especially in introductory classes, by working alone. In addition to completing ``normal'' individual assignments, which have many benefits, we wanted to expose students to collaboration early (via, for example, team projects). In this paper, we describe how we leveraged competition and collaboration in a CS2 class to help students learn aspects of computer science better --- in this case, good software design and software testing --- and summarize student feedback.
  
• Understanding Individual Contribution and Collaboration in Student Software Teams - Slides
  Fabio Rocha and Eleni Stroulia
  (University of Alberta, Canada)
  Software development is an inherently team-based activity, and many software-engineering courses are structured around team projects, in order to provide students with an authentic learning experience. In these courses, student developers define, share and manage their tasks, relying on collaborative-development tools. These tools typically support all lifecycle activities and generate a detailed record in the process. Albeit not designed for this purpose, this record can provide the instructor with insights into the students' work, the team's progress over time, and the contributions and overall performance of each individual team developer. In this paper, we describe an analysis and visualization framework that we have developed to enable instructors to interactively explore the trace of the team's collaborative work, so that they can better understand the team dynamics, their activities and tasks, and the roles of the individual developers within the team. We have used our framework to analyze and understand how a student team worked through a term project. At the same time, we collected data about the students' own perception of their work processes through individual questionnaires and team interviews, and using grounded-theory analysis, we studied the human and social aspects of the student team behaviors. Our analyses suggest that the inferences supported by our framework are congruent with the individual-developer feedback, while there are some discrepancies with the reflections of the team as a whole.
  

• Project Selection for Student Involvement in Humanitarian FOSS - Slides
  Heidi J. C. Ellis, Gregory W. Hislop, and Michelle Purcell
  (Western New England University, USA; Drexel University, USA)
  Student involvement in Free and Open Source Software (FOSS) holds the potential to support a wide range software engineering education topics from requirements to design to testing and more. In addition, participation in a FOSS project exposes students to large, complex software projects and real-world development teams and environments like those that they will typically see after graduation. However, identifying a project appropriate for student involvement can be a difficult task. There are a huge number of possible FOSS projects with a wide range of sizes, complexity, and domains. The presenters of this workshop have developed an approach to FOSS project identification [1] which is based on several years of experience with student participation in FOSS projects. The approach is based on humanitarian FOSS (HFOSS) as those projects have been shown to motivate students [2]. During the workshop, key criteria for evaluating a FOSS project will be presented, along with a rubric. This workshop will interactively walk participants through the process of identifying and evaluating a project appropriate for their classes based on the criteria and rubric.
  

2:00 PM - 3:30 PM
Afternoon Technical Sessions
T2-1: Teaching Software Development Processes by Simulation - Quality Assurance as a Factor of Success - Location: Garden A

• Teaching Software Development Processes by Simulation: Quality Assurance as a Factor of Success
  Andreas Bollin, Elke Hochmuller, and Ladislav Samuelis
  (University of Klagenfurt, Austria; Carinthia University of Applied Sciences, Austria; TU Kosice, Slovakia)
  This half-day tutorial shows how a flexible simulation environment can link the various topic areas of software engineering in the same way they are interwoven in the daily work of practitioners. Based on the simulation goals, the participants act as project managers determining the simulated development process by adequate staffing and allocating software development as well as quality assurance tasks.
  

• Workshop on Revisions to SE 2004
  Mark Ardis, David Budgen, Gregory W. Hislop, Jeff Offutt, Mark Sebern, and Willem Visser
  (Stevens Institute of Technology, USA; University of Durham, UK; Drexel University, USA; George Mason University, USA; Milwaukee School of Engineering, USA; University of Stellenbosch, South Africa)
  We shall conduct a half-day workshop on needed revisions to Software Engineering 2004: Curriculum Guidelines for Undergraduate Degree Programs in Software Engineering (SE 2004). A brief overview of the current guidelines and their revision status will be presented. Workshop attendees will share their experience using the current guidelines and suggest needed changes. We will provide a summary report from the workshop to other CSEE&T attendees at a Birds Of a Feather meeting later during the conference.
  

4:00 PM - 5:30 PM
Late Afternoon Technical Sessions
T2-2: Teaching Software Development Processes by Simulation - Quality Assurance as a Factor of Success (cont.) - Location: Garden A

Workshop 1-2: Revisions to SE 2004 (cont.) - Location: Garden B

P3: Architecture and Design - Location: Hospitality (Ends at 6:00 PM)

• Teaching Software Design with Social Engagement - Slides
  Damian A. Tamburri, Maryam Razavian, and Patricia Lago
  (VU University Amsterdam, Netherlands)
  Software designers constantly mediate with various stakeholders, agree with requirement engineers and interact with coders. Software design is a socially-intensive activity. Teaching software design should be equally socially-intensive. However academic courses still lack a beneficial balance between theory, practice and social engagement. This paper provides details on how we address this problem in our course on software design. The course is designed to engage students with real-life projects and using peer-review sessions within collaborative team clusters. These instruments embed the social conditions of software design within the students' learning process. We show the effectiveness of the course by discussing student evaluations.
  
• Introducing Tool-Supported Architecture Review into Software Design Education
  Yuanfang Cai, Rick Kazman, Ciera Jaspan, and Jonathan Aldrich
  (Drexel University, USA; University of Hawaii, USA; Cal Poly, USA; CMU, USA)
  While modularity is highly regarded as an important quality of software, it poses an educational dilemma: the true value of modularity is realized only as software evolves, but student homework, assignments and labs, once completed, seldom evolve. In addition, students seldom receive feedback regarding the modularity and evolvability of their designs. Prior work has shown that it is extremely easy for students and junior developers to introduce extra dependencies in their programs. In this paper, we report on a first experiment applying a tool-supported architecture review process in a software design class. To scientifically address this education problem, our first objective is to advance our understanding of why students make these modularity mistakes, and how the mistakes can be corrected. We propose tool-guided architecture review so that modularity problems in students' implementation can be revealed and their consequences can be assessed against possible change scenarios. Our pilot study shows that even students who understand the importance of modularity and have excellent programming skills may introduce additional harmful dependencies in their implementations. Furthermore, it is hard for them to detect the existence of these dependencies on their own. Our pilot study also showed that students need more formal training in architectural review to effectively detect and analyze these problems.
  
• Archinotes: A Tool for Assisting Software Architecture Courses - Slides
  Juan Sebastian Urrego and Dario Correal
  (Universidad de los Andes, Colombia)
  During the last years, software architecture has become an increasingly necessary subject in IT education. At Universidad de los Andes, a software architecture course is taught midway through the Systems and Computer Engineering degree and aims to create skills within the student to identify quality requirements as well as designing software architectures for middle-sized systems. However, based on statistics over the last 8 years of our Software Architecture course, we've noticed that correctly identifying quality requirements seems to be a recurring issue among students. One of the course's objectives comprehends the construction of an architecture document during the semester, which must be done in groups who tend to find it difficult to get together and work as a team. This paper present Archinotes, a collaboration tool to support the teaching of software architectures by facilitating collaboration workload and providing useful information on the difficulties and progress of the students to the course's teacher. The conclusions of the paper prove Archinotes effective in helping students learn critical concepts and artifacts during the software architecture course.
  
• Teaching Object-Orientation with Smartphones as Digital CRC Cards - Slides
  Rainer Lutz, Sascha Schafer, and Stephan Diehl
  (University of Trier, Germany)
  Object-orientation is one of the essential parts of every software engineering course. However, according to literature, it often lacks the following: First, modeling on a conceptual level independent from a particular programming language is often neglected. Moreover, the actual process of designing or implementing a piece of software seems to be less important than providing an optimal solution. Finally, students often follow the slides of the teacher passively without thinking about or even questioning the material. But, in order to actively apply a proper form of object-orientation, it is essential that one understands the concepts of this programming paradigm and is able to deal with problems and communicate ideas rather than handling a specific programming language. In this paper we introduce CREWSpace-a tool for co-located collaboration that implements a digital version of the CRC method. To this end, students actively participate in so called CRC sessions, which fosters communication and problem solving skills. In particular, they design a software system on a conceptual level and use our tool to analyze and adjust the proposed design through role play. Moreover, CREWSpace records these analyses for a later replay such that the students are able to reflect on their decisions.
  Video: http://www.youtube.com/watch?v=_NuXue9crOM

11:00 AM - 12:30 PM
Morning Technical Sessions
P4: Introductory and Specialized Curricula - Location: Garden B

• Motivating and Orienting Novice Students to Value Introductory Software Engineering - Slides
  Daniel Port, Chris Rachal, and Jia Liu
  (University of Hawaii, USA; Nanjing University, China)
  Students with little professional software development experience typically have low intrinsic motivation and beyond achieving a good grade, low extrinsic motivation to study and appreciate the value of software engineering curricula. Unlike other subjects, introductory software engineering instructors exert a great deal of effort justifying and motivating their course topics. Since 2006 the University of Hawaii has been developing a series of early awareness engagements within an introductory Systems Analysis and Design course designed to foster intrinsic and extrinsic motivation and orient students to value learning software engineering. Measuring motivation and perceived value is difficult, but there are key indicators to determine the impact of our improvements such as higher course evaluations, greater class attendance, and increased positive feedback from students and employers. Our results show that these key indicators have improved since introducing early engagements. Furthermore, students like this approach, value the course more, do better quality work, and evaluate the course more positively. Longitudinal follow-ups indicate greater interest and success in pursuing software engineering related careers. This paper shares the details of our early awareness engagements, how they are applied in the classroom, some of our experiences in using them, and evidence of that they have a positive impact. Our goal is to provide specific and practical means that instructors can use immediately to improve the perceived value of software engineering for novice students prior to or while they study it.
  
• Using GSwE2009 in the Creation and Modification of Graduate Software Engineering Programs and Related Curricula - Slides
  Mark Ardis, Shawn Bohner, Lucia Camilloni, Diego Vallespir, and Sylvia Ilieva
  (Stevens Institute of Technology, USA; Rose-Hulman Institute of Technology, USA; University of the Republic, Uruguay; University of Sofia, Bulgaria)
  The current ACM and IEEE Computer Society recommended guidelines for graduate software engineering programs (GSwE2009) were created in 2009 by an international group of experts from industry, government and academia. We report here on some of the early experiences using GSwE2009 to create a new curriculum in software assurance and to create and/or improve 4 different academic programs in 3 countries. All of these experiences have been positive, confirming the validity and usefulness of GSwE2009.
  
• The Software Assurance Competency Model: A Roadmap to Enhance Individual Professional Capability - Slides
  Nancy R. Mead and Dan Shoemaker
  (SEI, USA; University of Detroit Mercy, USA)
  This paper describes a software assurance competency model that can be used by individual professionals to improve their software assurance skills. It can also be used by universities to align course content with skills needed in industry, and it can be used by industry to help employee professional growth as well as to screen prospective employees. The knowledge and skill areas in the competency model are based on the Master of Software Assurance reference curriculum that has been previously approved by the IEEE Computer Society and ACM. The model is aligned with a similar effort by the IEEE Professional Activities Board to develop a competency model for software engineering practitioners.
  

• Undergraduates and Research: Motivations, Challenges, and the Path Forward
  W. Eric Wong, Junhua Ding, Gene Fiorini, and Christian Hansen
  (University of Texas at Dallas, USA; East Carolina University, USA; Rutgers University, USA; Eastern Washington University, USA)
  At last year's conference, we organized a panel "Involving Undergraduates in Research: Motivations and Challenges" which was a great success with many interesting discussions. This has motivated us to develop a second iteration of this panel with an additional dimension - the Path Forward. We expect to have more discussions on how to extend what we have already learned from the past experiences to further enhance the way we involve undergraduates in doing research. Panelists will deliver a 5-minute overview of their research experiences with undergraduate students, including challenges they faced, lessons learned, and areas for improvement. The floor will then be opened for audience members to voice any concerns, questions, or comments. Student panel attendees will be given special consideration when presenting observations from their own perspective
  

• The Cost of Problem-Based Learning: An Example in Information Systems Engineering
  Vincent Ribaud and Philippe Saliou
  (UBO, France)
  High-quality education helps in finding a job - but student skills heterogeneity and student reluctance to move towards a professional attitude are important barriers to employability. We re-engineered some of the technical courses of a Masters in software development using a Problem-Based Learning (PBL) approach. Although initial results are encouraging, the cost of using PBL must be taken into account. Two aspects are particularly expensive: (i) set-up of the software development practicum, a mid-sized information system and its environment; (ii) screenwriting of problem-based learning scenarios, including procurement of input artefacts.
  
• Team Characteristics for Maximizing the Educational Effectiveness of Practical Lectures on Software Intensive Systems Development
  Shota Inaga, Hironori Washizaki, Yusuke Yoshida, Katsuhiko Kakehi, Yoshiaki Fukazawa, Shoso Yamato, Masashi Okubo, Teruhiko Kume, Manabu Tamaki, and Toshikazu Kanou
  (Waseda University, Japan; University of Tsukuba, Japan; NEC, Japan)
  In practical lectures on software intensive business systems, we do not yet have an established method for determining what kind of personal characteristics and team compositions are most beneficial to obtaining the maximal educational effectiveness. Here, we propose a framework for analyzing the effects of personal characteristics of team members on educational effectiveness. We also apply the framework to an actual practical lecture. As a result, we find that it is better for a team to have members with a similar degree of tendency of conservative for acquiring more knowledge and skills and the team members have similar characteristics of progressive or conservative. It is expected that in similar practical lectures, we can also obtain the desired educational effectiveness if we can compose a team with the suitable characteristics as based on our findings.
  
• Towards a Model of Faculty Development for FOSS in Education
  Heidi J. C. Ellis, Gregory W. Hislop, Michelle Purcell, Mel Chua, and Sebastian Dziallas
  (Western New England University, USA; Drexel University, USA; Purdue University, USA; Olin College, USA)
  Free and Open Source Software (FOSS) has become an important segment of the computing industry and a source of innovation in software development. The open culture of FOSS projects where all project artifacts are accessible and communication is visible provides computing educators with an array of unique opportunities for student learning. However, FOSS projects can also present hurdles to instructors desiring to take advantage of these opportunities including the learning curve for FOSS culture, infrastructure and processes, difficulties in designing appropriate assignments, and more. This paper presents a model for faculty development based on experiences with prior academic and FOSS approaches to faculty development.
  
• Toward Infusing Modular and Reflective Design Learning throughout the Curriculum
  John C. Georgas
  (Northern Arizona University, USA)
  Design is a core activity in computer science and software engineering, but conventional curricula do not adequately support design learning since they isolate the explicit study of design to only a few select courses. This paper reports on our initial efforts toward addressing this challenge through an intervention focusing on the modular deployment of design challenges and design stories throughout the curriculum: Design challenges allow learners to work through open-ended problems, which is followed by the creation of a design story narrative through the use of a structured reflection framework. Our intervention strategy is intended to be easily adoptable within existing curricular structures and leverages reflective-learning theories.
  
• Analyzing Coordination among Students in a Software Engineering Project Course
  Bonnie K. MacKellar
  (St. John's University, USA)
  Coordination among developers has long been recognized as critical in software projects. One of the reasons for running large project software engineering courses is to teach students how to coordinate while working in a group; yet we have little understanding of how the students might fail or ways to assist them in learning this skill. Socio-technical congruence is a way to measure coordination based on the fit between communications among developers and the dependencies of the project. In this work-in-progress paper, we use a measure of socio-technical congruence to analyze the coordination in a student software engineering team. We found that congruence did not improve over time as has been shown for professional software teams. We then describe a proposed tool that uses socio-technical congruence measures to support and give advice to students who are learning how to effectively coordinate activities on a group project.
  
• Guidance for Exploratory Testing through Problem Frames
  Shreya Kumar and Charles Wallace
  (Michigan Tech, USA)
  Exploratory testing is a well-established, industry-adopted process of investigation and discovery, which employs human creativity to gain deep insights into a software product. It is authentic, rigorous, and enjoyable, making it an excellent topic for an undergraduate software engineering course. However, it is difficult to explain to the beginner how to generate a successful exploratory strategy. Case studies and lessons learned from practitioners illustrate the value of exploratory testing but do not necessarily reveal the motivation for a particular exploratory tour. Here we discuss the use of problem frames as a means of guiding students toward promising testing strategies. Problem frames were originally proposed as a requirements analysis approach, carefully locating and bounding software problems to be solved, then matching subproblems to commonly occurring problem patterns or frames. A natural extension to that idea is to associate test strategies with particular frame concerns, guiding the student toward exploratory techniques that are well-suited to the frame. Once students become confident exploratory testers, they can add their own strategies to a growing body of knowledge. To illustrate the approach, we consider frame concerns and test strategies for workpieces problems, using Google Calendar as our test subject
  
• Test-Driven Learning in High School Computer Science
  Ryan Stejskal and Harvey Siy
  (University of Nebraska at Omaha, USA)
  Test-driven development (TDD) is an accepted practice in the software development industry. Although computer science teaching programs have been slower to adopt test-driven practices, test-driven learning has been used in a number of universities with generally positive results. The use of test-driven learning at the high school level is less studied. We introduce and assess the benefits of using test-driven learning in a high school Advanced Placement (AP) computer science course. This course is a strong candidate for the introduction of TDD. The Java language used in AP computer science is well-supported by TDD tools, and the concepts of TDD show promise in helping students develop the ability to analyze problem statements and develop programs. Preliminary results indicate that students respond well to the use of TDD tools to complement other teaching techniques in AP CS.
  
• Bringing Undergraduates to the Web: Baby Steps in Webifying a Software Engineering Curriculum
  Matti Luukkainen and Arto Vihavainen
  (University of Helsinki, Finland)
  Software engineering has evolved greatly during the last couple of decades. The methodologies for organizing software engineering projects, as well as the technologies for building software have changed dramatically. However, this evolution is seldom reflected in the software engineering-related education provided by research-oriented computer science departments. Many traditional research-oriented universities continue to teach using the "talking head"-approach, where students are expected to absorb information out of the atmosphere in the lecture halls. In this paper, we describe our work towards "webifying"" a software engineering curriculum, where learning by doing plays a key role.
  
• A Project Spine for Software Engineering Curricular Design
  Kevin Gary, Timothy Lindquist, Srividya Bansal, and Arbi Ghazarian
  (Arizona State University, USA)
  Software engineering education is a technologically challenging, rapidly evolving discipline. Like all STEM educators, software engineering educators are bombarded with a constant stream of new tools and techniques (MOOCs! Active learning! Inverted classrooms!) while under national pressure to produce outstanding STEM graduates. Software engineering educators are also pressured on the discipline side; a constant evolution of technology coupled with a still emerging engineering discipline. As a hands- on engineering discipline, where engineers not only design but also construct the technology, guidance on the adoption of project-centric curricula is needed. This paper focuses on vertical integration of project experiences in undergraduate software engineering degree programs or course sequences. The Software Enterprise, now in its 9th year, has grown from an upper-division course sequence to a vertical integration program feature. The Software Enterprise is presented as an implementation of a project spine curricular pattern, and a plan for maturing this model is given.
  
• Essence: A Framework to Help Bridge the Gap between Software Engineering Education and Industry Needs
  Pan-Wei Ng and Shihong Huang
  (Ivar Jacobson Int., Singapore; Florida Atlantic University, USA)
  Given the time limit, software engineering courses in universities can only emphasize a particular development approach or method; therefore, it is challenging to prepare graduates to face the diverse range of approaches and methods used by industry. One of the issues software engineering education faces is the lack of a framework to understand and compare the similarities and differences among diverse practices used by different companies versus what students learn at school. Software Engineering Methods and Theory (SEMAT) is a new international initiative that bridges the gap among industry, education and research. SEMAT latest result is the submission to OMG standard, namely the Essence Kernel and Language for Software Engineering. Instead of teaching diverse range of software engineering development methods, Essence provides a novel way of thinking of the different software development methods and approaches. This paper discusses the value of Essence to software engineering education and the preliminary feedback from university professors and lecturers.
  
• Teaching Software Processes to Professionals: The Approach Taken by an Evening Master's Degree Program
  Yadran Eterovic, Gemma Grau, and Jorge Bozo
  (Pontificia Universidad Catolica de Chile, Chile)
  As part of an evening master's degree program, we need to teach software processes in nine weekly sessions to professionals who work in software development but who have no formal education in software engineering. We have done this successfully for the past few years by a) dividing class time into lectures, supervised student work, and student presentations; and b) evaluating the students based on their analysis of a real software development project, from the perspective of the project?s process. Getting the students more involved in their classmates? projects is still a challenge.
  
• Killer App: A Eurogame about Software Quality
  James H. Andrews
  (University of Western Ontario, Canada)
  Games can be effective teaching tools, if the games simulate faithfully some aspect of the material being taught. Eurogames are a recent genre of games that allow for effective simulation of tradeoffs and competing strategies for achieving the same end. We have developed Killer App, a Eurogame which is focused on software development and on software quality tradeoffs. Here we report on the design of Killer App, our early experience in playtesting it with both programmers and non-programmers, and our experience of using it in a senior-year software quality assurance course.
  
• What Makes It Hard to Teach Software Engineering to End Users? Some Directions from Adaptive and Personalized Learning - Poster - Slides
  Sridhar Chimalakonda and Kesav V. Nori
  (IIIT Hyderabad, India)
  Today, software is being co-designed, co-developed, co-maintained and customized by professionals from a wide range of other disciplines and end users from varied and different backgrounds in addition to software engineers. While there is extensive research on facilitating and supporting end users to write better software, there is sparse research on better ways of educating them with software engineering (SE) knowledge. On the other hand, learning domain has recognized the need for adaptive and personalized learning (APL) and developed numerous approaches, methods and tools to address that need. The main purpose of this paper is firstly to expose some challenges of teaching SE to end users with an aim of understanding learning needs of end users. We then present a brief overview of APL domain and an ontology based framework for integrating APL with software engineering education (SEE). We then discuss a brief example of end users from adult literacy followed by some future directions towards delivering personalized SEE.
  

2:00 PM - 3:30 PM
Afternoon Technical Sessions
P5: Processes and Distributed Development - Location: Garden B

• Applying Competitive Bidding Games in Software Process Education - Slides
  Guoping Rong, He Zhang, and Dong Shao
  (Nanjing University, China; NICTA, Australia; UNSW, Australia)
  In order to enhance the understanding of important concepts and strengthen the awareness of software process, students need to learn from their experiences in process-specific project practices. However, it?s often difficult to design and carry out such practices in tertiary education environment. Typical challenges may include: 1) the difficulty to separate process-specific project practices from other (e.g., technical) practices in a software project, which may result in students paying more attention on technical aspects than process-specific aspects. 2) The limitation of a habitual technical-alone perspective may neglect concerns of other project stakeholders (e.g., project owner). We designed a special project-practicing course in Nanjing University as an attempt to solve these issues. The course is composed of 6-hour lecture and 32-hour bidding game. We found several positive results with this new education approach on process-specific practicing course. For example, it was short and flexible, which is easy to be placed in a regular semester. Besides, students were also forced to pay close attention only to process-specific aspects of the practice project. What's more, students were able to think from different perspectives, e.g., the senior management and customers.
  
• Using Distributed Software Development in the Improvement of Communication and Collaboration Skills in SE Courses: An Observational Study - Slides
  Luiz Leandro Fortaleza, Sergio Roberto Costa Vieira, Olavo Olimpio Matos, Jr., Rafael Prikladnicki, and Tayana Conte
  (UFAM, Brazil; Fucapi, Brazil; PUCRS, Brazil)
  Communication and collaboration skills are very important for Software Engineering practitioners. The practitioner who possesses these skills, as well as solid technical knowledge, will possibly perform his activities in a more efficient way. Generally, people acquire these skills through experience. However what can happen when we emphasize training this kind of skills during Software Engineering courses? Practitioners might get better prepared to the market expectations in lesser time, which could reduce training costs in the industry. In this paper we present an observational study aiming to allow a better understanding on how can communication and collaboration skills be improved by using Distributed Software Development (DSD). In the literature, we found previous researches that indicate a relationship between DSD and the improvement of skills. We use these researches as basis for our study. After a qualitative analysis of the data, we identified that, in the context of our experiment, the use of DSD in classroom accelerated the adoption of communication and collaboration practices and it can improve these skills
  
• Picking the Right Project: Assigning Student Teams in a GSD Course
  Ivana Bosnic, Igor Cavrak, Marin Orlic, and Mario Zagar
  (University of Zagreb, Croatia)
  This paper describes the process of assigning students to project teams in a global software development course. Project proposals vary in several characteristics in order to provide students from two universities, who have highly heterogeneous knowledge, a wide range of choices. Students submit an initial questionnaire about their skills, together with ranked project preferences. Based on 24 projects and 155 students in last three years of the course, project types and criteria such as students knowledge of programming languages or development platforms are analyzed and presented.
  

• Software Engineering Education via the Use of Corporate-Sponsored Projects: A Panel Discussion of the Approaches, Benefits, and Challenges for Industry-Academic Collaboration
  Linda Werner, Geoff Kuenning, Mark Sebern, James Vallino, and W. Eric Wong
  (UC Santa Cruz, USA; Harvey Mudd College, USA; Milwaukee School of Engineering, USA; Rochester Institute of Technology, USA; University of Texas at Dallas, USA)
  In this panel, we will address questions regarding the development and execution of one type of industry-academic collaboration corporate-sponsored projects. As representatives of programs at both public and private institutions, we will address a set of questions related to these programs. We have prepared an initial list that will be augmented with questions submitted and voted on by conference participants in advance of the session. After we have presented our prepared responses, the balance of the session will be dedicated to open discussion with audience members.
  

• Positive Transitions from the Classroom to the Cubicle: Creating Strategies for Augmenting Professional Development in the Software Engineering Curriculum
  C. Shaun Longstreet and Kendra M. L. Cooper
  (Marquette University, USA; University of Texas at Dallas, USA)
  Engineering ethics often receives attention in separate courses or modules, however other critical elements of professionalism are not directly addressed in a curriculum. Graduates coming to industry frequently lack proficiency in vital skills such as being adept in appropriate interpersonal communications, quickly adapting to industry protocols, and effectively acclimating to corporate hierarchy, culture and accountability. Many programs assume that professionalism is indirectly socialized through faculty modeling and classroom management. Such an assumption does not serve our students well, or the SE industry that hires them and then must put a tremendous effort into new employee orientation to create a productive work environment. This highly interactive tutorial provides practical resources for those who seek to introduce professionalism education into the SE curriculum but cannot create whole new courses devoted to the subject. Participants who will come away with concrete plans to assess, create, and integrate professional development opportunities into their academic Software Engineering curricula or industry training programs. Participants will reflect on their own context, they will engage peers and facilitators through a series of cases in small groups, while working on their individual strategic plan that will work best for their own campus. This tutorial is a fertile opportunity for SE educators, advisors, administrators and representatives from SE undergraduate professional societies who want to respond to a vital concern for many campuses.
  

4:00 PM - 6:00 PM
Late Afternoon Technical Sessions
P6: Agile Methods - Location: Garden A

• Scrum in a Software Engineering Course: An In-Depth Praxis Report
  Andreas Scharf and Andreas Koch
  (University of Kassel, Germany)
  Working in a team for a limited period of time and to deliver a high quality product are some of the skills students should gain during their studies at the university. Therefore universities should offer software engineering courses teaching agile methodologies broadly used in the industry as well. These courses need to simulate a real world working environment introducing agile methods like XP or Scrum. We present the design of our Scrum based undergraduate course Software Engineering 1, provide in-depth information about important course details and also give recommendations for tools we find useful. Unlike other software engineering courses we have a large staff of up to 11 supervisors allowing us to simulate close to real world working conditions. We provide every team with a tutor who is responsible for observing his team and answer questions. Additional research assistants are playing the role of customers.
  
• Academic Education of Software Engineering Practices: Towards Planning and Improving Capstone Courses Based upon Intensive Coaching and Team Routines - Slides
  Christoph Johann Stettina, Zhao Zhou, Thomas Back, and Bernhard Katzy
  (Leiden University, Netherlands; CeTIM, Netherlands)
  Academic education of professional processes is challenged by a necessary balance of practical activities with academic reflection. In this paper we address this issue by discussing our experiences with teaching software engineering practices and their continuous improvement. By designing a graduate course we embed an intensive coaching routine based upon agile practices with research activities to leverage knowledge of students and coaches. As a concrete example of an embedded research project we conduct an experiment on the impact of two different meeting routines on the teams satisfaction with information exchange. Our results show that the intensive coaching in individual teams is shorter in nature and more appealing to the students. Our findings suggest that software engineering education can benefit from the notion of team routines and process improvement practices contributing to maturity of students and educators.
  
• Teaching Agile Software Development at University Level: Values, Management, and Craftsmanship - Slides
  Martin Kropp and Andreas Meier
  (FHNW, Switzerland; ZHAW, Switzerland)
  Agile methodologies have come a long way over the last decade. Several recent surveys show that agile methodologies like Scrum, Extreme Programming and, more recently, Kanban have been successfully adopted by many companies to develop their software. However, the same surveys show that only few of the agile practices are used and even fewer are applied consequently and thoroughly. This is to a great extent due to the lack of skilled personnel. Although teaching agile software development has drawn some attention in recent research and has been discussed in several papers, we do not yet seem to be able to deliver the appropriately skilled personnel. What is the reason for this, and more importantly, how can we improve the situation? In this paper we propose a more holistic approach for teaching agile software development, in which the required agile practices and values are not only integrated theoretically into our courses but also practically applied and repeated until they become a habit to our graduates. The proposed concept was realized in a new Software Engineering course held at Zurich University of Applied Sciences during 2012. The evaluation shows very encouraging results, but also leaves some challenges and problems to be solved.
  
• A Double Comparative Study: Process Models and Student Skills - Slides
  Paolo Ciancarini, Caroline Dos, and Sara Zuppiroli
  (University of Bologna, Italy)
  We report on a recent experience in our Software Engineering laboratory course. More than one hundred students, from two different degrees, were divided in teams grouping diverse competences and skills, and had to develop four software products using a process model chosen among Waterfall, Spiral, and Extreme Programming. The two degrees involved were Computer Science and Informatics for Management. The former students have a standard, strong, background in programming, systems, and algorithms, while the latter students have a weaker training in programming compensated by some courses in Economics and Management. This situation allowed us to perform a double comparative study: on one hand, analyzing the laboratory results we obtained a comparison of the process models, which reproduced some results already known in literature. On the other hand we could compare on the field the different skills of students following different curricula, especially with respect to the requirements of the different process models. We discuss the results of this experience.
  

• Software Enterprise Pedagogy for Project-Based Courses
  Kevin Gary, Srividya Bansal, and Arbi Ghazarian
  (Arizona State University, USA)
  The Software Enterprise is a pedagogical model that combines traditional lecture with project-based learning. The Enterprise model leads students through a modular series of lessons that combine foundational concepts with skills-based competencies. In this tutorial, software engineering educators in higher education or industry will learn the methodology, get exposed to assessment techniques such as e-portfolios and concept maps, and become familiarized with the open resources available to educators that adopt the pedagogy. This tutorial should be of interest to any educator interested in making their project-based courses more engaging and more relevant to students needing to be ready to practice the profession from the first day they exit the Enterprise environment.
  

11:00 AM - 12:30 PM
Morning Technical Sessions
ASEE&T - Location: Garden A - Intro Slides - Notes

• Model-Driven Development and the Future of Software Engineering Education - Slides
  Tony Cowling
  (University of Sheffield, UK)
  This paper argues that the research area of model-driven development is likely to lead before long to tools being produced that will automate most of the construction activity within software development processes. It therefore discusses the impact that such developments would have on the software engineering curriculum, in terms of both the body of knowledge and the structures of courses, drawing on analogies with the impact during the 1960s of the development of problem-oriented programming languages and compilers for them.
  
• Education Impact of Evolutionary Software Development
  Vaclav Rajlich
  (Wayne State University, USA)
  The paradigm shift from waterfall to evolutionary software development (that includes agile development) has been widespread in industry, but academia is still struggling with it. This position paper reiterates the reasons for the paradigm shift that illustrate the importance of the shift. The position paper then discusses what the shift means for the software engineering education. As an example, it briefly presents how software engineering is taught at Wayne State University.
  
• What Should Students Learn in Their First (and Often Only) Software Engineering Course? - Paper - Slides
  James Vallino
  (Rochester Institute of Technology, USA)
  The questions that are proposed as the basis for academy panel sessions are important ones to ask. In the aggregate, they cover an enormous expanse of the software engineering landscape. The reality of undergraduate computing education is that the vast majority of students do not go through software engineering curricula where there is time to address the academy questions in some depth. Instead, they are in computer science or computer engineering programs, and receive their software engineering education in a single course. What students should really learn in this first, and often only, software engineering course is important because the majority of computing students will not see any other software engineering. The course designer will need to make judicious choices in selecting the material for this course because all of software engineering will not fit in just one course even if you try by using one of the classic software engineering tomes as the textbook. I do not know the right answer to the question I pose in the title of this position paper. I suspect that there is no one set of software engineering topics that should be included, but rather a range of topics to select from based on the purpose and perspective of the course. The answer to this question is important to everyone who has responsibility for providing the software engineering education for the next generation of computing students.
  
• Software Engineering in CS 2013 - Slides
  Richard LeBlanc
  (Seattle University, USA)
  This paper discusses how software engineering topics are included in the CS2013 Curriculum Guidelines and presents several challenges to be addressed in collaboration with the software engineering community before final publication of the CS2013 volume.
  

• Adding Software Testing to Programming Assignments - Materials
  Stephen H. Edwards
  (Virginia Tech, USA)
  This tutorial provides a practical introduction to how one can incorporate software testing activities as a regular part of programming assignments, supported by live demonstrations, with a special focus on early introduction in CS1 and/or CS2 courses. It presents five different models for how one can incorporate testing into assignments, provides examples of each technique, and discusses the corresponding advantages and disadvantages. The focus is on unit testing, test-driven development, and incremental testing, all of which work well in a classroom environment. Examples will use Java, although participant discussion regarding support in other languages such as Python and C++ is welcome. Approaches to assessment-using testing to assess student code, assessing tests that students write, and automated grading-are all discussed. A live demonstration of automatic assignment grading based on student-written tests is included. Advice for writing "testable" assignments is given. Participant discussions are encouraged.
  

2:00 PM - 3:30 PM
Afternoon Technical Sessions
P7: Programming within Software Engineering - Location: Garden A

• Explorable Code Slides
  Michael Fritz, Benjamin Biegel, and Stephan Diehl
  (University of Trier, Germany)
  Presenting source code to others is not only a typical task of computer science teachers, but also when practitioners as well as researchers in software engineering are faced with this task. Usually, classical presentation tools or source code editors are used for such presentations. However, while the former are too inflexible for the presenter to deviate from a preplanned scheme, the latter show too many irrelevant details to the audience. In this paper, we introduce Explorable Code Slides, which address both issues. We not only describe its concept and features but also report on our practical experience from using Explorable Code Slides in class and feedback gathered from our students.
  
• A Spirit of Camaraderie: The Impact of Pair Programming on Retention
  Zhen Li, Christopher Plaue, and Eileen Kraemer
  (University of Georgia, USA)
  We conducted a quasi-experimental study of pair programming versus solo programming, in the context of a required, four-hour, intermediate level-course that focuses on the acquisition of a second language (C/C++). We found pair programming served as a protective factor for the retention of female students and less experienced students. Our findings support those of prior studies that suggested that pair programming may improve retention for female students and also suggest that pair programming strategies may help to shorten the long pre-requisite chain typically found in CS programs, reduce time to degree, and promote student productivity during undergraduate studies. We also found that solo programmers relied more heavily on TA assistance, which implies that resource-constrained departments might better meet student needs or handle larger groups of students with existing resources through the use of pair programming.
  
• Designing Grace: Can an Introductory Programming Language Support the Teaching of Software Engineering? - Slides
  James Noble, Michael Homer, Kim B. Bruce, and Andrew P. Black
  (Victoria University of Wellington, New Zealand; Pomona College, USA; Portland State University, USA)
  Many programming language constructs that support software engineering in the large --- explicit variable declarations, explicit external dependencies, static types, information hiding, invariants --- provide little benefit to the small programs written by novice programmers, where every extra syntactic token has to be explained and understood before novices can succeed in running even the simplest program. We are designing Grace, a new educational object-oriented language that we hope will prove useful for teaching both programming and software engineering. This paper describes some of the tradeoffs between teaching programming and teaching software engineering that we faced while designing Grace, and our attempts to address those tradeoffs.
  

4:00 PM - 5:30 PM
Late Afternoon Technical Sessions
P8: Formal Methods and Testing - Location: Hospitality

• Specification and Reasoning in SE Projects using a Web IDE - Slides
  Charles T. Cook, Svetlana V. Drachova-Strang, Yu-Shan Sun, Murali Sitaraman, Jeffrey C. Carver, and Joseph Hollingsworth
  (Clemson University, USA; University of Alabama, USA; Indiana University Southeast, USA)
  A key goal of our research is to introduce an approach that involves at the outset using analytical reasoning as a method for developing high quality software. This paper summarizes our experiences in introducing mathematical reasoning and formal specification-based development using a web-integrated environment in an undergraduate software engineering course at two institutions at different levels, with the goal that they will serve as models for other educators. At Alabama, the reasoning topics are introduced over a two-week period and are followed by a project. At Clemson, the topics are covered in more depth over a five-week period and are followed by specification-based software development and reasoning assignments. The courses and project assignments have been offered for multiple semesters. Evaluation of student performance indicates that the learning goals were met.
  
• An Empirical Study of the Effects of Personality on Software Testing - Slides
  Tanjila Kanij, Robert Merkel, and John Grundy
  (Swinburne University of Technology, Australia; Monash University, Australia)
  The effectiveness of testing is a major determinant of software quality. It is believed that individual testers vary in their effectiveness, but so far the factors contributing to this variation have not been well studied. In this study, we examined whether personality traits, as described by the five-factor model, affect performance on a software testing task. ICT students were given a small software testing task at which their effectiveness was assessed using several different criteria, including bug location rate, weighted fault density, and bug report quality. Their personality was assessed using the NEO PI-3 personality questionnaire. We then compared testing performance according to individual and aggregate measures against different five-factor personality traits. Several weak correlations between two of these personality traits, extraversion and conscientiousness, and testing effectiveness were found.
  
• Automated Evaluation of Regular Lab Assignments: A Bittersweet Experience? - Slides
  Pavel Jezek, Michal Malohlava, and Tomas Pop
  (Charles University, Czech Republic)
  Our undergraduate curriculum includes a one semester course on object-oriented programming in the C# language and the .NET platform. The course underwent a major change in its labs organization two years ago - an introduction of regular one-week lab assignments motivated by a need to enhance unsatisfactory skills of students attending the course. However such change of the course scheme would not be possible without introduction of an automated evaluation system of the lab assignments. Besides the expected positive results, we were worried about any unforeseen consequences of the change. Having enough data from before and after the change of the course scheme the paper presents a unique analysis of impact of such a change on students and the course itself. The paper provides two main contributions: (1) to our best knowledge, we provide the first empirical validation of expected impacts on real-world data and (2) we identify and discuss several unexpected aspects and drawbacks of introduction of such a new scheme.
  

• Recent Trends in Graduate Software Engineering - Slides
  Mark Ardis, Shawn Bohner, Dick Fairley, Dennis Frailey, Tom Hilburn, Gregory W. Hislop, and Todd Sedano
  (Stevens Institute of Technology, USA; Rose-Hulman Institute of Technology, USA; Colorado Technical University, USA; Southern Methodist University, USA; Embry-Riddle Aeronautical University, USA; Drexel University, USA; Carnegie-Mellon University Silicon Valley, USA)
  This panel will discuss recent trends in graduate software engineering programs, including adoption of GSwE2009, cooperative programs between schools, increasing use of distance education formats, and specialization of programs for industry partners. Panelists will also discuss the evolving relationship of software engineering to other disciplines, such as computer science and systems engineering.