An Ada-based software engineering course

The goals of computer science department and software engineering courses are not always clear as they could be, and exactly how much of a computer science curriculum should be spent on software engineering topics at the expense of topics with more immediate relevance to computer science majors is far from clear. Computer science students are sometimes skeptical about the relevance of software engineering course topics, particularly those who have had some experience in industry. They report that the techniques and procedures covered in standard software engineering texts are seldom used in industry. There is not enough communication between Industry and Academia, and graduates often must be re-trained for their new jobs. This is a proposal for a modification in the approach to software engineering education for computer science majors, and for clarification of the goals of computer science programs, and calls for procedures to increase the relevancy of computer science and software engineering courses to meet the needs of industry.

The evaluation of an advanced software engineering (SE) course is a challenging task that should be addressed as part of the course design. In this paper, we describe an implementation of the reflective practitioner perspective as part of an advanced SE course and introduce its use for feedback purposes. Reflective feedback goes beyond merely using feedback questionnaires. Furthermore, we show, using both qualitative and quantitative empirical data, that the course on which the perspective was applied meets its objectives and fosters students' awareness to the multidimensional nature of SE.

As software becomes more ubiquitous and complex, the cost of software bugs continues to grow at a staggering rate. To remedy this situation, there needs to be major improvement in the knowledge and application of software validation techniques. Although there are several software validation techniques, software testing continues to be one of the most widely used in industry. The high demand for software engineers in the next decade has resulted in more software engineering (SE) courses being offered in academic institutions. However, due to the number of topics to be covered in SE courses, little or no attention is given to software testing, resulting in students entering industry with little or no testing experience. We propose a minimally disruptive approach of integrating software testing into SE courses by providing students access to a collaborative learning environment containing learning materials on testing techniques and testing tools. In this article, we describe the learning environment and the studies conducted to measure the benefits accrued by students using the learning environment in the SE courses.

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.

One of the main concerns in the software industry continues to be the development of high quality software. This concern will be exacerbated as software systems become more complex. The training of software developers continues to grow in academia since more institutions are offering software engineering (SE) courses. However, the list of topics that are expected to be covered in this course leaves little or no time for topics that focus on developing quality software, such as software testing and the use of testing tools.In this paper we describe an approach that non-intrusively integrates the use of software testing tools in SE courses. The cornerstone of our approach is the interaction students have with a Web-Based Repository of Software Testing Tools (WReSTT) that contains tutorials on testing concepts and testing tools. WReSTT employs both collaborative learning and social networking features that are attractive to students. We present the results of preliminary study performed in two SE courses that show how using the resources in WReSTT can potentially impact the students' understanding of software testing and the use of testing tools.

The Covid-19 pandemic forced many academic institutions around the world to switch to online teaching. This shift occurred suddenly and with little preparation and this method of instruction was named “emergency remote teaching”. This paper will describe the effects of emergency remote teaching on teaching a software engineering course at a Japanese university, showing how the online environment was used as an alternative to cancelling classes. Strategies for implementing active learning and for engaging students during this software engineering course will be highlighted. Based on the results and observations gathered during the teaching of this course, important conclusions will be drawn. They will constitute a starting point for planning and implementing future software engineering courses and for making sure that active learning continues to remain an essential part of the instruction process.KeywordsEmergency remote teachingActive learningSoftware engineering

The primary goal of an introductory software engineering course is to provide a complete introduction to software engineering. Typically this includes concepts, terms, processes, tools, and history. However, for students to fully understand software engineering and be prepared for software development careers, courses must also consider the sociological and communication aspects, often called the socio-technical aspects. Unfortunately, these aspects are difficult to teach and do not receive much coverage in the most widely used software engineering textbooks. Faculty have used various approaches to address the socio-technical aspects. One popular method is to use role-playing exercises. The software engineering education literature contains many papers advocating role-play. However, these papers describe role-play integrated in semester-long projects and often provide little detail about the exercises. Using these published approaches in an existing software engineering course requires significant work by the instructor. This paper presents a set of ready to use role-play exercises that can be downloaded and easily integrated into an existing course. Student reaction is also reported.

Software engineering course is one of the core courses of computer science. The students trained in the current teaching mode can no longer meet the market demand for high-technology talents. Based on this, the research attempts to optimize the traditional software engineering teaching mode by using the project teaching method (PTM). According to the basic concept of PTM and course characteristics, the reform path of PTM in software engineering course is explored in the experiment. Then in the experiment, the indicators that affect teaching reform effect is selected and a evaluation model is built. And GA-BP algorithm is used to evaluate the effect of the evaluation model. To verify the performance of the built model and the final evaluation effect, the research results are tested from the fitness of the algorithm, error performance, prediction in the data set and other aspects. GA-BP algorithm converged when it iterated to the 18th generation, and the final fitness value was 0.61. The average error square value of GA-BP was 0.35 and the minimum error square sum of GA-BP was 0.48. Its prediction accuracy in test set and training set was 93.4% and 94.1% respectively. The maximum prediction error in the training sample was only 0.015, and the performance of the above data was better than the other three algorithms. To sum up, applying PTM to software engineering curriculum reform can achieve better teaching results.

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.

In view of the demand for software professionals in current software industry and the teaching situation in universities, the necessity of researching and constructing software engineering course group is proposed; the basic principles of constructing software engineering course group is discussed, the knowledge system of software engineering courses group is analyzed, a three-segment two-lay course group is designed, the integration and division of the course contents is achieved, and the revision and recombination is promoted, the foundation is laided, in order to further improve the qua lit y o f personnel training and construction level of course group, and accomplish the scale effect of curriculum group construction.

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.

In the past there has been much written about successful commercial software development projects while failures are largely ignored. Similarly, the software engineering education literature contains many references to successful course projects, while academic course project failures are rarely described. This paper provides an analysis of software engineering course project failures as well as practical recommendations for increasing the chances of successful projects. The failures are grouped into technical, personal and management categories. Our recommendations are based upon a synthesis of current approaches being adopted to various degrees in industry as well as our own personal experiences. Most of our non-technical recommendations have historically received very little attention in course offerings or even current popular software engineering texts. It is our goal in this paper to sensitize software engineering course instructors to the possible failures their project teams face as well as provide them with insight into increasing their teams chances for success.

Project-based capstone software engineering courses are a norm in many computer science (CS) and computer science & engineering (CS&E) accredited programs. Such cap-stone design courses offer an excellent vehicle for educational outcomes assessment to support the continuous improvement process required for accreditation. A project-based software engineering capstone course near the end of a student’s program can span the majority of CS and CS&E program objectives, providing a significant means to assess at-tainment of these objectives in a single course location. One objective of this chapter is to explore the role of a project-based, software engineering course in accreditation. An addi-tional objective is to relate over twelve combined years of experience in teaching such a course, and in the process, highlight what works and what does not. We candidly examine both the successes and the failures that we have encountered over the years, and provide a roadmap for other instructors and departments seeking to institute such courses.

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.

The typical one-semester software engineering course is normally geared towards new software development. Unfortunately, most new computer science graduates do not find themselves in a position where they are developing new software but instead in a position where they are maintaining an existing product. This paper describes some current practical software maintenance approaches which can be taught as a part of a software engineering course.