Learning Software Engineering Research Articles

GSOFT: A Generic Model for Teaching and Learning Large-scale Software Programs

Learning software engineering in practical laboratory based on present curriculum is under the clutches of hard practices and not well defined. The effort and time taken for planning, designing and coding, have a few issues in student’s learning aspect. Same is the case for evaluating the student’s program. With the effect, both the teacher and students have leaned towards lightweight learning method using Extreme Programming (XP). Pair Programming, which is one among the twelve practices of XP has been widely used by the pedagogical community. However, this practice is found suitable for introductory level small-scale programs. Also, the researchers incorporating pair programming, have not given much importance for program assignments and program correction. To address these problems, we have developed a Generic software teaching and learning model called GSOFT with few software development practices, and pair programming. COSMIC FFP (Common Software Measurement Integration Consortium Full Function Point) standard was used for program assignments and program evaluation. This method was applied on real time project assigned to student as large scale programs and examined. For this study, the students were grouped into pair programmers (PP) and solo programmers (SP). The performance of the PP and SP groups were measured using our generic model and found the person-days taken to complete the program. The results show that PP used less person-day than the SP. This study also proves that the program developed by PP has better coding.

The Future of Social Learning in Software Engineering

Building on time-honored strengths of person-to-person social learning, new technologies can help software developers learn from one another more efficiently and productively. In particular, continuous social screencasting is a promising technique for sharing and learning about new software development tools.

Learning Software Engineering with Global Teams

Global software engineering requires the coordination of team participants around the world, mainly in large software projects. How can computer science students learn the organizational and intercultural skills required to guide and participate in global distributed projects? To answer this question, this paper analyzes international virtual team teaching with the use of software engineering. Experiences and lessons learned are presented based on the results of a joint Mongolian-German team project. The obtained results with the Mongolian team encourage the project to include students and researchers from the National Polytechnic Institute in Mexico.

Success Factors for Using Case Method in Teaching and Learning Software Engineering

The Case Method (CM) has long been used effectively in Social Science education. Its potential use in Applied Science such as Software Engineering (SE) however has yet to be further explored. SE is an engineering discipline that concerns the principles, methods and tools used throughout the software development lifecycle. In CM, subjects are presented to students by means of real cases whereby students themselves either individually or in group discussions work through the problems and issues presented in the cases. The CM approach is deemed necessary for SE education in order to expose students to real scenarios that challenge them to develop the appropriate skills to deal with practical problems. As a largely theoretical subject, SE students could understand more about the practical application of SE concepts and ideas via such active learning activities. This paper presents a survey conducted on two sets of students who were exposed to CM in learning SE. Besides confirming the acceptance of CM among SE students, the surveys aimed to discover the contributing factors and elements that influence the efficacy of the method. The participants consisted of 64 undergraduates that comprised local full-time and executive students. The survey was performed in two semesters through group interviews. Data from the survey were analysed qualitatively using content analysis. The results showed that there are four factors that are important to teaching SE using CM, namely Environment, Case, Instructor, and Student. Each of these factors has certain criteria and characteristics that suggest how CM can be successfully used in teaching and learning SE. These findings can be used by SE educators to more effectively plan the use of CM as one possible teaching method in SE.

A Research Agenda for Identifying and Developing Required Competencies in Software Engineering

0 0 1 130 820 Hochschule Coburg 6 1 949 14.0 96 Normal 0 21 false false false DE JA X-NONE /* Style Definitions */ table.MsoNormalTable {mso-style-name:"Normale Tabelle"; mso-tstyle-rowband-size:0; mso-tstyle-colband-size:0; mso-style-noshow:yes; mso-style-priority:99; mso-style-parent:""; mso-padding-alt:0cm 5.4pt 0cm 5.4pt; mso-para-margin:0cm; mso-para-margin-bottom:.0001pt; mso-pagination:widow-orphan; font-size:10.0pt; font-family:"Times New Roman";} Various issues make learning and teaching software engineering a challenge for both students and instructors. Since there are no standard curricula and no cookbook recipes for successful software engineering, it is fairly hard to figure out which specific topics and competencies should be learned or acquired by a particular group of students. Furthermore, it is not clear which particular didactic approaches might work well for a specific topic and a particular group of students. This contribution presents a research agenda that aims at identifying relevant competencies and environmental constraints as well as their effect on learning and teaching software engineering. To that end, an experimental approach will be taken. As a distinctive feature, this approach iteratively introduces additional or modified didactical methods into existing courses and carefully evaluates their appropriateness. Thus, it continuously improves these methods.

Uma Proposta para o Ensino de Engenharia de Software a partir da Resolução de Problemas

The constant technological advances require that professionals have, in addition to specific knowledge, skills such as proactivity, initiative, self-learning ability, communication and teamwork. However, in traditional higher education, generally, the focus turns to knowledge acquisition, appearing as an optional activities that encourage such skills. Seeking to narrow the gap between the academic and the job market, is envisioned the Software Engineering (ES) course at UNIPAMPA. The method chosen to support the approximation between theory and practice was the PBL (Problem Based Learning). Besides teaching the basic concepts, the course reserve part of their semester to practice them across disciplines called Problem Solving. In them, students are encouraged to solve a real problem by developing a computer system. Divided into teams, they apply concepts and practices of software engineering and exercise coordination and project development of your team, simulating the environment of a software development company. The aim of this paper is to show how the use of PBL may contribute to both the learning of software engineering, and to encourage professional aimed skills. As a case study, this paper presents the design and operationalization of Problem Solving I, which is offered to freshman students in the ES. Through the returns from the class of 2011, it was realized that even with a preliminary overview of the course, students realized the importance of the use of PBL as a means to bridge the gap between theory and professional practices of software engineering.

Collaborative and role‐play strategies in software engineering learning with web 2.0 tools

ABSTRACTSoftware development processes are inherently complex and require the collaboration and coordination of expert teams. The acquisition of both analysis and design competences as well as social skills should thus be the leitmotiv of courses devoted to software engineering learning. However, these aspects are often ignored and excessive importance is attached to the implementation stage. The learning framework described in this article was designed to teach students these competences and skills by means of an immersive learning experience where, working in a team, each student has to play the role of a software developer and address problems linked to requirements specification, design, and the software development process as a whole. Collaborative strategies of this kind have proven to be very successful in active learning processes, to which we have added continuous assessment mechanisms based on rubrics to provide early feedback to students. Additionally, and taking into account the characteristics of the new European Space for Higher Education, we have designed an online personal learning environment (PLE) that facilitates anytime–anywhere communications and provides a suitable social space for the exchange of information, which is crucial to the success of any teamwork effort. More specifically, we propose a learning activity based on Web 2.0 services and adapted to this particular PLE.© 2012 Wiley Periodicals, Inc. Comput Appl Eng Educ 22:658–668, 2014; View this article online at wileyonlinelibrary.com/journal/cae; DOI 10.1002/cae.21557

An Experience of Educational Innovation for the Collaborative Learning in Software Engineering

This paper describes the experience in collaborative learning based educational innovation for the Software Engineering Subject at the Telecommunications Engineering School of the Universidad Politécnica de Madrid. We describe the context of evolution of the Software Engineering related subjects in the Masterâ??s degree in Telecommunications Engineering (specialization in Telematics) for their adaptation to the educational and organizational postulates of the European Space for Higher Education. In this context, we describe a pilot project for the adaptation of the Software Engineering Lab course, which includes the development and validation of a software engineering tool environment and a web platform for collaborative work.

Engaging students in specification and reasoning

We introduce a "hands-on" experimentation approach for teaching mathematical specification and reasoning principles in a software engineering course. The approach is made possible by computer-aided analysis and reasoning tools that help achieve three central software engineering learning outcomes: (i) Learning to read specifications by creating test points using only specifications; (ii) Learning to use formal specifications in team software development while developing participating components independently; and (iii) Learning the connections between software and mathematical analysis by proving verification conditions that establish correctness for software components. Experimentation and evaluation results from two institutions show that our approach has had a positive impact.

Diseño de software educativo basado en competencias

El presente artículo describe un modelo de diseño de software educativo basado en competencias, el cual presenta una visión integral del desarrollo de estas aplicaciones mediante la combinación de componentes pedagógicos, didácticos, multimediales y de ingeniería de software. El modelo sugerido se compone de cinco fases que detallan paso a paso los aspectos que se deben tener en cuenta para la creación de software educativo. La fase inicial constituye la descripción del diseño educativo, en la cual se analiza la necesidad educativa, se plantean los objetivos de aprendizaje y se describen las competencias que se pretenden desarrollar con la aplicación; del diseño de éstas resultan las siguientes subfases: diseño de contenidos, diseño pedagógico y diseño de aprendizaje. Las competencias son el aspecto fundamental que abarca el desarrollo de este modelo, las cuales son primordiales para la realización de las fases a seguir conformadas por el diseño computacional y el diseño multimedial, estas se encargan del análisis y modelado del software, y del sistema de comunicación hombre-máquina. En la fase de producción se ensamblan los componentes elaborados o recolectados, según el caso. La última fase es la de aplicación, donde se hacen las pruebas de rigor para evaluar el desempeño del software en los contextos para los que fue desarrollado.

Promoting Collaborative Learning in Software Engineering by Adapting the PBL Strategy

Promoting Collaborative Learning in Software Engineering by Adapting the PBL Strategy

Machine Learning and Value-Based Software Engineering

Software engineering research and practice thus far are primarily conducted in a value-neutral setting where each artifact in software development such as requirement, use case, test case, and defect, is treated as equally important during a software system development process. There are a number of shortcomings of such value-neutral software engineering. Value-based software engineering is to integrate value considerations into the full range of existing and emerging software engineering principles and practices. Machine learning has been playing an increasingly important role in helping develop and maintain large and complex software systems. However, machine learning applications to software engineering have been largely confined to the value-neutral software engineering setting. In this paper, the general message to be conveyed is to apply machine learning methods and algorithms to value-based software engineering. The training data or the background knowledge or domain theory or heuristics or bias used by machine learning methods in generating target models or functions should be aligned with stakeholders’ value propositions. An initial research agenda is proposed for machine learning in value-based software engineering.

Mining extremely small data sets with application to software reuse

AbstractA serious problem encountered by machine learning and data mining techniques in software engineering is the lack of sufficient data. For example, there are only 24 examples in the current largest data set on software reuse. In this paper, a recently proposed machine learning algorithm is modified for mining extremely small data sets. This algorithm works in a twice‐learning style. In detail, a random forest is trained from the original data set at first. Then, virtual examples are generated from the random forest and used to train a single decision tree. In contrast to the numerous discrepancies between the empirical data and expert opinions reported by previous research, our mining practice shows that the empirical data are actually consistent with expert opinions. Copyright © 2008 John Wiley & Sons, Ltd.

A classroom outsourcing experience for software engineering learning

Outsourcing of software development is a key part of globalization, oft misunderstood by computer science students, and possibly a cause of declining enrollments in the field. The authors developed and implemented an outsourcing experience for students in an advanced software engineering course. Student teams at two universities developed game playing programs and outsourced key parts of their systems to the other university. Results show students improved their understanding of outsourcing, developed better appreciation for the importance of software engineering techniques, and created ad hoc communication protocols between teams. The paper concludes with recommendations for expanding the approach used to other universities to create a more inclusive computer science and software engineering teaching environment.

Learning Software Engineering at a Distance

Delivering a software engineering curriculum by distance learning requires innovative and flexible approaches to presenting and managing the learning materials. At the Open University, we've been offering a broadly based master's degree in Computing for Commerce and Industry by distance learning for over 20 years. The Open University's SE curriculum and delivery mechanisms are shaped by its commitment to offering professionally accredited part-time, open, and large-scale distance learning primarily aimed at IT practitioners

Heuristics for the automatic identification of irregularities in spreadsheets

Spreadsheet programs turned out to be the most popular end-user programming environment that has ever been released. Important decisions are based on the results of spreadsheet programs and the list of known errors with large impact is growing daily- although it surely is only the top of an iceberg.One way out of the crisis might be the introduction of software engineering techniques into spreadsheet development. Suggestions for the improvement of spreadsheet development range back as far as into the late eighties, but none has been successful yet. We argue this is either because not enough effort is put into the roll-out of the technique to the users and, mainly, because they neglect the fact that spreadsheet programmers are end-users, not willing or not able to spend any time on learning software engineering methods. We found out that most end users are willing to verify their spreadsheets, but only view have the time and skills to do really systematic testing of spreadsheets.We developed an approach to generate two orthogonal abstract representations of spreadsheet programs that are then displayed to the user by different visualisation techniques to support the auditing process. Usually, irregularities in the visualisation point out hot-spots on the spreadsheet with a high likelihood of erroneous formulas. In this paper we present new heuristics for identifying hot spots that are very efficient for large spreadsheet programs.

Reflection and abstraction in learning software engineering's human aspects

Intertwining reflective and abstract modes of thinking into the education of software engineers, especially in a course that focuses on software engineering's human aspects, can increase students' awareness of the discipline's richness and complexity while enhancing their professional performance in the field. The complexity of software development environments includes the profession's cognitive and social aspects. A course designed to increase students' awareness of these complexities introduces them to reflective mental processes and to tasks that invite them to apply abstract thinking. For the past three years, we have taught a Human Aspects of Software Engineering course at both the Technion-Israel Institute of Technology and the School of Computer Science at Carnegie Mellon University. This course aims to increase software engineering students' awareness of the richness and complexity of various human aspects of software engineering and of the problems, dilemmas, question, and conflicts these professionals could encounter during the software development process.

Machine Learning and Software Engineering

Machine learning deals with the issue of how to build programs that improve their performance at some task through experience. Machine learning algorithms have proven to be of great practical value in a variety of application domains. They are particularly useful for (a) poorly understood problem domains where little knowledge exists for the humans to develop effective algorithms; (b) domains where there are large databases containing valuable implicit regularities to be discovered; or (c) domains where programs must adapt to changing conditions. Not surprisingly, the field of software engineering turns out to be a fertile ground where many software development and maintenance tasks could be formulated as learning problems and approached in terms of learning algorithms. This paper deals with the subject of applying machine learning in software engineering. In the paper, we first provide the characteristics and applicability of some frequently utilized machine learning algorithms. We then summarize and analyze the existing work and discuss some general issues in this niche area. Finally we offer some guidelines on applying machine learning methods to software engineering tasks and use some software development and maintenance tasks as examples to show how they can be formulated as learning problems and approached in terms of learning algorithms.

The software engineering learning facility

The Software Engineering Learning Facility (SELF) is a web-based environment designed to enhance learning the art of software development. The system consists of three components. The Practice comp...

Apprenticeship learning of software engineering using Webworlds

There is an increasing use of the World Wide Web in the teaching of topics in computer science. Many examples involving animation have been reported and other modeling environments (or 'Webworlds'), such as diagramming tools, are emerging. The software engineering curriculum includes topics such as testing and design, which can be supported by graphical editors. This paper presents three examples of software produced to support learning in this area and a detailed analysis of the results of one pilot research study. Taken as a whole, the evidence is argued to support the case for apprenticeship learning and that the Web provides an opportunity to exploit this, if collaborative and other tools properly scaffold it.