Bridging the Academia-Industry Gap in Software Engineering

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.

Over time much has been written on how to organize a course on software engineering, with arguments flowing for and against additional complexity. It is highly believe that SWE is an umbrella course in computing and most dangerously in any course proclaimed to be specialist in generating Software Engineers. Unfortunately, this may still not be widely recognized, both in the industry and in academia. The modern course on SWE requires that the student is familiar not just with many aspects of computing such as programming languages but rather with many other aspects including networking, Internet technologies, programming languages, databases, Human Computer Interaction (HCI), computer graphics, and project management. Depending on the year of academic study these expectations could be unrealistic, especially if that is a 2nd year course. Based on the above view, it is essential to investigate what are the necessary attributes of an ideal Software Engineering at the undergraduate level and how much it is covering of the requirements imposed by the business and industry market. This paper will investigate how appropriate are Software Engineering courses at the undergraduate level in terms of the areas of concentration, delivery approach, and the real life practical training received by the target group of students. It will deeply investigate the overall intended learning objectives and how they are related to the choice of modules offered. On the other hand, a number of business institutions will be surveyed for achieving an overview of how effective graduates of Software engineering courses are within these selected institutions and most importantly what are the challenges they encounter in professional life given their level of university education i.e. how helpful their undergraduate education has been helpful to their development as specialists.

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.

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.

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.

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.

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.

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.

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.

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.

In a junior- or senior-level undergraduate software engineering course that uses real-world projects for real clients, different parts of a project are inherently unequal in difficulty, time requirements, and desirability. A perennial problem is assigning portions of the project to student teams equitably. Fair division is a highly effective strategy for making an equitable, proportional, and envy-free assignment of tasks and in serving as the basis for fair grading of assignments which vary in difficulty, desirability, and time requirements.

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

In software engineering education, large projects are widely recognized as a useful way of exposing students to the real-world difficulties of team software development. But large projects are difficult to put into practice. First, educators rarely have additional time to manage software projects. Second, classrooms have inherent limitations that threaten the realism of large projects. Third, quantitative evaluation of individuals who work in groups is notoriously difficult. As a result, many software engineering courses compromise the project experience by reducing the team sizes, project scope, and risk. In this paper, we present an approach to teaching a one-semester software engineering course in which 20 to 30 students work together to construct a moderately sized (15 KLOC) software system. The approach combines carefully coordinated lectures and homeworks, a hierarchical project management structure, modern communication technologies, and a web-based project tracking and individual assessment system. Our approach provides a more realistic project experience for the students, without incurring significant additional overhead for the instructor. We present our experiences using the approach the last 2 years for the software engineering course at The College of William and Mary. Although the approach has some weaknesses, we believe that they are strongly outweighed by the pedagogical benefits.