Anais Estendidos do Simpósio Brasileiro de Engenharia de Software (SBES)
Sociedade Brasileira de Computação - SBC
Abertura do XXXIII Brazilian Symposium on Software Engineering
Mensagem dos chairs e abertura do evento
Comitê Técnico das trilhas Insightful Ideas and Emerging Results e Education
A Model-based Framework for the Analysis of Software Energy Consumption
Software is present in all types of devices, some of them with restrictions as to the amount of energy they can spend to execute software applications. For this reason, energy costs are becoming an important factor during software development and evolution. However, there is still little support for creating energy-efficient software. In this work, we introduce a possible framework for software energy costs evaluation based on model analysis. We model software as Labelled Transitions Systems (LTS) and annotate these models with energy costs, which can be obtained using existing tools. We can then apply graph-based algorithms to traverse the models to obtain information about energy consumption related to software behaviour, such as its most/least costly execution, the cost of a specific execution, and the average cost of executing the software. No existing tool currently provides all the necessary analyses, even though they are essential for energy-consumption evaluation. We have conducted a small experiment with our framework where we employed jRAPL to measure energy costs. We annotated the models with the collected energy costs using an extended version of the LoTuS tool, where we have also implemented some of the desired analyses. Based on this support and on our initial results, we believe developers could create software more energy-efficient and consider possible trade-offs related to time, space, and energy costs when producing new versions of their systems.
smAR2t: a Models at Runtime Architecture to Interact with the Web Of Things using Augmented Reality
The Internet of Things has a high heterogeneity of devices, cloud services, communication protocols and comprises different research and development areas. This implies in ease-of-use problems for users who interact with high-density smart environments using common interface solutions, demanding specific applications for each device. There are also situations where things change their locations and networks, bringing even more complexity to this scenery. A great number of recent researches point Augmented Reality(AR) as an interface solution that is capable of providing rich user experiences for high-density IoT environments. W3C's Web of Things standards(WoT) are proving to be a feasible solution for IoT's heterogeneity issues by using well-known web protocols and the Thing Description(TD) formal model. This paper's goal is to propose an architecture called smAR2t that integrates these solutions by managing mobility, heterogeneity and high-density of smart environments, allowing users to browse their surroundings with AR and to interact with things seamlessly according to each of their TDs. This could be done by: representing TDs in a higher level of abstraction with models; transforming these models at runtime to reflect real-time interactions and behaviors; updating an auto-generated AR interface according to these models.
A Conceptual Metamodel to Bridging Requirement Patterns to Test Patterns
Requirement patterns represent an abstraction of an application's behaviors and services that, in turn, may be replicated in similar applications. However, there has been a lack of efforts exploiting the benefits of requirement patterns in other phases of the software development life cycle, besides the requirements engineering itself. To address this gap, we propose the Software Pattern MetaModel (SoPaMM) that bridges requirement patterns to groups of scenarios with similar behaviors in the form of test patterns. SoPaMM allows the description of the behavior of a requirement pattern through a time executable and easy-to-use language aiming at the automatic generation of test patterns. Using SoPaMM, we model and implement a behavior-driven functional requirement pattern for a web-based user authentication application. Our preliminary results point out that a requirement pattern can be an executable specification capable of generating automated tests.
ADORE: An Adaptation-Oriented Requirement Modeling Approach for Systems of Systems
The composition of several independently manageable and operable systems in order to create a system of systems may require adaptations due to the rise of emergent behaviours. An inadequate identification, by the requirement engineer, of how a new behaviour impacts the constituent systems could lead to conflicts and poor operation of the system. Therefore, identifying and resolving such scenarios is crucial for defining adaptation strategies as well assuring the achievement of the system global requirements. In this paper, a systematic adaptation-oriented requirement modeling approach for Systems of Systems, called ADORE, is presented. The proposed approach relies on the Cognitive Work Analysis (CWA) framework and Goal-oriented Requirements Engineering concepts to define three phases, each of them with a specific output model, that aim at modelling the system domain, identifying the collaborative tasks and analysing the scenarios and adaptations strategies. The approach is used to model a drone medical delivery system in order to demonstrate its applicability.
Identifying How the Brazilian Software Industry Specifies Legal Requirements
[Background] Software requirements are usually specified in Natural Language, bringing challenges for Requirements Engineering (RE) as these specifications are inherently ambiguous. These challenges become bigger when dealing with software requirements that must comply with regulations, the so-called legal requirements. The state of practice to tackle ambiguity of legal requirements and their compliance with regulations is missing. [Goal] This work investigates how ambiguity in legal requirements specification is addressed and how the software development industry performs legal compliance. [Method] We followed a qualitative approach based on semi-structured interviews involving nine professionals from different companies who presented their views on the RE process, including legal compliance and ambiguity resolution of legal requirements. Data was collected using audio-recorded and analyzed using Grounded Theory. [Results] Findings revealed that customer and legal expert support during the project could reduce the risk of misinterpreting the legislation. Verification and Validation of Legal Compliance are customer assignments. [Conclusions] Ambiguity resolution and legal compliance of requirements are based on the tacit knowledge of experienced team members or discussions between the team and the customer.
This paper introduces the modifiable source code virtual view concept, which is a variant of a source code fragment from the version used to generate the binary code for execution, enriched with information provided by the impact analysis process. A modifiable source code virtual view supports the maintenance process instead of the corresponding source code fragment used to generate the binary code, as is the current practice today. The set of key maintenance attributes (maintainability, reusability, etc.) are improved in the view, while the (opposite) set of key software execution attributes (performance, security, etc.) are improved in the source code fragment to generate the binary code. In between, there are refactoring transformations that adjust the metrics related to each set of key attributes, which also support the propagation of modifications from the view to its corresponding fragment in execution.
Quality Evaluation of Self-Adaptive Systems: Challenges and Opportunities
Self-adaptive systems (SAS) can adapt their behavior to suit user preferences or contexts, as well as monitor their performance and adjust it if necessary. In addition to adaptation operations, self-adaptive systems communicate with sensors, actuators, and other devices. Due to the complexity and dynamism of SAS, many situations can compromise the functioning of the system, such as faults in adaptations, low performance to execute tasks, and context inconsistencies. To prevent the system of these problems, it is essential to ensure high levels of quality. However, due to the peculiarities of these systems, there are still challenges to perform quality evaluations in these systems. In this sense, this paper proposes a discussion about the quality evaluation of self-adaptive systems in the last years. As a result, we identify challenges, limitations and research opportunities related to SAS quality evaluation.
xOOHDM: Integrated development environment for creating and executing models in Web applications design
Web applications have several characteristics that differentiate them from conventional applications. However, they are often developed without considering such characteristics, even though there are specific methods for the design of these applications. This work proposes the combined use of the OOHDM method and executable models in an integrated environment for the model-driven development of Web applications. This environment provides a DSML for navigation modeling using the notations of the OOHDM and automatically generates the corresponding executable model, which permits simulating and testing this navigation without the need of code generation. It allows developers addressing specific aspects of web applications, such as hypertext, and identifying and fixing design problems beforehand via model execution.
Towards the Description and Representation of Smartness in IoT Scenarios Specification
Contemporary Software Systems (CSS) embraces the Internet of Things (IoT) paradigm. Such a paradigm has allowed new technologies, and it is leading to more autonomous and smarter software systems in the fourth industrial revolution. The demand for CSS has grown considerably, highlighting new challenges in their engineering to assure final quality. The lack of adequate software technologies to support the capturing of specific features, such as their smartness capacity, represents one of the challenges faced by software engineers in CSS. This work raises the discussions towards capturing and representing smartness regarding IoT software systems. Therefore, it investigates the use of a scenario-based requirements specification technique to support dealing with smartness in IoT software systems. The results of an observational study indicate that IoT scenarios could capture the smartness characteristics of the system, although, some previous experience in IoT can lead to better results, which suggests the need to more training of software engineers to deal with smartness in IoT software systems.
An Investigation of Influencing Factors when Teaching on Active Learning Environments
This paper presents an investigation on how students' background, previous experience and teams composition may influence the teaching process on active learning environments. Using a survey we were able to get data from students that participated in a two-year mobile application development course. We have found indicatives that the timeframe of an activity and the composition of the teams can have an impact students individual perception regarding the project. Moreover, our results also present indicatives that the number of students participating in a project may impact the students perception of projects.
Using Challenge Based Learning to Create an Engaging Classroom Environment to Teach Software Startups
Teaching entrepreneurship to computer science or software engineering students is challenging. Lecturers must find ways to effectively present the importance of focusing on the customers' problems and needs and work backwards to the technology. Additionally, the experience in the classroom has to be engaging and students must feel motivated to work on their given solution. We conducted a study describing the path of 30 software engineering students through an undergraduate software startup entrepreneurship course that applied Challenge Based Learning methodology to guide students' projects. Data was collected from both students and the lecturer through a semi-structured questionnaire applied at the end of each deliverable. Our preliminary results indicate that Challenge Based Learning methodology can strengthen students' collaboration and engagement in addition to helping in the process of learning how to develop a startup.
Willow: A Tool for Interactive Programming Visualization to Help in the Data Structures and Algorithms Teaching-Learning Process
Data Structures and Algorithms (DSA) are one of the main pillars of software development; however, abstractions around them are hard to teach and to be understood by students. The most common approaches adopted by instructors to demonstrate the behavior of DSAs are the use of resources like slides and whiteboard sketches to create program illustrations. This task may be slow and tedious because these illustrations need to be continuously updated to represent new algorithm inputs and modifications. In this paper, we propose Willow, a tool for Program Visualization Simulation (PVS), which supports user interactions to manipulate the generated visualizations. With these manipulations in the visualization, we expect the user to be able to create better examples, resembling Algorithm Visualization Simulation tools (AVS), which are specialized in providing visualizations for specific DSAs. We evaluated our tool through a preliminary qualitative study with teaching assistants from an introductory Computer Science course who all give review lessons to the students. Our preliminary results show that the tool was well accepted by the participants, but we still need more studies to validate the use of the tool in classrooms. With the use of our tool features in the teaching-learning process, we expect that instructors may be able to interactively and more clearly explain DSAs to their students, without the hassle of hours creating slides or drawing by hand messy examples of algorithms.
Experimenting with the Peanut Butter and Jelly Sandwich Challenge to Introduce Algorithmic Thinking and Test Case Writing
New approaches that offer good learning experiences driven to computer science education have been applied in different places. One of the ways adopted is the application of dynamics in classrooms that challenge students to work in groups and make relations to situations of their lives. Besides, to improve content retention and students engagement, humor is one good element that should be applied in these dynamics. The "Peanut butter and jelly sandwich challenge" is an example that allows including the idea of challenging students using humor as a support to instructional content. This paper explains how that dynamic was applied to two students' groups. The first experience was offered in a mobile programming course that follows a boot camp style and involved a multidisciplinary group with students from three universities. The dynamic applied was used to present the relevance of algorithmic thinking. The second experience used the first case as motivation, adapting it to cover contents focused on test case writing applied to students of computer science. In both cases we present results gathered, such as learning impact for the students.
Software Testing Education: dreams and challenges when bringing academia and industry closer together
Software systems are present in people's lives and they are increasing to the same extent as their complexity and their criticality. Therefore, we must ensure that these systems maintain high quality in order to behave as expected. To develop high quality software, it is essential to have qualified people who are knowledgeable about Validation and Verification (V&V) techniques, especially software testing. This paper reports on the teaching process in two undergraduate courses in two different contexts: Computer Science students, who can dedicate more time during the day to studying, and Information Systems students, who can only study during the evenings. To engage and motivate the students in the context of software testing learning, we studied ways to bring real industry problems to the classroom in order to adopt the Problem-based Learning (PBL) approach. We chose two real open source projects which, considering the feedback from students and professors, was a good decision. However, the approach requires students to take extra classes rather than teacher-centered approaches. Extra classes may hinder the approach when the class consists of students who work during the day, thus developing a balance between student-centered and teacher-centered can be a good solution in such contexts.
Towards a Conversational Agent to Support the Software Testing Education
The training of professionals in the field of software testing is increasing its relevance in the past few years and, therefore, efforts in appropriate methodologies for the learning-teaching process in this context have been proposed and appreciated. The emergence of pedagogical models, such as flipped classroom and team-based learning, which demand from the students a previous study of the theory before the lecture, creates a concern: how to support the before class learning? Because of the hybrid nature of these pedagogical models, which means they mix elements from traditional and distance education, it is possible that the support mechanisms used in distance learning platforms, such as conversational agents, can be applied for this matter. At the same time in which the academic work tries carefully to provide a proper software testing formation, there are also many contributions being established regarding the training and non-formal learning. Improvement and personal training courses about criteria, tools, and software testing good practices are being created by teaching institutes and offered in Massive Open Online Courses platforms (MOOCs). However, in this type of course, in the absence of a teacher, the student might be in a situation where there is nobody available to answer their questions about the topic. In this paper, we propose the use of conversational agents in solving the problems and challenges which encompass the learning through MOOCs and hybrid models. A conversational agent, called TOB-SST is proposed to support software testing education. A viability study was conducted to understand the quality of the given answers by TOB-SST and the possibility of it serving as a learning support tool. The results indicate that it is promising to employ a conversational agent to guide student study.
A Report on the Teaching of Software Ecosystems in Software Engineering Discipline
Software Engineering is a crucial discipline present in several undergraduate courses, often due to the incorporation in its curriculum and many times focusing only in technical artifacts analysis, which leads to restricting social and business aspects, and limiting a global vision. Software Ecosystem (SECO) is a collection of software products with some degree of symbiotic relationship, consisting of a set of actors working as a unit interacting with a market distributed between software and services, along with the relationships between these entities. Motivated by the SECO diffusion, the idea of incorporating its teaching in the Software Engineering discipline seems to be attractive. However, a drawback to SECO research is the lack of modeling support. Furthermore, there is a need for more examples of SECO models, mainly close to the students' reality. This work aims to report the teaching of SECO in the Software Engineering discipline. For this, a qualitative analysis of a questionnaire with students' answers was designed. As a result of this work, we concluded that adding the teaching of ECOS in the Software Engineering discipline provides a global view of the systems development, mainly social aspects and evolution.
Software Engineering Practices in the development of applications for Smart Cities: An Experience Report of Teaching in a Contemporary Context
The heterogeneity of contemporary systems has turned the Software Engineering (SE) area even more challenging, since it is necessary to identify practices that are more adequate according to the technologies and context. Thus, practitioners need to be better prepared for these new systems. The area of Smart Cities (SC) is emerging and presents new challenges in conceptual, technical and academical degrees. This paper presents an experience report of SE practices in the development of SC applications. Five teams used the SC platform and developed their projects, creating software documentation, while applying agile practices. As a result, we identified that some UML diagrams were not adequate to model specific SC's aspects and microservices. Furthermore, we identified that there was a low application of the proposed agile practices, such as pair programming and daily meetings. Despite being the first time this class was taught, we identified gaps that need to be investigated in order to identify which SE practices are more adequate for such context.
A Qualitative Study of Teaching Requirements Engineering in Universities
Requirement Engineering education shows itself as relevant when considering its possible benefits to the training of students of Computer Science courses, such as Software Engineering, Computer Engineering, Information Systems and Computer Science. In the literature, many challenges that come from the process of Requirements Engineering in the industry are described. Regarding the academic environment, the initial training of Requirements Engineers still happens in the undergraduate programs and many challenges may happen in this context. Considering that context, this paper presents how the discipline of Requirements Engineering is taught in undergraduate courses on the Computer Science area in Brazil, from the perspective of the lecturers. The research shows the teaching methodologies, the evolution of the discipline over the years, the forums used and the challenges faced by lecturers when teaching requirements documentation. Based on that purpose, a survey with open questions was conducted with lecturers from different institutions. The results showed the similarity in the way the discipline is taught, challenges common to the lecturers, their desire for studies to diversify teaching methodologies, and the creation of exercises and more efficient context simulations. Besides that, it is listed different methodologies used by lecturers to mitigate the challenges and problems faced, as well as research sources for subjects related to Requirements Engineering that can support the planning and teaching-learning processes of the discipline, according to the experience of those lecturers.
FLOSS in Software Engineering Education: Supporting the Instructor in the Quest for Providing Real Experience for Students
Software engineering courses play an important role in computer science programs and are expected to provide the required basic knowledge and skills for professional practice in software industry. However, teaching software engineering principles, concepts and practices, and relating them to real-world scenarios are challenging tasks. The adoption of open source software projects may address such challenges. In this paper we report on an experience of the teaching object-oriented modeling with Unified Modeling Language (UML) Class Diagrams using open source projects. We conducted a case study with students of the software engineering discipline of the Computer Science course. We supported the instructor in some activities related to syllabus planning, including the selection of a Free/Libre/Open Source Software (FLOSS) projects and the creation of examples to be used in the classroom. The instructor selected and used a small FLOSS project to support the modeling activities. Then, the instructor applied an evaluation activity and a perception questionnaire about the methodology used. After the end of the classes, we conducted an interview with the instructor to present a brief report of his experience in the classroom. In the perception of students, the experience with FLOSS projects enhanced their ability to handle real projects and third-party code, and to deal with the job market. They also reported developing skills such as proactivity and communication. From the instructor's perspective, the group was enthusiastic and dynamic, and interacted more during practical activities.
Most common errors in software modeling using UML
This article adresses recurrent errors in software modeling made by students from Software Engineering courses. Software Modeling teachers and related literature agrees that there are certain patterns on errors made by students, although there is no detailed description of them. In this context, we evaluated 2 editions of Requirements Engineering and Systems Analysis of a Software Engineering course with a total of 41 students. Based on this analysis, student errors instances were compared with those found through a literature review, especially the ones involving text interpretation and abstraction difficulties, given these are essential skills for designing and representing models. Our results include a list of most common software modeling errors along with a description of each one, and the resulting catalog can support teachers who seek to develop techniques using error as a mediating instrument for teaching and learning as well as a fundamental resource to reduce them.
Strategies for Use Case Modeling: A Systematic Literature Review
A major challenge in teaching use-case modeling (UCM) is to mitigate the difficulties of students that prevent them from producing use-case models with quality. The strategies for UCM are scattered in the literature in several areas, and may not be known to the students, who therefore fail to receive the benefits that would mitigate their difficulties. This paper aims to present a systematic literature review (SLR) to identify, gather and analyze strategies for UCM. During the SLR, two thousand two hundred sixty-six studies published between 2008 and 2018 were returned from 6 bases (ACM, IEEE, Scopus, Science Direct, SpringerLink and Engineering Village), which resulted in the selection of 39 primary studies. These were classified, following the coding procedures of Grounded Theory, into 13 categories of different strategies for UCM. The results can help teachers in the adoption of the most appropriate UCM strategies for their students. Besides, they provide a quick reference for teachers and researchers interested in conducting additional studies on teaching strategies for UCM.
UML Acceptance: Analyzing the Students' Perception of UML Diagrams
Unified Modeling Language (UML) has been adopted as a standard modeling language in the software industry for the graphical representation of analysis and design models. Due to its importance, UML is taught in most undergraduate majors in Software Engineering and Computing. However, little is known about the students' perception regarding the UML diagrams. Their perceptions may influence the diagrams' adoption since the students are future software engineers. This paper aims to start filling this gap by better understanding students' perception regarding UML diagrams acceptance. To achieve this goal, we applied a Focus Group to foster a discussion with undergraduate students about five UML diagrams. Besides, we applied the Technology Acceptance Model to assess the students' acceptance regarding these diagrams. Based on the results of this study, students considered use cases and class diagrams useful for designing systems, although they stated that their modeling was not easy. We also noticed that the perceived usefulness was the construct that most influenced the students' intention to use these diagrams. Our research benefits instructors interested in understanding the students' perceptions about UML, enlightening the points that they need to reinforce to show the benefits of the modeling language. Still, the instructors are invited to reflect on other teaching strategies to show the importance of these diagrams in the software development process.
Agile Teaching Practices: Using TDD and BDD in Software Development Teaching
In this paper, we aimed to analyze the application and contribution of the use of Test-Driven Development (TDD) and Behavior-Oriented Development (BDD) in Software Engineering teaching. As empirical research, we presented an experiment conducted in the Software Engineering Laboratory (LES) course of a Private University (Tiradentes University) in the Bachelor of Computer Science and Information Systems courses. This experiment demonstrated the fundamentals in verifying the learning difficulties of students. Collected data were subjected not only to quantitative analysis but also to appropriate statistical analysis. The results showed a reduction in student absences, higher student satisfaction rate and higher grades in the courses. Furthermore, our approach allowed students to deliver a product in a short period, representing a possibility of adoption of BDD due to their successful learning experience.
An Experience Report on Using LEGO-based Activities in a Software Engineering Course
As a natural social evolution, new generations tend to bring a shift in behavior and mindset. Studies have shown that millennial students prefer an active learning approach instead of traditional lectures. In Active Learning, instead of passively listening, students learn by participating in more engaging activities. As a way to gradually transition to that approach in a Software Engineering course, we started experimenting LEGO-based activities, which provide a simplified way to understand concepts that would be too large or too difficult to demonstrate if using programming languages to build software from scratch. In this paper, we present an experience report on students learning and practicing software engineering concepts using LEGO bricks in two different activities: requirements engineering and agile project management. We adapted practices taken from industry-tailored training approaches and applied them in an undergraduate course classroom, collecting feedback from students through quantitative and qualitative data. We describe the approach, the perception of students and the lessons learned while teaching using that approach.
CleanGame: Gamifying the Identification of Code Smells
Refactoring is the process of transforming the internal structure of existing code without changing its observable behavior. Many studies have shown that refactoring increases program maintainability and understandability. Due to these benefits, refactoring is recognized as a best practice in the software development community. However, prior to refactoring activities, developers need to look for refactoring opportunities, i.e., developers need to be able to identify code smells, which essentially are instances of poor design and ill-considered implementation choices that may hinder code maintainability and understandability. However, code smell identification is overlooked in the Computer Science curriculum. Recently, Software Engineering educators have started exploring gamification, which entails using game elements in non-game contexts, to improve instructional outcomes in educational settings. The potential of gamification lies in supporting and motivating students, enhancing the learning process and its outcomes. We set out to evaluate the extent to which such claim is valid in the context of post-training reinforcement. To this end, we devised and implemented CleanGame, which is a gamified tool that covers one important aspect of the refactoring curriculum: code smell identification. We also carried out an experiment involving eighteen participants to probe into the effectiveness of gamification in the context of post-training reinforcement. We found that, on average, participants managed to identify twice as much code smells during learning reinforcement with a gamified approach in comparison to a non-gamified approach. Moreover, we administered a post-experiment attitudinal survey to the participants. According to the results of such survey, most participants showed a positive attitude towards CleanGame.
Fábrica de Tecnologias Turing: A Strategy for Effective Teaching of Software Engineering
The focus on the need for improvements and innovations in the environment and teaching practices is increasingly evident. Mainly in the courses of computer engineering, it is justified by the change of profile of the students and fast evolution of the technologies. This paper presents an academic software factory approach, used as an effective teaching strategy for Software Engineering. In this context, aspects of contributions to the profile of the Software Engineer in relation to interpersonal, specific and scientific skills and competences are discussed. Therefore, it characterizes a active methodology approach, as well as an alternative to enhance the relationship between teaching, research and university extension.
Masters of the Process: A Board Game Proposal for Teaching Software Management and Software Development Process
Software Engineering (SE) education has a current challenge to provide sufficient hands-on experience for their students. Game-based learning represents a promising alternative to teach computing in higher education, promoting an "active learning" and serving as entertaining means for drill and practice. This paper presents "Masters of the Process", a board game proposal for teaching software management and software development process competences. For this, the design, construction and evaluation steps of the proposed game are described, as well as the usability results together with a brief comparison among SE board games. As a result, a simple, interactive and multiplayer game was provided, able to teach important SE concepts in a practical, competitive and funny way.
Students Perception on the use of Project-Based Learning in Software Engineering Education
Balancing theory and practice is a recurring challenge in Software Engineering (SE) education. However, the curriculum guidelines of the ACM/IEEE and Brazilian Computer Society emphasize the need of providing students with sufficient practical experiences for the development of competences expected for SE professional. Student-centered and learn-by-doing approaches, such as Project-Based Learning (PBL), have been advocated as suited for the development of competences. These approaches aim to promote higher motivation for the learner, a more active role in the learning process, and better learning in the application level. The goal of this paper is to evaluate the students' perception on the adoption of PBL in SE education. To achieve this goal, we performed a long-term study spanning for about 2 years. This study includes a survey to collect responses of 32 undergraduate students enrolled in an introductory SE course that used PBL. We compare the results to the responses of 17 students who participated in a SE course with similar syllabus but with a traditional teacher-centered learning method (non-PBL). Our results show a positive reception of the PBL method, and an increased perception of the contribution of a practical software development assignment in learning specific SE topics in the context of the PBL course, in comparison to a non-PBL method.