Abstract Context Code smells (CS) are symptoms of poor design and implementation choices that may lead to increased defect incidence, decreased code comprehension, and longer times to release. Web applications and systems are seldom studied, probably due to the heterogeneity of platforms (server and client-side) and languages, and to study web code smells, we need to consider CS covering that diversity. Furthermore, the literature provides little evidence for the claim that CS are a symptom of poor design, leading to future problems in web apps. Objective To study the quantitative evolution and inner relationship of CS in web apps on the server- and client-sides, and their impact on maintainability and app time-to-release (TTR). Method We collected and analyzed 18 server-side, and 12 client-side code smells, aka web smells, from consecutive official releases of 12 PHP typical web apps, i.e., with server- and client-code in the same code base, summing 811 releases. Additionally, we collected metrics, maintenance issues, reported bugs, and release dates. We used several methodologies to devise causality relationships among the considered irregular time series, such as Granger-causality and Information Transfer Entropy(TE) with CS from previous one to four releases (lag 1 to 4). Results The CS typically evolve the same way inside their group and its possible to analyze them as groups. The CS group trends are: Server, slowly decreasing; Client-side embed, decreasing and JavaScript,increasing. Studying the relationship between CS groups we found that the "lack of code quality", measured with CS density proxies, propagates from client code to server code and JavaScript in half of the applications. We found causality relationships between CS and issues. We also found causality from CS groups to bugs in Lag 1, decreasing in the subsequent lags. The values are 15% (lag1), 10% (lag2), and then decrease. The group of client-side embed CS still impacts up to 3 releases before. In group analysis, server-side CS and JavaScript contribute more to bugs. There are causality relationships from individual CS to TTR on lag 1, decreasing on lag 2, and from all CS groups to TTR in lag1, decreasing in the other lags, except for client CS. Conclusions There is statistical inference between CS groups. There is also evidence of statistical inference from the CS to web applications’ issues, bugs, and TTR. Client and server-side CS contribute globally to the quality of web applications, this contribution is low, but significant. Depending on the outcome variable (issues, bugs, time-to-release), the contribution quantity from CS is between 10% and 20%.

Code smells are symptoms of poor design, leading to future problems, such as reduced maintainability. Therefore, it becomes necessary to understand their evolution and how long they stay in code. This paper presents a longitudinal study on the evolution and survival of code smells (CS) for web apps built with PHP, the most widely used server-side programming language in web development and seldom studied. We aimed to discover how CS evolve and what is their survival/lifespan in typical PHP web apps. Does CS survival depend on their scope or app life period? Are there sudden variations (anomalies) in the density of CS through the evolution of web apps? We analyzed the evolution of 18 CS in 12 PHP web applications and compared it with changes in app and team size. We characterized the distribution of CS and used survival analysis techniques to study CS’ lifespan. We specialized the survival studies into localized (specific location) and scattered CS (spanning multiple classes/methods) categories. We further split the observations for each web app into two consecutive time frames. As for the CS evolution anomalies, we standardized their detection criteria. The CS density trend along the evolution of PHP web apps is mostly stable, with variations, and correlates with the developer’s numbers. We identified the smells that survived the most. CS live an average of about 37% of the life of the applications, almost 4 years on average in our study; around 61% of CS introduced are removed. Most applications have different survival times for localized and scattered CS, and localized CS have a shorter life. The CS survival time is shorter and more CS are introduced and removed in the first half of the life of the applications. We found anomalies in the evolution of 5 apps and show how a graphical representation of sudden variations found in the evolution of CS unveils the story of a development project. CS stay a long time in code. The removal rate is low and did not change substantially in recent years. An effort should be made to avoid this bad behavior and change the CS density trend to decrease.

Context. Improving the efficiency and effectiveness of software development projects implies understanding their actual process. Given the same requirements specification, different software development teams may follow different strategies and that may lead to inappropriate use of tools or non-optimized allocation of effort on spurious activities, non-aligned with the desired goals. However, due to its intangibility, the actual process followed by each developer or team is often a black box. Objective. The overall goal of this study is to improve the knowledge on how to measure efficiency in development teams where a great deal of variability may exist due to the human-factor. The main focus is on the discovery of the underlying processes and compare them in terms of efficiency and effectiveness. By doing so, we expect to reveal potentially hidden costs and risks, so that corrective actions may take place on a timely manner during the software project life cycle. Method. Several independent teams of Java programmers, using the Eclipse IDE, were assigned the same software quality task, related to code smells detection for identifying refactoring opportunities and the quality of the outcomes were assessed by independent experts. The events corresponding to the activity of each team upon the IDE, while performing the given task, were captured. Then, we used process mining techniques to discover development process models, evaluate their quality and compare variants against a reference model used as "best practice". Results. Teams whose process model was less complex, had the best outcomes and vice-versa. Comparing less complex process variants with the ""best practice"" process, showed that they were also the ones with less differences in the control-flow perspective, based on activities frequencies. We have also determined which teams were most efficient through process analysis. Conclusions. We confirmed that, even for a well-defined software development task, there may be a great deal of process variability due to the human factor. We were able to identify when developers were more or less focused in the essential tasks they were required to perform. Less focused teams had the more complex process models, due to the spurious / non-essential actions that were carried out. In other words, they were less efficient. Experts' opinion confirmed that those teams also were less effective in their expected delivery. We therefore concluded that a self-awareness of the performed process rendered by our approach, may be used to identify corrective actions that will improve process efficiency (less wasted effort) and may yield to better deliverables, i.e. improved process effectiveness.

Context: Code smells are associated with poor design and programming style that often degrades code quality and hampers code comprehensibility and maintainability.Goal: In this paper, we investigated to which extent classes affected by the God Class and Long Method code smells were more susceptible to the occurrence of software bugs. Method:We conducted an exploratory study targeting two well known open source software projects, Apache Tomcat and Eclipse JDT Core Component.We applied correlation analysis in order to evaluate to which extent Long Method and God Class were related to the occurrence of bugs.Results: We have found a significant correlation of Long Method and Commits and, on the other hand, a poor correlation of God Class and Commits in the two analyzed projects.Therefore, we expected that the higher the number of occurrences of Long Method, the higher the chances of more commits in a class that contains this method, which could result in the increase of occurrence of bugs.Conclusion: Based on the results, we confirmed what other studies pointed out, regarding classes affected by Long Method being more bug-prone than others.In practice, we found evidence, from analyzed data, that the occurrence of Long Method implies more effort in maintenance tasks.

Multiple view interactive environments (MVIEs) provide visual resources to support the comprehension of a specific domain dataset.For any domain, different views can be selected and configured in a real time fashion to be better adjusted to the user needs.This paper focuses on the use of a MVIE called OctMiner to support the comprehension of MATLAB and GNU/Octave programs.The authors conducted a case study to characterize the use of OctMiner in the context of comprehension activities.Results provide preliminary evidence of the effectiveness of OctMiner to support the comprehension of programs written in MATLAB and Octave.

Java on the Eclipse IDE is a frequent choice for software development nowadays.Software Engineering researchers have built program analysis tools in that environment for several purposes.However, that requires a deep understanding of Eclipse internals, such as the Java AST.This paper discusses the feasibility of a metamodel-driven approach to scaffold the construction of such tools.Its core is the Eclipse Java Metamodel (EJMM), obtained through reverse engineering.The latter is instantiated with meta-objects representing the constructs of a given Java program.We then use OCL to traverse programs very easily.To validate the feasibility of our metamodel-driven approach to program analysis, we developed an Eclipse plug-in based on it, to support the metamodel-driven measurement (M2DM) approach.

This paper presents our approach for producing graphical user interfaces (GUIs) for functionally rich business information system (BIS) prototypes, upon a mobile platform. Those prototypes are specified with annotated UML class diagrams. Navigation in the generated GUIs is allowed through the semantic links that match the associations and cardinalities among the conceptual domain entities, as expressed in the model. We start by reviewing the Android scaffolding for producing flexible GUIs for mobile devices. The latter can present rather different displays, in terms of size, orientation and resolution. Then we show how our model-based generative technique allows producing prototypes that match both the Android GUIs requirements, while implementing our model-driven approach for user navigation.

Refactoring is a process meant to improve the internal quality of software systems. However, while on one hand, the guidelines for this delicate process are still empirical and qualitative, on the other hand, software product metrics often indicate that this process has the opposite results. Also, there is a lack of evidence regarding improvements on maintainability due to refactoring. This means that this process, although widely acknowledged as one of the best software practices, is difficult to deploy within large scale software systems, and can be better grounded. To address these challenges, we propose a method for refactoring with quantitative and experimental grounds. Upon the consolidation of this method, we will build the necessary blocks to implement and validate it.

Published work in the IT services area is generally centered on the description of management best practices or specific technological issues. There is a lack of empirical studies the relationship among service level agreements (the quality parameters of service agreed between customer and provider) and the required IT parts to deliver IT services. In the ITIL framework, the service level agreements process is fully described, albeit without a formal representation. Enterprise Architecture frameworks provide a mean for formal description of IT and business parts of organizations and their interrelationships, however without reference to service level agreements. In this research, we intend to derive a formal specification of service level agreements by integrating IT Services Management within an Enterprise Architecture framework. This integration will facilitate the provision of a business-aligned automatic checking of compliance between agreed and provided services.

This paper aims at identifying top challenges faced by IT executives in IT infrastructures to help the formulation of meaningful research questions. The introduction of this paper describes the importance of IT infrastructures to organizations. The top challenges according to a recent survey are also introduced in the state-of-the-art section. Then, to improve our understanding and face challenges, we propose an approach based upon a research method and we describe several research techniques that we plan to use (e.g. laddering technique) and the use of empirical research in IT infrastructures. Finally, we present the expected contributions, work already performed and some preliminary results.

Component based software development is becoming more generalized, representing a considerable market for the software industry. The perspective of reduced development costs and shorter life cycles acts as a motivation for this expansion. However, several technical issues remain unsolved before the software components industry reaches the maturity exhibited by other component industries. Problems such as the component selection by their integrators, the component catalogs formalization and the uncertain quality of third-party developed components, bring new challenges to the software engineering community. This paper presents an overview of the current research efforts on software components, from a quality assessment perspective. The emerging of empirical component based software engineering practices, to complement the current research trends with a more effective component quality and complexity evaluation, is perceived as a research area that will become very active in a near future.