Well-written code (which meets standards, conventions, and quality specifications) is often associated with the programmer's experience, which is why companies have been looking for increasingly qualified professionals. Codes at odds with these standards tend to be complex and poorly written and are generally difficult to understand. Consequently, the activities inherent to it become costly. Although well defined and consolidated in the industry, the concepts of code quality taught in the academy are insufficient to enable students to meet market expectations. Research indicates that graduates do not feel prepared to enter the labor market, facing difficulties when competing for the best job opportunities. This difficulty highlights a gap between industry and academia. Researchers have identified the gap and have proposed improvements to the teaching-learning process based on using the concepts and tools widely used in the software industry in an academic environment. When analyzing educational institutions' programming disciplines, it is possible to notice a mismatch between programming disciplines and code quality disciplines. In this scenario, this project aims to propose improvements on how knowledge of programming and quality is evolved, proposing an approach that uses software quality as a subsidy for teaching programming, providing the teacher with guidelines for teaching programming focusing on internal quality source code. We idealized an innovative practice that brought programming, usually focused on the execution of algorithms, within the teaching of code quality, focused on software engineering principles. The use of code inspection tools allowed direct teaching according to the class's needs, introducing a guided content-based internal quality teaching in programming disciplines without generating extra work for the teacher. In addition to the improvements for the teacher, we are convinced that from the student's perspective, we were able to motivate them to learn to program not only concerned with the execution results but also how the solution is developed.

The selection of variables in a given experiment is crucial, since it is the theoretical foundation that guides how data should be collected and analyzed. However, selecting variables is an intricate activity, especially considering areas such as Software Engineering and Education, whose studies should also consider human-related variables in the design. In this scenario, we aim to investigate how a support mechanism helps in the variables selection activity of the experiment process. To do so, we conducted a preliminary study on the use of an experimental framework composed of a catalog of variables. We explored the domain of the integration of software testing into programming education. Participants were divided into two groups (ad hoc and framework support) and asked to select variables for a given experiment goal. We analyzed the results by identifying threats to validity in their experimental design drafts. Results show a significant number of threats of type inadequate explication of constructs for both groups. Nonetheless, the framework helped to increase the clarity of concepts selected as variables. The cause of most raised threats, even with the framework support, was an inaccuracy in selecting the values of such variables (i.e. treatments and fixed values).

This Research Full Paper presents an overview of the practices that have been used to integrate software testing into programming education. Introductory programming courses compose the core of several undergraduate programs, since programming is a crucial technical skill for professionals in many areas. Given the subject importance, researchers have been conducting several studies to investigate teaching approaches that can help overcoming students' learning difficulties. In particular, studies on introducing software testing into this context present evidence that testing practices can improve students' programming performance and habits. There are many teaching approaches in programming education, which involve different choices of programming paradigm and language, support tools and development practices, such as version control. Likewise, the integration of software testing into such diverse context can also happen in many different ways. Therefore, investigating the ways to teach programming and testing at the same time can help instructors with informed choices. In this sense, we identified teaching practices that have been adopted to integrate software testing into programming education. To do so, we further analyzed a subgroup of 195 papers that returned in our systematic mapping on this research domain. We selected papers describing empirical studies (e.g. survey, qualitative studies, experiments, case studies and experience reports), since this kind of study involves applying a given teaching practice in order to collect evidence or report the observed experience. Overall, our results shed light on how the integration of software testing has been done in different classroom contexts of programming education. We discuss the practices in terms of their application context (i.e. the course), how testing was introduced in theory and practice, and the adopted support tools. We also discuss an important gap regarding the lack of instruction in testing concepts, even when students are responsible to write their own tests.

Computer Science teaching materials are biased towards concepts and theoretical aspects. One may consider it difficult to relate concepts to concrete problems. Consequently, it increases the chances of a student not recognizing the relevance of the subject, becoming unmotivated and unprepared to solve practical problems or coping with workplace needs after college. This paper shows the use of social media data as an alternative to minimize the skill gap between what the student learns in college and the skills required in the workplace. The proposed strategy consists of extracting topics from Stack Overflow questions to identify concepts generally unknown or misunderstood and concepts that their practical application represents a challenge. The concepts covered in Stack Overflow questions provide strong cues about how professors and instructors can improve teaching material with useful content for their students, as well as increase their motivation -- since the teaching material becomes clearly related to practical issues in Computer Science. We show, by an example, how to use the proposed strategy to improve teaching material from the generated topics. Also, we demonstrate that the application of topic modeling in Stack Overflow content is promising as a professor support tool to enhance teaching material relevance in Computer Science courses and diminish the college-workplace skill gap.

Traditionally, students learn about software testing during intermediate or advanced computing courses. However, it is widely advocated that testing should be addressed beginning in introductory programming courses. In this context, testing practices can help students think more critically while working on programming assignments. At the same time, students can develop testing skills throughout the computing curriculum. Considering this scenario, we conducted a systematic mapping of the literature about software testing in introductory programming courses, resulting in 293 selected papers. We mapped the papers to categories with respect to their investigated topic (curriculum, teaching methods, programming assignments, programming process, tools, program/test quality, concept understanding, and students' perceptions and behaviors) and evaluation method (literature review, exploratory study, descriptive/persuasive study, survey, qualitative study, experimental and experience report). We also identified the benefits and drawbacks of this teaching approach, as pointed out in the selected papers. The goal is to provide an overview of research performed in the area, highlighting gaps that should be further investigated.

This Research Full Paper presents an analysis of the challenges and advantages on applying MOOCs in software engineering teaching and training contexts. Software engineering is a constantly evolving discipline in which educators are involved with a constant flow of new tools, resources and techniques in software development. This scenario makes the act of teaching and contributing to the students' academic education more complex. The insertion of educational technologies brings contributions in this context, causing a transformation in the current scenario of teaching. An example of these new technologies are the MOOCs (Massive Open Online Courses) - open and online courses that are available in providers in partnership with reputable universities. Considering this scenario, this paper aims at identifying the challenges and trends of MOOCs application in software engineering domain, by means of a systematic mapping of the literature (SML). During the SML it was performed an analysis of 5100 papers and selection of 96 primary studies. The outcomes indicate that there is a potential in using MOOCs on teaching or training, as they are an alternative to offer courses applying traditional methods of learning. In addition, the challenges of this direction are analyzed and discussed.

This research full paper presents a study on graduates' knowledge gaps in software testing according to industry needs. Several studies indicate that students graduate from computing programs with a knowledge gap in software testing. In this sense, we aimed to investigate in details this broader testing gap, by considering gaps in the level of testing topics. We conducted a survey with Brazilian practitioners in order to collect data (N=90). For each testing topic, knowledge gaps were calculated as the difference between what respondents' learned/practiced in undergraduate courses and what they actually applied in industry after graduating. Results provide evidence on points that could be improved in software testing education. Firstly, for all testing topics there was a negative gap on practice activities. This means that students could benefit from more testing assignments throughout the curriculum. Regarding gaps in concepts, some testing topics presented negative gaps (such as test in web applications) and others positive (such as test in aspect oriented software and mutation analysis). Therefore, results suggest that it is possible to counterbalance them in order to reduce the existing gaps. We also present respondents' opinions about their experience in software testing education and industry practices.

Software testing can be very helpful to students if adopted in programming assignments throughout the Computer Science curriculum. Many testing practices involve students writing their own test cases. This approach implies that students are responsible for the test design task while performing the test activity. On the other hand, some testing practices follow the opposite approach of providing ready-made test cases, so students only need to execute and evaluate test results for their solution code. In this paper, we investigated the effect of test design in student programming performance. We conducted an experiment comparing two different testing approaches during programming assignments: student-written and instructor-provided test cases. We also assessed students' perceptions of this subject by means of a survey. Results suggest that when students are responsible for test design, i.e. when they write their own test cases, they perform better in programming assignments.

Teaching mathematics for engineering students is very important. New undergraduate students are aware that they will need mathematical concepts in professional activities. It is still usual to observe not only the difficulty of students in mathematical disciplines, but also the lack of motivation for those disciplines. Motivate and keep motivated the engineering students to mathematical disciplines are a challenge for the teacher. In the literature, it is possible to observe the use of modeling tools of mathematical problems, some of them able to simulate models. Those tools have been used to try to motivate students, but with a technological bias that may introduce difficulties. In this paper we propose an approach to teaching-learning process of mathematical concepts to engineering students with a motivational factor: a practical problem to be modeled in which students must apply concepts seen in class, in particular using the Ordinary Differential Equations (ODE). Each student can choose a problem of his/her interest, which increases motivation. The problem chosen must be explored to create mathematical models involving multiple concepts, which allows the comparison of results. Students must create models using existing computational tools, preferably of free use, supported by instructor. So, the students are allowed to apply the concepts acquired to develop projects with transversal themes aiming to verify the capability and the use of these tools in learning mathematical concepts. Also, this paper presents an application of the approach proposed in Numerical Methods for Differential Equations course. We observed that the use of computer tool to model a real problem chosen by students has improved the interest and, consequently, facilitated the teaching-learning process. Also, it may develop in students a new vision on how they can build their knowledge. We also discuss ways in which the computational resources and everyday problems can help in math classes and arouse creativity, motivation and mathematical logical reasoning in engineering students.

Software Quality Assurance is a sub-process that ensures that developed software meets and complies with defined or standardized quality specifications. Focusing on source code, there are characteristics that can be used to evaluate the quality. Introductory courses must encourage freshmen students to improve internal quality of their source code, but only as sophomore they have contact with Software Engineering concepts, including Quality Assurance. In this paper we present a tool to source code quality evaluation aimed at supporting students to improve their source code and, consequently, their programming skills. The proposed tool uses quality reports (available to professional environment integrate with software repositories) to analyze students' source code and provide a feedback about the student coding. The proposed tool run locally, with few computational resources. In addition, we proposed the methodology to use the proposed tool: it consists of challenging students to perform a set of maintenance tasks in a controlled environment. We prepared a source code by introducing common defects, what decreases the quality of source code, and ask to students to perform maintenance tasks in order to both eliminate the introduced defects and introduce new features. After each modification, the students must evaluate their code using the proposed tool to obtain a feedback about quality of source code. To evaluate the approach and the tool, we created a survey and applied to students and the teacher. As a result, we show the benefits of using the proposed tool to both teachers and students perspectives. The results are positive to enhance the teaching-learning Software Quality Assurance to Software Engineering students.

Several studies suggest that the teaching of software testing should begin as early as possible, since introductory programming courses. In this way, the teaching of both subjects, programming and testing, becomes an integrated teaching approach. Testing practices in this context can provide a timely feedback to students while they are still working on programming assignments and, as a result, increase the quality of their code. Besides, developing students' testing skills earlier is useful to improve their programming skills as well, since both kinds of skills are complementary. However, this integration is not straightforward, because lecture hours and the coverage of programming topics must remain the same, while testing concepts and practices are introduced. For this reason, when designing an educational approach to introduce testing practices to novice programmers, there is also the need to address potential difficulties faced by both students and instructors. Considering this scenario, this paper aims at identifying the challenges raised due to the integration of software testing into introductory programming courses. The goal is to provide support for instructors who intend to adopt the integrated approach. The challenges have been identified from the results of a systematic mapping we conducted of the literature in this domain. The main contribution of this paper refers to the establishment of a catalog of challenges faced to integrate software testing into introductory programming courses. We also discuss possible solutions to design courses using the integrated approach and point out challenges that have been scarcely addressed in the literature. Finally, we indicate directions that can be explored in future educational empirical studies in this context.

The traffic between computer networks must be controlled to prevent unauthorized access. Firewall is responsible for filtering data packets between networks, applying rules to select data packets that can get in/out to access the network. The firewall must be configured accordingly network access policy. Therefore, the students have to be trained to acquire skills not only to understand network access policy, but also to translate it into firewall native language. The use of a graphical representation (high level) to model the network access policy consist in a resource to facilitate understanding and to minimize defects on firewall native language. For that, we have proposed an extension to Security Policy Modeling Language (SPML), the SPML2, which aims to create a visual representation of the network access policy using graphical notation. Also, in this paper we present SP2Model, a web based tool to support SPML2 network accesses policy modeling and its translation into firewall native language. Using the SP2Model, the student can model the network access policy in a graphical notation and, then, can generate the set of rules in firewall native language. The use of SP2Model has facilitated the teaching-learning process, compared to traditional approaches. We evaluated SP2Model (and consequently the SPML extension) through an experiment following the GQM paradigm (Goal / Question / Metric) comparing the traditional approach and the use of SPML2 in operational security education. We performed two experimental sessions and we present the results, as well as a discussion about the tool, its use and the trade-off on using it.

Theoretical Computer Science area (TCS) stands out by being an important study field, and it is composed by Formal Languages and Automata Theory (FLA), Computer Science Theory (CST), and Theory of Compilers (TC). This area is responsible for introducing the beginnings of the Computer Science through formalisms - which represent a set of methods, techniques, or rules that describe the solution to a problem with restrictions - and it has a substantial impact on the student's knowledge. Computer science theory is based on the understanding of computability and techniques to solve challenges, and to improve the teaching-learning process used to introduce these concepts we proposed a Combined Methodology for Theoretical Computing (CMTC). Our methodology is based on formalism development to ground the knowledge acquired during classes of FLA, CST, and TC, where students are introduced to Theoretical Computing during one year and a half. In each course, we applied the same methodology where each student used data structures, computer graphics, and algorithms to solve problems. We address this methodology to understand how much the incomprehension of formalisms is influenced by new concepts and its abstractions. Against this background, we demonstrate that the that CMTC has the aim to build knowledge and make the new concepts and formalisms concrete. Our results are based on statistical analysis from students' grades, where we could observe among other results, the correlation between the practical activities and the conceptual knowledge.

Project management is an essential activity across several areas, including Software Engineering. Through good management it is possible to achieve deadlines, budgets goals and mainly delivering a product that meets customer expectations. Project management activity encompasses: measurement and metrics; estimation; risk analysis; schedules; tracking and control. Considering the importance of managing projects, it is necessary that courses related to Information Technology and Computer Science present to students concepts, techniques and methodology necessary to cover all project management activities. Software project management courses aim at preparing students to apply management techniques required to plan, organize, monitor and control software projects. In a nutshell, software project management focuses on process, problem and people. In this paper we proposed an approach to teaching and learning of software project management using practical activities. The intention of this work is to provide the experience of applying theoretical concepts in practical activities. The teaching and learning approach, applied since 2006 in a Computer Science course, is based on teamwork. Each team is divided into groups assuming different roles of software process development. We have set four groups, each one assuming a different role (manager; software quality assurance; analyst and designer; programmer). The team must be conducted across the software process by its manager. We use four projects, each group is in charge of managing a different project. In this paper we present the proposed approach (based on hands on activities for project management); we summarize the lessons learned by applying the approach since 2006; we present a qualitative analysis from data collect along the application.

Digital Image Processing (DIP) consists of a set of techniques to acquire, represent and transform digital images. Through these techniques, it is possible to extract and identify information of images and improve the visual quality by facilitating human perception and interpretation by computer systems. However, the Digital Image Processing teaching is hindered by the complexity of implementation of many techniques, on several occasions is not possible that student visualize the results of DIP techniques when are discussed during the course. This paper presents an experiment over a web platform to support the teaching of digital image processing. The goal of this platform is not replace coding techniques, but allow rapid visualization and experimentation of studied methods, without be necessary to install software or previous knowledge of a specific programming language.

Formal languages and automata (FLA) theory have fundamental relevance to the base of knowledge in the computer science area, especially focusing on scientific education. Usually presented by a discipline, the teaching-learning process of FLA is characterized by the high level of abstraction, and it is considered difficult due to the complexity of language formalisms. As support for the learning process, tools have been used to simulate language formalisms. However, the simulation is not enough to reinforce the construction of an abstract concept. In this paper, we present an FLA teaching-learning methodology based on the development of simulators as an approach to clarify the formalism for the students. Through developing their simulators, students are exposed to the data structure and algorithms to handle the formalism. Consequently, students have the opportunity to make the concept concrete.

Several multidimensional projection techniques have been proposed in literature over the last years. The quality of those techniques can be evaluated based on the dimensionality reduction or the clusters quality. The first evaluation aim to verify if the similarities from multidimensional space are preserved in projected space. While the second evaluation aim to verify if instances from a same class are placed in a same cluster in projected space. Respectively, Stress and Silhouette Coefficient are the main measures to quality evaluations. In this paper we present two new approaches -- named Simplified Stress and Simplified Silhouette Coefficient -- to speed up the computation of measures, enabling a faster evaluation of multidimensional projection techniques and feature spaces. We present experiments showing the high correlation between results obtained using original approaches and results obtained with those proposed in this paper. In addition, we show how to use Simplified Silhouette Coefficient to perform a fast feature space evaluation and selection.

Data synchronization is a process of establishing equivalence among two data collections. It is essential to distribute databases and several techniques have been implemented in Database Management Systems (DBMS), but it is not a feature for free use versions. Focusing on mobile computing, applications that perform data synchronization have become increasingly popular. However, due to lack of internet connection, synchronization process requires specific features to take place in an asynchrony way. The MySQLite Sync middleware, presented in this paper, perform data synchronization among databases stored in mobile devices and DBMS. To validate our proposal we adopted metrics based on time and number of primary and foreign keys mapped after synchronization, in order to maintain data integrity. The results obtained are presented and discussed showing positive contributions.

The Data Structure discipline consists on studying data organization in computer memory, primary and secondary ones. Data structures are organized using conceptual and behavioral issues that require high degree of abstract representation. It has been observed significant difficulty, by students, to understand the abstract concepts related, which is observed during practical tasks. In fact, practical tasks are essential to consolidate knowledge about data structures, but the students need support to understand the concepts before practical tasks. There are several works in literature showing tools to support conceptual and behavior comprehension, each one with specific features. However, the tools by themselves are not enough, dealing with specific data structure, with severe constraint. In literature, some tools are presented using case studies specific to the data structures supported. And we observed that the tools are presented focusing on their functionalities (the case studies are designed to explore such functionalities). Also, we observed the lack of a methodological approach to incorporate tools in a learning process effectively. In this scenario, we address the use of technological support to teaching-learning process. We propose a methodology based on constructionism, in which students, tasks (home works) and tools are coordinated by a teacher in favor of knowledge construction. In order to present our methodology, we use a learning tool, named CADILAG, developed using visual resources to support students understand data structures concepts. We applied the methodology proposed for two years. The positive results are observed in students grades and their evaluation. Also, according to the teacher, the students have shown interest and motivation.

The development of large-scale distributed virtual environments deals with restrictions imposed by the infrastructure of communication systems. The scalability in those systems is an important issue to consider on designing and shows higher complexity, as the resources managed by the system increases. AVDNet - an architecture for scalable distributed virtual environments presented in a previous work - helps to reduce the amount of packets sent over the communication network. Besides, the computational processing on rendering is also reduced by using AVDNet, since the virtual environments is created using regions that separate spatially the environment. However, the AVDNet has restrictions on dealing with bandwidth management and the choice of servers, considering their availability. In this paper we present an analysis of scalability using the application layer anycast. To conduct this analysis we use the AnyAVDNet, a framework that implements the dynamic load distribution among servers of AVDNet regions. In addition, we show the metrics and the results.

The number of images available has grown over the years, as well as the number of techniques to aid to organizing and retrieving from image collections. Techniques and systems have been proposed to recover images based on query, in which an image (or words) is used as input parameter and a list of similar images (or images with related text content) is recovered. However, understanding how the retrieved images are related to each other remains as a problem. This paper proposes an approach based on multidimensional visualization and coordination techniques to show the relationship from retrieved images. In this approach, coordination techniques are employed to perform image retrieval methods and highlight the results in visual representations, showing how retrieved images are relate. To evaluate our proposal image collections with and without textual annotations related to each image were used, and also image retrieval mechanisms based on distance, topic and semantic to retrieve images from distinct and multimodal datasets.

Visualization techniques have proved to be valuable tools to support textual data exploration. Dimensionality reduction techniques have been widely used to produce visual representation of document collections. Focusing on multidimensional projection techniques, good visual results are produced depending on how representative terms to discriminate the documents are chosen to compose the vector space model (VSM). To define a good VSM it is necessary to apply filters during the preprocessing in order to eliminate terms using their frequency. For that, the user must evaluate the term frequency histogram based on his/her expertise in the text subject and decide the threshold value for frequency cut. Usually it is a trial and error approach that requires the user to verify the quality of visual representation after each trial. In this paper, we propose an automatic approach that applies the Otsu's Threshold Selection Method for computing a threshold using a term frequency histogram. We conducted experiments that have shown our approach generates visual representations as good as those generated with a threshold obtained by trial and error approach. The contribution of our approach is that users with non expertise are able to generate good visual representations and the time to get a good threshold is decreased.

Multiple views of data sets from the same domain can support to discover unforeseen associations among data elements, but requires users to interact with them. The coordination mechanism must relate elements across multiple views. The mapping among data elements are constrained by using data attributes, and such mapping influences on how multiple views are coordinated. We propose the application of ontology to link data elements based on semantic for specific context. Representing the underlying data into ontology, semantic representation to create the mappings can benefit exploratory visualization. In this paper we show how to use ontology on coordinating multiple views, the initial results using document collections are presented and discussed, in comparison with traditional techniques.

The software industry has become more and more concerned with the appropriate application of activities that composes requirement engineering as a way to improve the quality of its products. In order to support these activities, several computational tools have been available in the market, although it is still possible to find a lack of resources related to some activities. In this context, this paper proposes the inclusion of a module to aid in the requirements specification to a tool called Requirements Elicitation Support Tool. This module allows to specify requirements in accordance with IEEE 830 standard, thus contributing to the documentation of the requirements established for a software system, besides supporting the learning of concepts related to the requirements specification, which improves the skills of users of the tool.

Exploratory tasks supported by visualization are usually improved by Coordinated and Multiple Views (CMV) of the data under study. Several coordination techniques have been proposed in the literature, resulting in a diversity of tools to generate mappings among the multiple views. These mappings can be highly dynamic, and their history reveals the settings employed in the multiple exploratory tasks conducted in a discovery process. Several solutions have been proposed to help users to recover the steps performed in exploratory tasks, but little support is found for registering the multiple coordination mappings employed. This paper provides a contribution in this direction, proposing a model for storing and recovering such mappings. We believe such a facility is an important feature of CMV systems, so that users can recover and rerun the coordinations performed when exploring their data. We present details of the proposed model and show some potential applications.

Most of architectures proposed for developing distributed virtual environment (DVE) allow limited number of users. To support the development of applications using the Internet infrastructure, with hundred or, perhaps, thousands users logged simultaneously on DVE, several techniques for managing resources, such as bandwidth and capability of processing, must be implemented. The strategy presented in this paper combines methods to attain the scalability required, in special the multicast protocol at application level.