Search

Global software engineering education (GSEE) is aimed at providing software engineering (SE) students with knowledge, skills, and understanding of working in globally distributed arrangements so they can be prepared for the global SE (GSE) paradigm. It is important to understand the challenges involved in GSEE for improving the quality and experience of educators and students. This paper reports the findings of an empirical study on the socio-cultural aspects of GSEE. A case study was conducted involving 14 participants from ten different universities in eight countries. The data was analyzed using grounded theory’s open coding procedure. The key contributions of this paper are the identification and description of seven dimensions of socio-cultural distance that caused several significant challenges in the courses: 1) language differences; 2) concept of time; 3) attitude toward grades; 4) assumptions about national culture; 5) differences in autonomy; 6) influence of the course lecturer; and 7) work habits. Recommendations from this paper that are expected to benefit GSEE educators and students include: cross-cultural orientation of students prior to the course; use of various strategies to support better comprehension of different English accents (e.g., speaking slowly, replaying recorded video messages, and text chatting); and educators familiarizing themselves and their students with the relevant GSE and GSEE literature. [ABSTRACT FROM PUBLISHER]

This paper describes a four-year longitudinal study of the extent of nonoriginal material in final-year undergraduate computing projects. This was done in conjunction with the estab- lishment of a proactive departmental policy on academic integrity which emphasized education and prevention as well as detection and penalty. The intention of the project was to attempt to reduce the amount of nonattributed nonoriginal (plagiarized) content in the projects. The amount of nonoriginal material contained in each of approximately 900 projects over all four years was automatically measured and subsequently investigated and evaluated. Despite problems caused by the continual development of the mea- surement tools during the project, the conclusion can be drawn that the amount of nonoriginal material has declined and that which remains is being used with greater integrity. [ABSTRACT FROM AUTHOR]

A comprehensive suite of pedagogical resources is presented that will enable an instructor to embed grid computing concepts in a traditional distributed system course. Rapidly advancing Internet technologies and ever expanding application domains have created excitement in teaching distributed systems. Many fundamental concepts developed decades earlier, such as remote procedure calls and multithreading, have come to play key roles in modern distributed systems. Standards such as eXtensible Markup Language (XML) and Simple Object Access Protocol (SOAP) have been developed to enable interoperability among heterogeneous distributed systems. However, a plethora of new paradigms, a wide variety of technological choices, and short cycles of technological obsolescence challenge the introduction of these important concepts into a distributed systems course. This paper describes how the author addressed these challenges in teaching grid computing. The paper also provides details of the resources developed during this process. The pedagogical resource kit developed includes course curriculum, lecture notes, a set of laboratory assignments, a Globus Toolkit-based experimental grid adapted to classroom assignments, and valuable lessons learned from the course offerings during the past two years. The material provided in this paper is expected to help to ‘jumpstart’ educators considering the introduction of grid computing into their curricula. [ABSTRACT FROM AUTHOR]

Carrying out real-world software projects in their academic studies helps students to understand what they will face in industry, and to experience first-hand the challenges involved when working collaboratively. Most of the instructional strategies used to help students take advantage of these activities focus on supporting agile programming, which is appropriate for capstone courses. This is not always recommended in initial software engineering project courses, however, where novice developers run projects in teams while simultaneously taking other courses. To enhance the learning and teamwork experience in this latter instructional scenario, this paper proposes a formative monitoring method, reflexive weekly monitoring (RWM), for use in project courses that involve disciplined software processes and loosely coupled work. RWM uses self-reflection and collaborative learning practices to help students be aware of their individual and team performance. RWM was applied in a case study over nine consecutive semesters. The results obtained indicate that RWM was effective in enhancing the learning experience in the instructional scenario studied. While students in the monitored teams were more effective and coordinated, and experienced a higher sense of team belonging and satisfaction, little evidence was found of them being more productive than students working in non-monitored teams. [ABSTRACT FROM AUTHOR]

Reviewers performing systematic literature reviews require understanding of the review process and of the knowledge domain. This paper presents an iterative approach for conducting systematic literature reviews that addresses the problems faced by reviewers who are novices in one or both levels of understanding. This approach is derived from traditional systematic literature reviews and based on observations from four systematic reviews performed in an academic setting. These reviews demonstrated the importance of defining iterations for the eight tasks of the review process. The iterative approach enables experiential learning from the two levels of understanding: the process level and the domain level. [ABSTRACT FROM AUTHOR]

The problem-based learning (PBL) approach has been successfully applied to teaching software engineering thanks to its principles of group work, learning by solving real problems, and learning environments that match the market realities. However, the lack of well-defined methodologies and processes for implementing the PBL approach represents a major challenge. The approach requires great flexibility and dynamism from all involved, whether in mapping content, in teacher performance, or laying out the process of how learners should go about solving problems. This paper suggests that management processes can help in implementing PBL throughout its life cycle (planning, implementation, monitoring, and enhancement), and proposes an assessment model called PBL-SEE for use in software engineering education (SEE). Two examples of its use are provided. The results show how the model can be applied and how the resulting information can be used to make the PBL initiatives “authentic,” in that they bring the reality of the labor market to the learning environment, while keeping to PBL principles. [ABSTRACT FROM PUBLISHER]

The development of collaborative Web applications does not follow a software engineering methodology. This is because when university students study Web applications in general, and collaborative Web portals in particular, they are not being trained in the use of software engineering techniques to develop collaborative Web portals. This paper presents a strategy for teaching collaborative Web portals based on reverse engineering and reuse mechanisms to engineer the collaborative Web portals' development. This strategy was successfully used in a final-year course of a Computer Science program at Carlos III University of Madrid, Spain. Its use has demonstrated an improvement in the maintainability of the Web projects developed as well as a decrease in the number of failures during the test phase. This is a very important step toward the engineering of Web applications. The students' grades for the same subject, with the same content and lecturers, also improved compared to those from previous years. The strategy, the details of its use, the results obtained after analyzing the projects the students developed, and their final grades are described in this paper. [ABSTRACT FROM PUBLISHER]

Spain is currently implementing the regulatory modifications promulgated by the Declaration of Bologna, which should result in the updating of the structure of university degrees, and the inclusion of the European Credit Transfer and Accumulation System (ECTS) methodology. In some Spanish universities, the experimental adoption of this methodology has been encouraged, with the aim of gaining experience which could be extrapolated to other qualifications and subjects when this system becomes compulsory, which is expected to be in 2008. This paper examines the teaching methodologies that follow the experimental introduction of the ECTS in the Technical Software Engineering degree course taught at the Higher Technical College of the University of Cordoba, Spain. Based on data gathered in three specific subjects during the first and third years, this paper defines the teaching strategies implemented in order to increase the active role of students during their learning. The utility of e-learning tools in this type of teaching is discussed and the academic results are compared with results obtained in previous years using more traditional teaching methodologies. [ABSTRACT FROM AUTHOR]

Research has shown that adult learners have a strong desire for a self-directed and autonomous learning experience. This paper presents an evaluation of an approach to supporting self-directed learning employed in a graduate-level Web application design and development course. The approach allows students to define and develop semester-long team projects in an independent fashion including the definition of their own grading metric and the evaluation of themselves against the measure. This paper presents the results of a survey on student opinion of the self-directed learning approach and an evaluation of grades. Study results indicate that the self-directed learning approach used in the course was quite successful in providing adult students with an autonomous and self-directed learning experience. [ABSTRACT FROM AUTHOR]

During the past several years, there has been a growing demand for skilled software engineers, a demand that, unfortunately, has not been satisfied, resulting in a variety of problems for the discipline. This paper presents a new approach called learner-centered Web-based instruction in software engineering that can be used to educate skilled engineers. The approach is based on three ideas. First, software engineering education must become more realistic. Second, software engineering education has to move closer to the learner. Finally, it must take advantage of the Web since this technology has the power of being a unique tool for implementing change in education. This paper reports and discusses the results from the evaluation of the approach. [ABSTRACT FROM AUTHOR]

An operating system course draws from a well-defined fundamental theory, but one needs to consider how more re- cent advances, not necessarily in the theory itself, can be applied to improve the course and the general body of knowledge of the student. The goal of this paper is to show how recent software engineering developments can be introduced to such a course to not only satisfy the theory requirements, but also make the theory more understandable. In particular, this paper focuses on how students can effectively learn the Unified Modeling Language, the object-oriented methodology, and the Java programming language in the context of an operating systems course. The goal is to form a systematic software engineering process for operating system design and implementation. [ABSTRACT FROM AUTHOR]

This paper describes a laboratory equipped for the teaching of advanced courses in computer engineering, computer science, information systems, and software engineering. Other related work areas include computer vision, real-time systems, programming languages, and computer architectures. The laboratory has been built around a digital model railroad platform controlled by a client-server system using an object-oriented language. The characteristics of this laboratory are suitable for implementing Web activities for educational purposes. The paper also includes an overview of the system in which most of these topics have been considered and a summary of the relationship with the most relevant international curricula in computing. [ABSTRACT FROM AUTHOR]

A field experiment investigated the evaluation, teaching, and application of two different approaches to automatic control in programmable logic controllers, in particular comparing the Unified Modeling Language (UML) to the classic procedural paradigm (IEC 61131-3). A total of 85 apprentices from a vocational school for production engineering with a specialization in mechatronics took part in the training and the experiment. This paper details the results of the training using both approaches, and the correlations found between the modeling and/or programming performance and cognitive abilities, interest, workload, expertise, and school grades. In general, the results show that students can be trained to carry out authentic programming tasks within one and a half days, even for beginners in programming. The data distinguish the two approaches. Function Block Diagram programming (IEC 61131-3) can be best predicted by the grade in mathematics, programming experience, and cognitive demand. For performance in UML class diagram and state chart (UML/CD+SC) modeling, the grade in mathematics plays an even more prominent role; this explains the greater variance in modeling performance in the UML group than in the 61131/Function Block Diagram group. With respect to other findings, the paper concludes that special problem-solving skills and skills for abstract thinking should be taught when teaching UML-based modeling approaches. [ABSTRACT FROM AUTHOR]

Project-based learning is one of the main successful student-centered pedagogies broadly used in computing science courses. However, this approach can be insufficient when dealing with practical subjects that implicitly require many deliverables and a great deal of feedback and organizational resources. In this paper, a worked e-portfolio is presented as an approach to improve the teaching/learning and evaluation processes in project-based learning environments needing considerable resources. To validate this approach, a practical project-based software engineering course supported by a Moodle-based e-portfolio was designed and taught. The results obtained corroborated the effectiveness of the e-portfolio in practical software engineering teaching; this approach can be extended to similar subjects in other studies and/or curricula. [ABSTRACT FROM AUTHOR]

Computer networks courses are hard to teach as there are many details in the protocols and techniques involved that are difficult to grasp. Employing programming assignments as part of the course helps students to obtain a better understanding and gain further insight into the theoretical lectures. In this paper, the Partov simulation engine and experience using this engine in a computer networks course are discussed. Since 2009, various programming assignments based on the Partov system have been set to help students in their learning process. Student feedback has been very good; this has been quantified in two surveys in which a majority of students expressed their satisfaction with this approach. [ABSTRACT FROM PUBLISHER]

As embedded software systems have grown in number, complexity, and importance in the modern world, a corresponding need to teach computer science students how to effectively engineer such systems has arisen. Embedded software systems, such as those that control cell phones, aircraft, and medical equipment, are subject to requirements and constraints that are significantly different from those encountered in the standard desktop computing environment. For example, embedded systems must frequently address challenges that arise from severe resource restrictions (e.g., low memory and network bandwidth), heterogeneous hardware platforms, and safety-critical operations. Software architecture has been shown to be an effective means for coping with such issues, yet traditional courses on embedded software development rarely focus on software architectural abstractions. Instead, they have concentrated on lower-level issues such as programming languages and hardware interfaces. Since 2005 at the University of Southern California, Los Angeles, a unique course has been developed that affords students the opportunity to gain experience and insights on developing software architectures for embedded systems. At the heart of the course is a middleware platform, Prism-MW, that helps students use software architectural principles to construct embedded systems and understand the important challenges of the embedded systems domain. This paper describes this course through the explanation and evaluation of four years of class projects, weaving together the course, the middleware platform, and the relationship of each to three key pedagogical goals that drove the formulation of the course curriculum. [ABSTRACT FROM PUBLISHER]

In this paper, an undergraduate capstone course in software engineering is described that not only exposes students to agile software development, but also makes it possible to observe the behavior of developers using Scrum for the first time. The course requires students to work as Scrum Teams, responsible for the implementation of a set of user stories defined by a project domain expert playing the role of the Product Owner. During the course, data on project management activities are collected in order to analyze the amount of work completed, compliance with the release and iteration plans, productivity, ability in effort estimation, and the like. The paper discusses the achievement of teaching goals and provides empirical evaluation of students' progress in estimation and planning skills. A summary of lessons learned and recommendations is given, reflecting the issues to be considered when teaching courses in agile software development. Surveys of students have shown that they were overwhelmingly positive about the course, indicating that the course fully met or even exceeded their expectations. [ABSTRACT FROM PUBLISHER]

A course in compiler construction seeks to develop an understanding of well-defined fundamental theory and typically involves the production of a language processor. In a graduate degree in software engineering, the development of a compiler contributes significantly to the developer's comprehension of the practical application of theoretical concepts. Different formal notations are commonly used to define type systems, and some of them are used to teach the semantic analysis phase of language processing. In the traditional approach, attribute grammars are probably the most widely used ones. This paper shows how object-oriented design patterns represented in unified modeling language (UML) can be used to both teach type systems and develop the semantic analysis phase of a compiler. The main benefit of this approach is two-fold: better comprehension of theoretical concepts because of the use of notations known by the students (UML diagrams), and improvement of software engineering skills for the development of a complete language processor. [ABSTRACT FROM AUTHOR]

Nowadays, considerable attention is paid to agile methods as a means to improve management of software development processes. The widespread use of such methods in professional contexts has encouraged their integration into software engineering training and undergraduate courses. Although several research efforts have focused on teaching Scrum through simulating a software development project, they covered only the learning of programming practices within a Scrum team. Furthermore, few studies tackle nontechnical skills other than the development practices themselves. The work presented here introduces an original Scrum-based training model enhanced with agile coaching to maximize student performance. This was validated by a case study on a capstone project in a Scrum course. This paper summarizes the positive results of introducing agile coaching, which resulted in approximately 22% more coverage of software engineering practices. In addition, a survey data showed that, compared to students who did not receive coaching, coached students gained valuable insight into the internalization of Scrum, problem solving, and guidance by means of checkpoint meetings. [ABSTRACT FROM PUBLISHER]

Software process modeling (SPM) is an important area of software engineering because it provides a basis for managing, automating, and supporting software process improvement (SPI). Teaching SPM is a challenging task, mainly because it lays great emphasis on theory and offers few practical exercises. Furthermore, as yet few teaching approaches have aimed at teaching SPM by introducing innovative features, such as games. The use of games has mainly been focused on other areas of software engineering, for example software project management. In an attempt to fill this gap, this paper describes a formal experiment carried out to assess the learning effectiveness of a serious game (DesigMPS), designed to support the teaching of SPM, and to compare game-based learning with a project-based learning method. In the DesigMPS game, the student models a software process from an SPI perspective, based on the Brazilian SPI model (MPS.BR). The results indicate that playing the game can have a positive learning effect and results in a greater degree of learning effectiveness than does the project-based learning instructional method. [ABSTRACT FROM PUBLISHER]

The value of a studio course in undergraduate soft- ware engineering programs is well documented. What is not as well understood is how to provide a relevant studio experience to working, seasoned professional software engineers as part of a Master's of Software Engineering (MSE) degree program. The challenge is that students' experiential diversity complicates the selection of projects that address different students' needs. Further, when the studio experience is compressed into 14 weeks, significant challenges are presented in controlling the process environment while providing a realistic and meaningful learning experience for part-time students. In this paper, a novel software studio course developed specifically for working, experienced professionals in an MSE program is described. [ABSTRACT FROM AUTHOR]

Software development relies heavily on teamwork; determining how to streamline this collaborative development is an essential training subject in computer and software engineering education. A team process known as the meetings-flow (MF) approach has recently been introduced in software capstone projects in engineering programs at various institutions. In undergraduate science, technology, engineering, and mathematics (STEM) curricula that emphasize team- and project-based learning, the MF approach serves as a macro-level instructional tool to guide students in holistically designing and directing collaborative project development. Previous studies on MF have shown the technical benefits of monitoring student work and product quality. This study investigated the approach further, from the perspective of team management. The effects of MF were examined through an experiment with team-related hypotheses. The results revealed that MF significantly enhances a team's communication and coordination and balances members' contributions by giving mutual support and effort. It has relatively less influence, however, on student team cohesion. [ABSTRACT FROM AUTHOR]

Computer science courses typically incorporate integrated training in software engineering, which includes learning how to reuse existing code libraries in new programs. This commonly presents a need to use the libraries' application programming interfaces (APIs) during project-based learning activities. The students learn these APIs with little support from the instructor. Instead, they primarily learn from whatever code examples they find on the Web—a scattershot approach that is slow, frustrating, and sometimes fruitless. Preliminary work investigated an improved approach that provides students with intelligent API tutors. This interactive educational content walks students through code examples selectively harvested from the Web. This approach increased students' knowledge of API method names, but a key pedagogical challenge remained: Students still lacked an understanding of common problems and surprises that they might encounter when using APIs in practice. Perhaps even more crucially, the prior statistical study provided no information about how students would perceive and accept the intelligent tutor approach, when given a choice. Therefore, this paper presents an enhanced approach that augments intelligent tutors with selected information from online FAQs and online open-source code, thereby providing more explanation and context about how to use APIs in practice. A qualitative study assessed student perceptions of the system's usability as well as suggestions for improvement, revealing that 100% of students considered the approach to be useful. A key implication is that providing information from online FAQs, related articles, and open-source code could facilitate computer science students' learning how to use APIs. [ABSTRACT FROM AUTHOR]

This paper explores the educational benefits of introducing the aspect-oriented programming paradigm into a programming course in a study on a sample of 75 undergraduate software engineering students. It discusses how using the aspect-oriented paradigm, in addition to the object-oriented programming paradigm, affects students' programs, their exam results, and their overall perception of the theoretically claimed benefits of aspect-oriented programming. The research methodology, consisting of automating the analysis of student-created computer programs, administering surveys, and collecting exam results, provided an objective measurement of the benefits of the paradigm for novice programmers, as well as evaluating their perception of its usefulness. The results show that the use of aspect-oriented programming as a supplement to object-oriented programming enhances the productivity of novice program code software engineering students and leads to increased understanding of theoretical concepts. Students readily accepted the new paradigm and recognized its benefits. [ABSTRACT FROM AUTHOR]

Requirements engineering is one of the fundamental knowledge areas in software and systems engineering graduate curricula. Recent changes in educational delivery and student demographics have created new challenges for requirements engineering education. In particular, there is an increasing demand for online education for working professionals. This paper describes a graduate requirements engineering course designed to address these new dynamics while aligning learning objectives with the prevailing body of knowledge and professional practices. [ABSTRACT FROM AUTHOR]

Teaching larger software engineering project courses at the end of a computing curriculum is a way for students to learn some aspects of real-world jobs in industry. Such courses, often referred to as capstone courses, are effective for learning how to apply the skills they have acquired in, for example, design, test, and configuration management. However, these courses are typically performed in small teams, giving only a limited realistic perspective of problems faced when working in real companies. This paper describes an alternative approach to classic capstone projects, with the aim of being more realistic from an organizational, process, and communication perspective. This methodology, called the company approach, is described by intended learning outcomes, teaching/learning activities, and assessment tasks. The approach is implemented and evaluated in a larger Master's student course. [ABSTRACT FROM AUTHOR]

Rubrics and oral feedback are approaches to help students improve performance and meet learning outcomes. However, their effect on the actual improvement achieved is inconclusive. This paper evaluates the effect of rubrics and oral feedback on student learning outcomes. An experiment was conducted in a software engineering course on requirements engineering, using the two approaches in course assignments. Both approaches led to statistically significant improvements, though no material improvement (i.e., a change by more than one grade) was achieved. The rubrics led to a significant decrease in the number of complaints and questions regarding grades. [ABSTRACT FROM PUBLISHER]

This paper discusses the usefulness of employing LEGO as a teaching-learning aid in a post-graduate-level first course on the control of discrete-event systems (DESs). The final assignment of the course is presented, which asks students to design and implement a modular hierarchical discrete-event supervisor for the coordination layer of a complete automated manufacturing system (AMS) built using LEGO blocks. A design approach frequently used in manufacturing is introduced to unify design criteria and nomenclature. Software tools are provided for all calculation and translation tasks required for the implementation of the supervisor architecture in a programmable logic controller (PLC). The assignment reinforces all the basic concepts of supervisory control theory taught during the course. It provides hands-on experience of the advantages and disadvantages and of the important theoretical and practical issues related to the use of DES controllers in an engineering application. [ABSTRACT FROM PUBLISHER]

This paper describes the authors' experience of teaching agile software development to students of computer science, software engineering, and other related disciplines, and comments on the implications of this and the lessons learned. It is based on the authors' eight years of experience in teaching agile software methodologies to various groups of students at different universities, in different cultural settings, and in a number of courses and seminars. It specifically discusses three different courses on agile software development, given in different teaching settings and at different levels, and briefly surveys variations to these courses given elsewhere. Based on the experience acquired, analyses and evaluations conducted, and current pedagogical trends at relevant university departments, the authors provide recommendations on how to overcome potential problems in teaching agile software development and make their adoption more effective. [ABSTRACT FROM AUTHOR]

Like many engineering programs in Europe, the final part of most Swedish software engineering programs is a longer project in which the students write a Master's thesis. These projects are often conducted in cooperation between a university and industry, and the students often have two supervisors, one at the university and one in industry. In particular, the Bologna Process that is currently underway to align different higher educational programs in Europe discusses industrial Master's theses as a major type of thesis project. However, there is a lack of knowledge on how best to support these projects and the different stakeholders involved. This paper presents a study where students and supervisors from software engineering Master's thesis projects at three different Swedish universities are interviewed. The intention of the study is to explore what the major problems of different stakeholders are during a project and to investigate what type of support is needed. Based on the interview results, a support model is defined, which outlines the different types of support that are needed for different roles in Master's thesis projects. [ABSTRACT FROM AUTHOR]

Embedded systems have been applied widely, not only to consumer products and industrial machines, but also to new applications such as ubiquitous or sensor networking. The increasing role of software (SW) in embedded system development has caused a great demand for embedded SW engineers, and university education for embedded SW engineering has become important. The embedded software engineers should learn system architecture design and hardware (HW) technologies as well as SW technologies. However, only a few universities offer education courses for embedded software engineering that include system architecture design and HW technologies. This paper proposes a student experiment method that is designed to nurture embedded SW engineers by teaching these technologies. The proposed method includes an experiment for embedded SW development, an experiment for embedded HW development and a HW/SW co-design experiment, which help students learn system architecture design skills such as system modeling, HW/SW tradeoff design, and SW and HW module design. A model of each experiment was developed and evaluated. [ABSTRACT FROM AUTHOR]

Increasingly, electrical and computer engineers are making their careers in designing wireless embedded systems. This paper presents a teaching methodology and the associated laboratory setup designed to meet the needs in teaching wireless embedded systems. The courses allow the students not only to apply their previous knowledge of digital system design, computer architecture, electronic circuits, wireless networking, and software engineering, but experience actual systems engineering by designing and implementing a large-scale team project within a semester. A flexible hardware platform was developed and was accompanied by teaching methodologies that allow quick completion of ambitious course projects in this area. [ABSTRACT FROM AUTHOR]

Software engineering curriculum guidelines state that students should practice methods, techniques, and tools. A capstone project is one possibility to address this aim. A capstone project helps the students to increase their problem solving competencies, improve their social skills (e.g., communication skills), and gather practical experience. A crux of such projects is that students perform "reflective" practice in order to learn from their experiences. The authors believe that experience gathering and reuse are effective techniques to stimulate reflective activities. An adapted free- and open-source Wiki-based system called software organization platform (SOP) is used to support students in managing their observations and experiences. The system can be used for experience exchange within the team and for experience reuse in forthcoming projects. The results of a case study show that standard Wiki functions improve communication and information sharing by means of explicit observation and experience documentation. A total of 183 documented observations and experiences at the end of the project provide a measure for the amount of reflection students have had during the capstone project. Still, the advantages of using Wikis will decrease when no technical adaptations of the Wiki to the learning objectives and to the software engineering tasks are made. Limitations of the case study, future evaluation steps, and planned developments of SOP will be provided in this paper. [ABSTRACT FROM AUTHOR]

Current e-learning systems are increasing their importance in higher education. However, the state of the art of e-learning applications, besides the state of the practice, does not achieve the level of interactivity that current learning theories advocate. In this paper, the possibility of enhancing e-learning systems to achieve deep learning has been studied by replicating an experiment in which students had to learn basic software engineering principles. One group learned these principles using a static approach, while the other group learned the same principles using a system-dynamics-based approach, which provided interactivity and feedback. The results show that, quantitatively, the latter group achieved a better understanding of the principles; furthermore, qualitatively, they enjoyed the learning experience. [ABSTRACT FROM AUTHOR]

This paper describes a controlled experiment concerning the use of a learning aid during the instructional procedure. The core issue of investigation is whether this instructional aid can augment the cognitive transfer of the learners by personalizing the offered knowledge. For this purpose, a controlled experiment was conducted with the participation of 79 undergraduate students. The taught domain was two lessons concerning human-computer interaction: the first in usability engineering and the second in interface evaluation methodologies. A test session was also conducted to collect data on the assessment of the augmentation of the students' knowledge on the domain. Descriptive and inferential statistics were applied to the collected data to test the research hypotheses. The results showed that with regard to the transfer of simple information, this "lesson sheet" does not provide any statistically significant advantage, yet for complex information, a significant statistically improved performance was observed for the student group that used the tool. Finally, concerns about the application of the tool and further research in the area are also presented. [ABSTRACT FROM AUTHOR]

The utilization of large-scale group projects in early computer science courses has been readily accepted in academia. In these types of projects, students are given a specific portion of a large programming problem to design and develop. Ultimately, the consolidation of all of the independent student projects integrates to form the solution for the large-scale project. Although many studies report on the experience of executing a semester-long course of this nature, course experience at Georgetown University, Washington, DC, shows the benefits of embedding a large-scale project that comprises just a segment of the course (three to four weeks). The success of these types of courses requires an effective process for creating the specific large-scale project. In this paper, an effective process for large-scale group project course development is applied to the second computer science course at George- town University. [ABSTRACT FROM AUTHOR]

Software testing is a popular and important technique for improving software quality. There is a strong need for universities to teach testing rigorously to students studying computer science or software engineering. This paper reports the experience of teaching the classification-tree method as a black-box testing technique at the University of Melbourne, Melbourne, Australia, and Swinburne University of Technology, Melbourne, Australia. It aims to foster discussion of appropriate teaching methods of software testing. [ABSTRACT FROM AUTHOR]

In some cases, real-world application of software engineering concepts does not effectively map with current undergraduate curriculums. Typically, a student's first "hands-on" experience working on large-scale software development projects is via an intern position or his/her first full-time position. However, prior exposure to the corporate project environment would greatly improve a student's performance in industry. In order to develop students for successful careers in software engineering, specifically for software development, they must be immersed not only 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 three-to-four person group projects. In the Department of Computer Science, Georgetown University, Washington, DC, 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. [ABSTRACT FROM AUTHOR]

Contribution: This article demonstrates the impact of today’s Information and Communication Technologies (ICT) in teaching software engineering (SE) course with design-based learning (DBL) and project-based learning (PBL). The results show a positive influence of integration of DBL and PBL in reducing industry gaps with improved student performance, engagement, and learning through designed PBL activities. Background: For an engineering graduate analysis, design, thinking, and validation of complex systems interactions is a desirable skill to support sustainability goals. A restructuring in delivery of the course through interactive lecture time and more project-based activities can improve students’ engagement, performance, and overall achievement in attaining desirable program learning outcomes (LOs). Intended Outcome: The objective is to provide student learning with an experience on how to apply critical thinking and creativity to specify, design, and validate software systems by focusing on challenges faced in the software industry. Application Design: Google classroom was used to conduct interactive class and tutorial sessions, design various PBL activities, exchange information, and work in teams. Throughout the semester, all learning and practice modules of the course were linked sequentially with intermediate milestones. Findings: The results show a positive outcome in helping students in attaining the knowledge, and understanding of both theoretical and practical concepts. These findings are based on academic results, PBL activities, and two anonymous surveys. The findings of statistical analysis suggest a positive influence of DBL and PBL in SE course to meet industry challenges, expectations, and overall course and program LOs. [ABSTRACT FROM AUTHOR]

Contribution: In this study, we accumulated the knowledge and generated evidence on how and in what context CDIO framework has been used in software engineering (SE) education. The aggregated evidence will enable SE academics in making informed decisions while adopting CDIO for SE education and build upon it. Background: CDIO framework is relevant for SE as it focuses on enabling engineering graduates in conceiving, designing, implementing, and operating complex systems and products. We were not able to find any study that identifies and aggregates the evidence on the use of CDIO for SE education. Research Questions: This study attempts to answer the following research questions: 1) how CDIO has been used in SE education? and 2) what are the experiences of academics in applying the CDIO framework in SE education? Methodology: Using a mixed-method approach (systematic mapping study and interview study with experienced academics in SE), we established the state of the art and practice on the use of CDIO in SE education. Findings: Getting a commitment from the higher management, teachers, and students is a major challenge in the adoption of the CDIO initiative followed by a lack of competence, finance, and resources. Ownership, motivation, persistence, and training of teachers and students are required not only to adopt CDIO for SE but also to sustain it. [ABSTRACT FROM AUTHOR]

Contribution: This article identifies the participation of external stakeholders as a key contributing factor for positive outcomes in project-based software engineering courses. A model for overlapping virtuous circles of lasting positive impact on both stakeholders and students from such courses is proposed. Background: Project-based courses are widespread in software engineering education, and there are numerous designs for such courses presented in literature. It is found that the needs and motivations of external stakeholders, from industry and government sectors, in these courses has received limited attention in related work. Intended Outcomes: A course design that prepares students for graduate level studies and professional life, through close proximity to external stakeholders in a highly realistic setting, working on “live” projects. Application Design: Building on a long tradition of university-industry collaboration dating back to 1977, as well as findings in related work, students are assigned to live projects proposed by external stakeholders from industry and government, working in close proximity with their respective stakeholders throughout the project. The course places great emphasis on coaching over instruction, treating the many unforeseen challenges of such projects as a valuable part of the learning experience. Findings: Based on interviews with stakeholders and students, it is found that stakeholder and student outcomes are interdependent and build upon one another, and that positive outcomes for both groups are necessary for the sustainability of the course over multiple iterations. [ABSTRACT FROM AUTHOR]

Contribution: Determine and analyze the gap between software practitioners’ education outlined in the 2014 IEEE/ACM software engineering education knowledge (SEEK) and industrial needs pointed by Wikipedia articles referenced in Stack Overflow (SO) posts. Background: Previous work has uncovered deficiencies in the coverage of computer fundamentals, people skills, software processes, and human–computer interaction, suggesting rebalancing. Research Questions: 1) To what extent are developers’ needs, in terms of Wikipedia articles referenced in SO posts, covered by the SEEK knowledge units? 2) How does the popularity of Wikipedia articles relate to their SEEK coverage? 3) What areas of computing knowledge can be better covered by the SEEK knowledge units? 4) Why are Wikipedia articles covered by the SEEK knowledge units cited on SO? Methodology: Wikipedia articles were systematically collected from SO posts. The most cited were manually mapped to the SEEK knowledge units, assessed according to their degree of coverage. Articles insufficiently covered by the SEEK were classified by hand using the 2012 ACM computing classification system (CCS). A sample of posts referencing sufficiently covered articles was manually analyzed. A survey was conducted on software practitioners to validate the study findings. Findings: SEEK appears to cover sufficiently computer science fundamentals, software design, and mathematical concepts, but less so areas, such as the World Wide Web, software engineering (SE) components, and computer graphics. Developers seek advice, best practices and explanations about software topics, and code review assistance. Future SEEK models and the computing education could dive deeper in information systems, design, testing, security, and soft skills. [ABSTRACT FROM AUTHOR]

Background: Peer evaluation in software engineering (SE) project courses enhances the learning experience of students. It also helps instructors monitor and assess both teams and individual students. Peer evaluations might influence the way individual students and teams work; therefore, the quality of the peer evaluations should be tracked through the project course. Contribution: In this article, we analyzed the quality and scoring behavior of students in peer evaluation in an undergraduate SE project course over three years. Research Questions: RQ1: What is the quality of peer evaluation of undergraduate students in a SE project course? RQ2: How do undergraduate students in an SE project course score each other? Methodology: The quality of peer evaluation (length, level of detail, etc.) and scoring of peers based on various aspects of peer evaluations of third-year students in a year-long SE project course were studied. Taking into account the grade students received at the end of the course (A, B, C, and F-calibers), peer evaluations were categorized, analyzed over time, and compared between students calibers. Findings: After analyzing 6854 peer evaluations from 193 students, it was found that the quality of peer evaluations across students was mostly consistent throughout the course. Also, it was observed that quantitative aspects of the peer evaluation were scored similarly across student calibers. However, the qualitative aspects of the peer evaluation were impacted by the caliber of students. These findings suggest that weaker students (i.e., C-caliber students) generally receive better quality peer evaluations than stronger students (i.e., A-caliber students). Finally, a preliminary analysis showed a positive connotation of emotions and sentiments found in the textual feedback delivered by students. [ABSTRACT FROM AUTHOR]

Contribution: This article presents agile software engineers stick together (ASEST+), an improved version of a framework called ASEST that aims to develop team cohesion, leading to better team learning and software engineering student teams. Background: Effective teamwork is crucial for agile software development’s success and is, therefore, a key topic of current software engineering education. In the previous work, a preliminary proposal for ASEST+ was presented. Here, an improved version, more suitable for agile practice education and considering cohesion antecedents, is described. Intended Outcome: A teaching-learning framework to support teamwork in agile software education. Application Design: ASEST+ is built around Scrum teams and combines learning strategies to train students in collaborative and technical agile practices. ASEST+ establishes policies for role allocation and team rule agreements to regulate communication and address conflict management agile practices. ASEST+ addresses personality traits, conflict resolution, and task interdependence as the antecedents identified as the most important. Findings: A quasiexperiment showed that the use of ASEST+ significantly increases the students’ positive perceptions on team cohesion, team performance, and team learning compared with the control group. [ABSTRACT FROM AUTHOR]

Teaching computing students about the importance of evidence and about the use of empirical methods for evaluating computing technologies can be difficult, especially within dual honors undergraduate degree programs. The aims of this study were to explore the effectiveness of second-year undergraduate computing students in carrying out a systematic literature review and to identify the elements of the process that the students found most difficult. A multicase case study of students carrying out an assignment to perform a systematic literature review (SLR) was undertaken. Students worked in groups and were studying across a range of computing programs. Data was collected from three sources: student grades, the comments made by the teaching staff on the submitted reports, and a debriefing questionnaire. All of the groups successfully completed the assignment. Results on which parts of the process were the most difficult were mixed, although much of the evidence suggests that the students found the conduct phase more problematic than the planning phase. It can be concluded that undergraduates can do SLRs, but the task is clearly quite challenging and time-consuming. SLRs are well suited to being undertaken by groups. [ABSTRACT FROM AUTHOR]

Reports on a case study in software engineering. Evidence of distributed group working among teams of software engineers; Work undertaken by British universities to provide computer science students with the opportunity to experience group working across universities using low-cost tools; Role of group tasks in software engineering education curriculum.

Contribution: This article demonstrates that social, cultural, economic, and political topics can be effectively addressed in the context of traditional computer science and engineering topics with few additional resources and little coordination. Background: Social, cultural, economic, and political influences are often secondary topics in computer science and engineering curricula. Superficial treatment of these topics can impede future graduates by limiting their understanding of how global factors influence the design of products, the availability of consumers, and future employment. Research Question: Are there ways to effectively integrate coverage of global issues and technical course material that sacrifice little class time and require few resources? If so, which activities and tools are most effective? Methodology: Computer networking students were introduced to the well-known networking tools Traceroute and WHOIS. Students were required to successfully use these tools for a graded assignment. After finding the country of origin with a visual Traceroute tool, students chose an article reporting on a technical topic in the social, cultural, political, or economic context of one of the origin countries. Students answered questions regarding their previous and new knowledge on the graded assignment and then reported the effectiveness of the activities in encouraging global awareness on an anonymous questionnaire. Findings: Students reported little previous knowledge of all countries included in the assignment but found the assignment useful in learning about global influences within the context of traditional networking tools. Furthermore, students reported differences in what activity during the assignment was most effective when learning about global issues. [ABSTRACT FROM AUTHOR]