Security in Agile Development: Pedagogic Lessons from an Undergraduate Software Engineering Case Study

Security affects every software component in different types of computing systems. Many vulnerabilities and attacks on software systems are due to security weaknesses in the software itself. During the process of software specification, development, or testing, security issues are either taken into consideration insufficiently or not at all. Such software, due to internal weaknesses is prone to new attacks. By teaching secure software engineering techniques for designing and developing software modules, students would learn systematic secure software development techniques, such as defect detecting and security testing. This paper presents a series of modules that are designed to be integrated into undergraduate software engineering courses from a security perspective. The goal of the modules is to teach the building of robust software security requirements, secure software design and development, and secure software verification through a secure software development lifecycle.

This study presents a case study of the integration of usability evaluation into the development of task based information system prototypes in undergraduate software engineering course projects within a problem-based learning (PBL) approach. As part of the course, usability evaluation was integrated into the software development process, and the usability evaluation performance (UEP) of the projects was assessed in terms of the following criteria: effectiveness, efficiency and problem validity. It also analyzed the problem solution rate of the projects and their correlation between UEP criteria. Additionally, the study in-depth analyzed the students' final conclusions regarding the design process. The relationship between UEP criteria and the problem solving rate was examined using Spearman correlation analysis. In addition, final conclusions and problem solving behaviors were analyzed through document and thematic analysis techniques. The results supported that there is a significant correlation between usability evaluation criteria and problem solving rate. The main themes that emerged regarding usability problem solving behaviors were navigation design, error handling, database connection, algorithm design, search matching, system-user communication design and others. Final conclusions showed that project teams gained valuable insights into user-centered design, solved critical usability problems and improved their prototype design. It can be concluded that the integration of usability into software engineering education using the above approach contributes to students' understanding of user-centered interaction design.

In this paper we describe our initiative to incorporate research, professional practice and methodologies into two undergraduate software engineering courses. As part of the Undergraduate Research Experience (URE) initiative on our campus, we modified two of our core software engineering courses. In our Software Development II (junior level) and Software Development Project (senior level) courses we integrated research projects, corporate visits and research talks to develop a deeper understanding of software engineering research and practice amongst our students.

This paper describes a research program on the introduction of globally distributed teams into undergraduate software engineering courses. A pilot study, now completed, involved students at a single institution using two different virtual environments while cooperatively developing requirements artifacts in 3-person virtual teams. We describe the results of this pilot study and the plans for its extension to a three-year multi-institution, multi-culture, and multi-language setting.

Software engineering has been taught over the years using expositive classes, but learning this discipline requires more than just theory. Lately, universities started teaching software engineering in a theoretical-practical way. Typically, these experiences involve the development of software projects in the academia, using industry-oriented or ad hoc processes. However, most of them are not fully formalized, therefore it is not possible to repeat, measure or improve them. Moreover, it is not clear which project contexts are proper for each ad hoc process. This thesis work proposes to define and formalize a prescriptive software development process for use in undergraduate software engineering courses. We hypothesize that this process can make these experiences repeatable investing an affordable effort and will help produce positive results in student projects. This software process will be evaluated in the context of a second software engineering undergraduate course at the University of Chile, and it will address specific project contexts. This software process could be used in any university that has a similar course context. The proposed process can also be adapted to fit with new contexts.

In order to develop students for successful careers in software engineering, specifically for software development, they must not only be immersed in the software development lifecycle and paradigms, but also in the workings of large project teams. Currently, most undergraduate software engineering courses are taught by presenting the concepts and methodologies and assigning fragmented 3-4 person group projects. In the Department of Computer Science at Georgetown University, a two-course approach to undergraduate software engineering education has been developed that incorporates the practical application of coursework in a large team setting. The first course presents a firm software design basis, while the second course demonstrates corporate-level software engineering concepts with a semester-long software development simulation where the entire class is the development team. This paper presents the experiences from offering this software engineering simulation approach.

Experiences provide computer science majors need to mirror the typical situation a student will encounter after graduation. The frustration as well as the benefit of working in a group can only be appreciated if experienced first hand. This has made the introduction of software engineering concepts into the traditional computer science curriculum an invaluable component in all computer science courses.The use of Software Engineering - A Practitioner's Approach (SEPA) in an undergraduate software engineering course taught at Montclair in the Spring of 1997 was an attempt to expose the students to situations as typical of real-world conditions as possible. In assessing the impact of this approach on undergraduate software education, I concluded that the SEPA can provide a rich and significantly worthwhile experience for students as the students in this course had very positive feedback regarding the course.

Peer Instruction (PI) is an active learning pedagogy in which students actively participate in the classroom. There have been several research studies regarding the value of PI in computer science. The present work adds to this body of knowledge by examining outcomes from an undergraduate software engineering course with specific focus on the effects of PI on student learning in the topics of unit testing, integration testing and continuous integration. We find encouraging increases in levels of success as measured through a cognitive pre- and post-course survey for those topics. This work also documents and hypothesizes reasons for the cognitive gains from PI, as well as student attitudes towards PI.

Software engineering education is challenged by the need to convey practical experience in the context of a rich and large body of theoretical knowledge. This study investigates whether the use of open source projects can reduce the gap between theory and practice in undergraduate software engineering courses. Two qualitative case studies were conducted with students performing activities in an open source project, each one in a different course: software testing and software requirements. Results point out that the use of open source projects provides a concrete experience similar to industry experience, allows high cognitive engagement when performing tasks, favors understanding and content retention, and leads to the recognition of the usefulness of software engineering principles, techniques and methods.

In this paper, we describe a learning environment that is being used to engage and empower students' learning in a undergraduate software engineering course. The methodology is a joint of Problem Based Learning (PBL) with Learning by Teaching idea - someone can learn better if he has to teach someone else the same concept. In addition, the students must produce videos and questionnaires present their studies. In the last year and a half, the environment is been used and tested in different classrooms of the same discipline. Finally, we compare the performance of students in this period with the two years before the introduction of the methodology.

Too often, computer science programs offer a software engineering course that emphasizes concepts, principles, and practical techniques, but fails to engage students in real-world software experiences. The authors have developed an approach to teaching undergraduate software engineering courses that integrates client-oriented project development and open source development practice. They call this approach the Client-Oriented Open Source Software (CO-FOSS) model. The advantages of this approach are that students are involved directly with a client, nonprofits gain a useful software application, and the project is available as open source for other students or organizations to extend and adapt. This chapter describes the motivation, elaborates the approach, and presents the results in substantial detail. The process is agile and the development framework is transferrable to other one-semester software engineering courses in a wide range of institutions.

Courses about various software engineering practices, e.g. testing and architecture, all ultimately relate to a process for applying the practice. We have used that process as the organizing principle for undergraduate and graduate software engineering courses. The Software Process Engineering Meta-model (SPEM) provides a means for engineering a process for the specific practice being studied and even tailoring that process to the specific needs of a project. We have used the Eclipse Process Framework, an implementation of the SPEM, as a tool to allow instructors to create, modify and reuse a baseline electronic textbook as well as for students to collect, organize, and represent information in a form most meaningful to them. We present examples and data from one undergraduate introduction to software engineering course and two graduate courses in verification and validation and software architecture gathered over several years.

GitHub is a platform used for the development of software projects. It provides a traceable project repository and a social meeting place for communities of practices. This poster presents the students' feedback on using GitHub as a development platform for software projects counting as an exam for a 3rd-year undergraduate software engineering course on software design. Students worked in teams and their feedback is positive overall.

Background: This Research Category Full Paper presents the results of authors' efforts to develop and evaluate learning materials for introducing Software Engineering (SE) students to the Cognitive Psychology concept of human errors (specifically to those human errors that occur during software development). During the last few years, the authors have developed, through a rigorous literature review and empirical investigation, human error intervention instrumentation and supporting training/teaching material. The intervention instrument consists of a corpus of human errors and a tool to support human error based software requirements inspections. The primary aim of developing this instrumentation and training material is to impart SE/CS students with the knowledge about the most frequently committed human errors during the software development process. Goal and Method: First, a study was conducted with Industry Practitioners with the goal of examining if the practitioners believed that human errors and human error training are useful and relevant to the software development process. Next, based on feedback from the practitioners, a study was conducted in an undergraduate Software Engineering course where students were trained using the human error instrument and were asked to perform error based requirements inspections. The high-level goal of this paper is to evaluate whether requirements inspections supported by human errors can be used to deliver knowledge about software engineering human errors as well as knowledge about requirements inspections (a key industry skill) to students. Results: Results showed that industry practitioners found the human error instrumentation and training useful. Based on their feedback, when the training was administered to students, it helped students understand those human errors that are the frequently committed during the software development process.

Putting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University