Search

In this work, we propose a simulation model to study the software market, and in particular the competition among on-premise and on-demand vendors of customer relationship management software. In this market two kinds of vendors, on-premise and on-demand vendors, and corporate customers interact. Vendors have an initial capital and a specific number of developers. They invest a fraction of their capital in their product quality and try to sell their products making a profit. Corporate customers buy software products for their employees, trying to minimize their cost and maximize their utility. The proposed model is able to reproduce the real trends of the market as regards both the price of software and the market shares of the vendors, despite there is relatively little empirical evidence available about the various mechanisms at play, and few experimental data. Our model could be used as a tool to forecast future market trends, or to plan business policies of investment and pricing. Any firm could calibrate this model depending on its past business trends in order to obtain simple guidelines to follow in the planning of business winning strategies.

Web applications are among the most popular and relevant kinds of application. Most Web applications are developed using a content management framework CMF. CMF helps to accelerate the publication of large amounts of information and the development of Web applications. However, developing Web applications through CMF is not exempt from cost and time overruns, as in traditional software projects. Currently, there is no estimation model able to adequately measure the effort of developing a Web application.

Just a few years after its birth, Knowledge Management drew the attention of the academic world, becoming a matter of intense study as the scientific community has always felt the need to create the cooperation among its members allowing the information exchange. Many disciplines develop several standardized formalization that domain experts can use to share information as reusable knowledge. The purpose of this chapter is the study of a process to formalize knowledge by using an iterative approach mixing a top-down and bottom up analysis of a specific domain and the bottom-up analysis for the information in the object of the specific domain. Our case study analyzes the domain of descriptions and reviews of Italian wines. We start by analyzing the information collected from the Web in order to define a taxonomy able to represent the knowledge related to the above mentioned domain.

We analyzed the source code of various releases of two large Object Oriented Open Source Java software systems, Eclipse and Netbeans, investigating the complexity of the whole release and of its subprojects. We show that when the classes in the source code and the dependencies between them are considered, such systems can be viewed as complex software networks, and emerging structures, characteristic of fractals, appear at different length scales - on the entire systems and on subprojects of any size. We were able to find in all examined cases a scaling region where it is possible to compute a self-similar coefficient, the fractal dimension, using ''the box counting method''. Such a coefficient is a single metric related to the system's complexity. More importantly, we were able to show that this measure looks fairly related to software quality, acting as a global quality software metric. In particular, we computed the defects of each software system, and we found a clear correlation among the number of defects in the system, or in a subproject, and its fractal dimension. This correlation exists across all the subprojects and also along the time evolution of the software systems, as new releases are delivered.

SUMMARY A software maintenance process is important for reducing maintenance effort and for improving software quality. In recent years, the Lean–Kanban approach has been widely applied in software practice including software maintenance. This approach minimizes Work-in-Progress (WIP), which is the number of items that are worked on by the team at any given time, thus improving the maintenance process. In this paper, we describe our simulation studies, which show that the Lean–Kanban approach can indeed help reduce the average time needed to complete maintenance requests. We develop a process simulator that can simulate both existing maintenance processes that do not use a WIP limit and that adopt it. We perform two case studies using real maintenance data collected from a Microsoft project and from a Chinese software firm. The main results of our study are twofold. First, we demonstrate that it is possible to effectively model and simulate, using actors and events, a maintenance process where a flow of issues is processed through a sequence of activities, correctly reproducing key statistics of real data. Second, our results confirm that the WIP-limited process could be useful to increase the efficiency of software maintenance, as reported in previous industrial practices. Copyright © 2013 John Wiley & Sons, Ltd.

The term "software entropy" refers to the tendency for software, over time, to become difficult and costly to maintain. A software system that undergoes continuous change, such as having new functionality added to its original design, will eventually become more complex and can become disorganized as it grows, losing its original design structure. A recent study show that software degradation may be measured using the WMC expressed in terms of Shannon entropy. In this paper we extended the empirical analyses also to RFC and CBO since these CK metrics have been shown to be correlated with fault-proneness of OO classes. We analyzed various releases of the publicly available Eclipse and Netbeans software systems, calculating the entropy of some CK metrics for every release analyzed. The validity is shown through a direct measure of software quality such as the number of detected defects. Our results display a very good correlation between the entropy of CBO and RFC and the number of bugs for Eclipse and Netbeans. Complexity and quality metrics are in general computed on every system module while the entropy is just a scalar number that characterizes a whole system, this result suggests that the entropy of some CK metrics could be considered as a global quality metric for large software systems. Our results need, however, to be confirmed for other large software systems.

We present a study of 600 Java software networks with the aim of characterizing the relationship among their defectiveness and community metrics. We analyze the community structure of such networks, defined as their topological division into subnetworks of densely connected nodes. A high density of connections represents a higher level of cooperation between classes, so a well-defined division in communities could indicate that the software system has been designed in a modular fashion and all its functionalities are well separated. We show how the community structure can be an indicator of well-written, high quality code by retrieving the communities of the analyzed systems and by ranking their division in communities through the built-in metric called modularity. We found that the software systems with highest modularity possess the majority of bugs, and tested whether this result is related to some confounding effect. We found two power laws relating the maximum defect density with two different metrics: the number of detected communities inside a software network and the clustering coefficient. We finally found a linear correlation between clustering coefficient and number of communities. Our results can be used to make predictive hypotheses about software defectiveness of future releases of the analyzed systems.

We present an analysis of the evolution of a Web application project developed with object-oriented technology and an agile process. During the development we systematically performed measurements on the source code, using software metrics that have been proved to be correlated with software quality, such as the Chidamber and Kemerer suite and Lines of Code metrics. We also computed metrics derived from the class dependency graph, including metrics derived from Social Network Analysis. The application development evolved through phases, characterized by a different level of adoption of some key agile practices — namely pair programming, test-based development and refactoring. The evolution of the metrics of the system, and their behavior related to the agile practices adoption level, is presented and discussed. We show that, in the reported case study, a few metrics are enough to characterize with high significance the various phases of the project. Consequently, software quality, as measured using these metrics, seems directly related to agile practices adoption.

We study the application to object-oriented software of new metrics, derived from Social Network Analysis. Social Networks metrics, as for instance, the EGO metrics, allow to identify the role of each single node in the information flow through the network, being related to software modules and their dependencies. These metrics are compared with other traditional software metrics, like the Chidamber-Kemerer suite, and software graph metrics. We examine the empirical distributions of all the metrics, bugs included, across the software modules of several releases of two large Java systems, Eclipse and Netbeans. We provide analytical distribution functions suitable for describing and studying the observed distributions. We study also correlations among metrics and bugs. We found that the empirical distributions systematically show fat-tails for all the metrics. Moreover, the various metric distributions look very similar and consistent across all system releases and are also very similar in both the studied systems. These features appear to be typical properties of these software metrics.

We present a comprehensive study of an implementation of the Smalltalk object oriented system, one of the first and purest object-oriented programming environment, searching for scaling laws in its properties. We study ten system properties, including the distributions of variable and method names, inheritance hierarchies, class and method sizes, system architecture graph. We systematically found Pareto - or sometimes log-normal - distributions in these properties. This denotes that the programming activity, even when modeled from a statistical perspective, can in no way be simply modeled as a random addition of independent increments with finite variance, but exhibits strong organic dependencies on what has been already developed. We compare our results with similar ones obtained for large Java systems, reported in the literature or computed by ourselves for those properties never studied before, showing that the behavior found is similar in all studied object oriented systems. We show how the Yule process is able to stochastically model the generation of several of the power-laws found, identifying the process parameters and comparing theoretical and empirical tail indexes. Lastly, we discuss how the distributions found are related to existing object-oriented metrics, like Chidamber and Kemerer's, and how they could provide a starting point for measuring the quality of a whole system, versus that of single classes. In fact, the usual evaluation of systems based on mean and standard deviation of metrics can be misleading. It is more interesting to measure differences in the shape and coefficients of the data?s statistical distributions.

The Maintainability Index (MI) metric was proposed in the early nineties to gauge ease of code maintenance. A high value of MI indicates well-constructed code which is easy to maintain and a low MI, the opposite. The metric has been criticized in the past and more recently for its applicability to code and validity more generally. Very few studies however have explored whether the MI correlates strongly with class features such as coupling, defects or size - features of object-oriented (OO) classes which are acknowledged to be surrogates of maintenance complexity. We explore the relationship between the MI and these four perspectives. Three releases of two Eclipse projects were used as the empirical basis of the study and the JHawk tool was used to extract class-based metrics. Significant correlations were found between class features and the MI for all class features except fan-in which measures incoming coupling and determined externally by 'using' classes; however, further exploration of the data revealed that the application of the MI to an OO paradigm was not particularly successful, due primarily to the influence of class size. For OO systems, we would thus warn against the use of MI as a measure of maintenance.

The goal of this work is to study the effects of the adoption of agile practices on open source development. In particular, we started to evaluate the effects of TDD (Test Driven Development) since it is easer to apply in a distributed environment than most other agile practices. In order to reach this goal we used the simulation modeling approach. We developed a simulation model of open source software development process. The model was tuned using data from a real FLOSS project: Apache HTTP Server. To introduce the TDD practice in our FLOSS simulation model, we made some assumptions based on empirical results. The two FLOSS development models (nonTDD and TDD) were compared. The one incorporating the agile practice yields better results in terms of code quality.

We present a study of three large object-oriented software systems—VisualWorks Smalltalk, Java JDK and Eclipse—searching for scaling laws in some of their properties. We study four system properties related to code production, namely the inheritance hierarchies, the naming of variables and methods, and the calls to methods. We systematically found power-law distributions in these properties, most of which have never been reported before. We were also able to statistically model the programming activities leading to the studied properties as Yule processes, with very good correspondence between empirical data and the prediction of Yule model. The fact that a design and optimization process like software development can be modeled on the large with the laws of statistical physics poses intriguing issues to software engineers, and could be exploited for finding new metrics and quality measures.

In this article, we present a simulation model that we developed for exploring the influence of two key Extreme Programming (XP) practices — Test-first Programming and Pair Programming — on the evolution of an XP software project. We present the results obtained simulating a typical XP project changing the usage levels of the two practices. We focused on output variables related to effort, size, quality and released functionalities. Copyright © 2006 John Wiley & Sons, Ltd.

The structure of the Web grows and changes, giving the user the chance to actively participate in its development. This study tries to link the worlds of Social Media and Semantic Web, with the aim of proposing a semantic classification of the information coming from the Web. Our approach consists in a mixed-iterative process, where top-down and bottom-up analyses of the knowledge domain which has to be represented are applied. We start from the concept of the domain knowledge base. The fundamental body of knowledge available on a domain is the knowledge valuable for knowledge users. We need to represent and manage this knowledge, to define a formalization and codification of knowledge in the domain. This kind of representation was created according to the criteria by which information, in a given domain, is structured within the net, by taking the hierarchy proposed in different sites as a reference.

Document management is not often handled appropriately by organisations, if at all. Despite that, and despite the lack of structure in documents, organisations must face regulations that require owning a document collection with semantic content. The technique based on taxonomies and folksonomies can easily produce an adequate semantic classification for documents. It requires an adequate setup among the domain experts that apply it. The approach we propose uses Lean Kanban to coordinate the phases of definition, validation and implementation of taxonomies and folksonomies. It helps organisations to create a semantic classification of existing document resources, making them ready to be used in ways that were not possible before. At the same time, it helps to improve the quality of work of the organisation itself, adding speed to document search.

In this paper we present a case study about the clustering of maintenance activities applied on large software systems, from the complex networks perspective. We analyze several releases of two large Open Source Java software systems, using data extracted from Software Configuration Management systems and from Issue Tracking systems (ITS). We find that Java files affected by maintenance activity are likely to be connected with each other, forming interconnected clusters inside the software network associated to the software system. This means that Java files interested by the maintenance activities requested on ITS are likely to be connected each other through dependencies at the source code level. The information carried by the clusters of Java files may be used to improve strategies for large maintenance operations. Since the tendency to form clusters can vary across different systems, such analysis can also be a useful indicator of the impact of defects on source code files in different software systems.

A fundamental aspect of a system's performance over time is the number of faults it generates. The relationship between the software engineering concept of "coupling" (i.e., the degree of inter-connectedness of a system's components) and faults is still a research question attracting attention and a relationship with strong implications for performance; excessive coupling is generally acknowledged to contribute to fault-proneness. In this paper, we explore the relationship between faults and coupling. Two releases from each of three open-source Eclipse projects (six releases in total) were used as an empirical basis and coupling and fault data extracted from those systems. A contrasting coupling profile between fault-free and fault-prone classes was observed and this result was statistically supported. Object-oriented (OO) classes with low values of fan-in (incoming coupling) and fan-out (outgoing coupling) appeared to support fault-free classes, while classes with high fan-out supported relatively fault-prone classes. We also considered size as an influence on fault-proneness. The study thus emphasizes the importance of minimizing coupling where possible (and particularly that of fan-out); failing to control coupling may store up problems for later in a system's life; equally, controlling class size should be a concomitant goal.

This paper reports on the 2010 ICSE Workshop on Emerging Trends in Software Metrics (WETSoM 2010) held on Tuesday 4 May 2010 in Cape Town, South Africa, as part of the ICSE workshop series. The goal of this workshop was to bring together researchers and practitioners to discuss the progress of software metrics.

Refactoring is widely used among the practices of Agile software development. In this preliminary work we present an empirical study carried out on several releases of 5 software systems written in Java. We focus our attention on the effect of refactoring activities on the topology of the software network. We find that refactoring activities involve classes linked together into clusters inside the software network and the clusters may be modified in different ways by the refactoring activity. This could lead to significative changes in source code, whose knowledge could be valuable for people involved in software development.

This paper reports the results from a survey concerning the use of Agile Methodologies (AM), techniques and tools for Web Programming. The survey lasted from October to December 2013, and involved 112 Web application developers from 32 countries. Its main purpose was to assess the usage of AMs, and of specific practices and tools, in the context of Web programming and of related technologies, such as Content Management Systems. The results confirm a broad adoption of AMs among Web developers, and the prevalence of Scrum among AMs.

Standardized formalizations of the knowledge are used by domain experts to share information in the form of reusable knowledge. The primary objective of our work is the definition of an approach for multimedia content management. We reached that goal through a validation activity which lasted for the last three years, and was carried on through the application on different case studies, some of them described in detail in previously published papers. This approach aims to represent the knowledge through a mixed-iterative approach, where top-down and bottom-up analyses are applied on the knowledge domain we want to represent. We focused our research on some issues concerning Knowledge Management, strictly related to the process of making multimedia content-related knowledge easily available to users. We need to represent and manage this knowledge, in order to formalize and codify all the knowledge in the domain. This formalization can eventually lead us to easily manage that knowledge through the use of repositories.

In recent years, the power balance between software firms and enterprise customers has been heavily changing. The contractual power of customers is increasing and the firms must take this fact into account. Stated the common need to save money, the opportunities to adopt new software solutions with tight budgets, or with substantial savings, are limited. The better way to obtain operational savings seems to be shifting to the use of open source software, obtaining in this way all the benefits of this software typology: lower costs, greater adherence to open standards, a broader vendor choice and service suppliers, no vendor lock-in and flexible, incremental architectures. In this work, a business model is proposed to analyse the competition among on-demand customer relationship management (CRM) firms, in particular among firms offering CRM products with or without source code availability. The model can also be customized to study other kinds of markets, and other assumptions can be made for study...

We present a study on the refactoring activities performed during the evolution of 7 popular Java open source software systems, using a complex network approach. We find that classes affected by refactorings are more likely to be interlinked than others, forming connected subgraphs. Our results show that in a software network, classes linked to refactored classes are likely to be refactored themselves. This result is meaningful because knowing how refactored classes are arranged inside a network could be useful to support developers in maintenance and refactoring activities.

This paper presents a software metrics analysis of eight object-oriented systems. Five systems had been developed using Agile methodologies and three using plan-driven methodologies; three systems were written in Python and five in Java. For each system, we considered 10 traditional metrics such as LOC and the Chidamber and Kemerer metrics. These metrics were computed at class level. In our study we present empirical results considering systems developed with Agile methodologies and we compare them with previous results for non Agile systems. In particular, we verify that the distributions of software metrics in a software system developed using Agile methodologies does not differ from the distribution in systems developed using plan-driven methodologies.

In recent years, we witnessed the diffusion and rise in popularity of software platforms for the User Generated Content (UGC) management, especially multimedia objects. These platforms handle a large amount of unclassified information. UGC websites (e.g. YouTube and Flickr) do not force the users to perform classification operations and metadata definitions, leaving space to a logic of free-tags (Folksonomies). We analyzed the standards used in UGC websites for the management of the multimedia contents and their metadata. We defined an ontology to represent the semantics of these multimedia contents, so that in turn the metadata classification can give an unambiguous meaning. In order to unify metadata coming from different sources we defined all rules of mapping toward a structure defined by sources such as YouTube and Flickr. The innovation is in the approach for the formalization of web semantics for multimedia content: we used standards such as Dublin Core, Exif, IPTC and in particular the Adobe XMP standard as a starting point of this domain. With the proposed approach, once can categorize and catalog all non-standard and unclassifiable information inside the ontology, using pre-made schemas.

This paper presents a case study of a large software system, Netbeans 6.0, made of independent subsystems, which are analyzed as complex software networks. Starting from the source code we built the associated software graphs, where classes represent graph nodes and inter-class relationships represent graph edges. We computed various metrics for the software systems and found interdependences with various quantities computed by mean of the complex network analysis. In particular we found that the number of communities in which the software networks can be partitioned and their modularity, average path length and mean degree can be related to the amount of bugs detected in the system. This result can be useful to provide indications about the fault proneness of software clusters in terms of quantities related to the associated graph structure.

In this paper we present a study on micro patterns in different releases of two software systems developed with Object Oriented technologies and Agile process. Micro patterns are design decisions in code that can be easily automatically recognised. Gil and Maman introduced the concept to support providing objective assessment of design decisions [1]. They catalogued 27 micro patterns that capture a variety of programming practices in Java. Micro patterns can be a useful metrics in order to measure the quality of software by showing that certain categories of micro patterns are more fault prone than others, and that the classes that do not correspond to any category of micro patterns are more likely to be faulty. In our study we present some empirical results on two case studies of systems developed with Agile methodologies, and compare them to previous results obtained for non Agile systems. In particular we have verified that the distribution of micro patterns in a software system developed using Agile methodologies does not differ from the distribution studied in other systems, and that the micro patterns fault-proneness is about the same. We also analyzed how the distribution of micro patterns changes in different releases of the same software system. We demonstrate that there is a relationship between the number of faults and the classes that do not match with any micro patterns. We found that these classes are more likely to be fault-prone than the others even in software developed with Agile methodologies.

Several Content Management Frameworks (CMF), either open source or with a commercial license, are available to help the publication of huge amounts of information and to develop Web applications. Unfortunately, developing Web applications through a CMF is not exempt from cost and time overruns, as in traditional software projects, and currently there is no estimation model able to adequately measure the effort of Web application development. This work presents a new methodology for estimat­ing the effort of Web applications developed with a Content Management Framework (CMF). We present the new key elements for analysis and planning, needed to define every important step in developing a Web application through a CMF. Using those elements, it is possible to estimate the effort needed to build such an ap­plication in man-days. We also present the experimental validation of the proposed methodology per­formed on a 9-project dataset, provided by three different Italian software companies.

Cloud Computing (CC) is a technological phenomenon that is becoming more and more important. Also Small and Medium Enterprises (SMEs) can increase their competitiveness by taking advantage of CC. This new computing approach promises to provide many advantages, and many SMEs are encouraged to use it. However, CC is still in its early stage -- for this reason we think that it is very important to study and assess its impact on SMEs' management processes. In this paper we propose a model for studying how Global Software Development can be facilitated using Cloud development environments, compared to a more traditional development environment. We use system dynamics to model and simulate how effective Cloud-based software development environments are for Global Software Development performed by a SMEs. Both studied environments assume a development process based on Scrum agile methodology. The proposed model could be used as a tool by the project managers to understand how Cloud Development Environments might facilitate Global Software Development.

The use of Open Source Content Management System (CMS) on the Web is increasing thanks to the flexibility provided by these systems and the semplification of the management operations. The use of CMS is simple for non programming experts. Many Public Administrations have adopted Open Source CMS for their websites, greatly reducing operating costs and ensuring scalability, advanced performance and privacy to the users. A special opportunity for a case study are the Italian municipalities. In fact the Italian Government, since January 2011, has required all municipalities to develop a website publishing all the public acts and everything related to the citizen-municipality communication (information regarding office hours, salaries of public employees, news and so on). Our study aims to quantify through empirical studies, the use of Open Source CMS in Italian municipalities websites in response to government regulations. Our results show that the number of Italian Public Administrations that use Open Source CMS is increasing, and our case study highlights how the adoption of Open Source CMS has increased about 5% in a year, leading to the 21.2% the percentage of Open Source CMS, with respect to the 15.8% registered in 2011.

We present a study were software systems are considered as complex networks which have a self-similar structure under a length-scale transformation. On such complex software networks we computed a self-similar coefficient, also known as fractal dimension, using "the box counting method".We analyzed various releases of the publically available Eclipse software systems, calculating the fractal dimension for twenty sub-projects, randomly chosen, for every release, as well as for each release as a whole. Our results display an overall consistency among the sub-projects and among all the analyzed releases.We found a very good correlation between the fractal dimension and the number of bugs for Eclipse and for twenty sub-projects. Since the fractal dimension is just a scalar number that characterizes a whole system, while complexity and quality metrics are in general computed on every system module, this result suggests that the fractal dimension could be considered as a global quality metric for large software systems. Our results need however to be confirmed for other large software systems.

Refactoring is an activity which, in theory, should have minimal impact on the overall structure of a system. That said, certain refactorings change the coupling profile of a system and over time those cumulative changes in coupling can have serious implications for system maintenance effort. In this paper, we analyse effect of the fan-in and fan-out metrics from the perspective of two refactorings -- namely 'Add parameter' to, and 'Remove Parameter' from, a method. We developed a bespoke pattern-matching tool to collect these two refactorings from multiple releases of the Tomcat open-source system using the Evolizer tool to extract method signature data and the JHawk metrics tool to collect the two coupling metrics. Results point to significant differences in the profiles of fan-in and fan-out between refactored and non-refactored classes. We describe how software company can take advantage from this knowledge by defining a priority list of classes which could require a refactoring. A strong over-arching theme emerged: developers seemed to focus on the refactoring of classes with relatively high fan-in and fan-out rather than classes with high values in any one. The study is the first that we know of to analyse the direct effect of a subset of Fowler's refactorings on fan-in and fan-out - relevant metrics of the overall structure of a system.

Nowadays, Scrum is the most used Agile Methodology, while the Lean-Kanban approach is perhaps the fastest growing AM. On the other hand, traditional, waterfall-like approaches are still very used in real-life software projects, due to the ease of up-front planning and budgeting, that however are seldom matched upon project completion. In our opinion, more effort is needed to study and model the inner structure and behavior of these approaches, highlighting positive and negative feedback loops that are strategic to understand their features, and to decide on their adoption. In this paper we analyze the dynamic behavior of the adoption of Kanban and Scrum, versus a traditional software development process such as the Waterfall approach. We use a system dynamics model, based on the relationships between system variables, to assess the relative benefits of the studied approaches. The model is simulated using a commercial tool. The proposed model visualizes the relationships among these software development processes, and can be used to study their relative advantages and disadvantages.

In recent years, a very important structural change in the software industry took place, with an increasing number of firms that got involved in Free/Libre Open Source Software (FLOSS) development communities. FLOSS communities and products have been studied as complementary to proprietary software companies and products. In this paper we propone a business model for the software market, and in particular we analyze the competition between proprietary software firms and FLOSS firms. Our software market is a system where each agent is independent of each other in the choice about buying or selling software products or services. The proposed work aims to analyze the influence of FLOSS firms producing both software and services in vertical software markets, nowadays mostly dominated by large proprietary firms. The findings show that FLOSS firms are able to compete with proprietary firms, though in the end a monopoly or oligopoly of the latters emerges. The ousted FLOSS firms, however, survive longer than proprietary ones, when these are not able to compete in the market.

We present a study of the effectiveness of estimating web application development effort using Function Points and Web Objects methods, and a method we propose - the Revised Web Objects (RWO). RWO is an upgrading of WO method, aimed to account for new web development styles and technologies. It also introduces an up-front classification of web applications according to their size, scope and technology, to further refine their effort estimation. These methods were applied to a data-set of 24 projects obtained by Datasiel spa, a mid-sized Italian company, focused on web application projects, showing that RWO performs statistically better than WO, and roughly in the same way as FP.

A software system can be associated to a graph - called software network - whose nodes are the software modules (for instance, the classes in Object-oriented systems), and edges are the dependencies between modules. A recent paper demonstrated that the structure of software networks is also self-similar under a length-scale transformation, and calculated their fractal dimension using the "box counting" method. In this paper, we focus on describing and evaluating alternative approaches for the computation of the fractal dimension of networks. We show that a Merge Algorithm is the most efficient, while Simulated Annealing is the most accurate. However, the Greedy Coloring algorithm, based on the equivalence of the box counting problem with the graph coloring problem, looks the best compromise, having speed comparable to MA, and accuracy comparable with SA.

We studied data mining from CVS repositories of two large OO projects, Eclipse and Netbeans, focusing on "fixing-issue" commits.We highlight common characteristics of issue reporting, and problems related to the identification of these messages, and compare static traditional approaches, like Knowledge Engineering, to dynamic approaches based on Machine Learning techniques. We compare for the first time performances of Machine Learning (ML) techniques to automatic classify "fixing-issues" among message commits. Our study calculates precision and recall of different Machine Learning Classifiers for the correct classification of issue-reporting commits. Our results show that some ML classifiers can correctly classify up to 99.9% of such commits.

The Workshop on Emerging Trends in Software Metrics aims at bringing together researchers and practitioners to discuss the progress of software metrics. The motivation for this workshop is the low impact that software metrics has on current software development. The goals of this workshop are to critically examine the evidence for the effectiveness of existing metrics and to identify new directions for development of software metrics.

This paper compares the effectiveness of Function Points and Web Object analysis to estimate the development effort of Web applications. The empirical study is performed on a set of industrial projects carried on in an Italian software company. Starting from original requirements and estimates, carried on using FP analysis, we compute the Web Objects analysis of the same requirements, and compare the results of the two approaches. We also assess the relative effectiveness of FP and WO using post-mortem data about the actual effort taken to develop the studied systems.

We present an agile process used for the development of a Web application written in Java, devised by choosing a set of proven agile practices taken by existing popular agile methodologies. During the project, we regularly measured the software using Chidamber and Kemerer object-oriented metrics suite, and other metrics. The application development evolved through phases, characterized by a different level of adoption of some key agile practices --- such as pair programming, test-based development and refactoring. The evolution of the OO metrics of the system, and their behavior related to the agile practices adoption level is presented and discussed, showing that soft ware quality, as measured using standard OO metrics, looks directly related to agile practices adoption.

In this study on Open Source communities, we examined some important aspects about communication among participants to developers mailing lists. We utilized Social Network Analysis approach to analyse this particular kind of communities, in order to better understand interaction among members, individuate communicational flows and discover whether there is a subsequential community coordination and control.

The development of a Web application using agile practices is presented, characterized by empirical software measurements that have been performed throughout the duration of the project. The project is the specialization of jAPS, an open source Java Web portal generation framework, for building a Research Register management system. The agile principles and practices used in the project are described and discussed. During the various phases of the project some key agile practices, such as pair programming, test-based development and refactoring, were used at different levels of adoption. The evolution of some object-oriented metrics of the system, and their behavior related to the agile practices adoption level is presented and discussed, showing that software quality, as measured using standard OO metrics, looks directly related to agile practices adoption.

In this paper we examine the close relationship that can be established between Agile methodologies and the FLOSS (Free-Libre Open Source Software) development model, by integrating a Health Information System (HIS) into the IT environment of an Italian hospital (a so-called software verticalization). We followed XP approach during development of new features. This approach allowed us not only to contribute to the original Open Source project, helping it to become increasingly mature, but also to evaluate in a quantitative manner the effort devoted to the international project, to the national context and to the specific health care organization.

Team work is defined by different factors: team size, members role, interactions and communication. In Agile Methodologies communication plays a fundamental role. Some research studies have found that the involvement of team members in a project also depends on the information provided. Communication also depends on the tool employed. The aim of this paper is to analyze communication among team members of the 9 most active projects on Source-forge provided of a developers' mailing list. In particular we tried to investigate how and why members post to developers' mailing list and the use that different members make of these mailing lists.

This paper analyzes the development of a project initiated by a co-located agile team that subsequently evolved into a distributed context. The project, named JAPS (Java Agile Portal System) [1], has been monitored on a regular basis since it started in January 2005, collecting both process and product metrics. Product metrics have been calculated by checking out the source code history from the CVS repository. By analyzing the evolution of these metrics, it has been possible to evaluate how the distribution of the team has impacted the source code quality.

Effectively evaluating the capability of a software development methodology has always been very difficult, owing to the number and variability of factors to control. Evaluating XP is by no way different under this respect. In this paper we present a simulation approach to evaluate the applicability and effectiveness of XP process, and the effects of some of its individual practices. Such approaches using simulation are increasing popular because they are inexpensive and flexible. Of course, they need to be calibrated with real data and complemented with empirical research. The XP process has been modelled and a simulation executive has been written, enabling to simulate XP software development activities. The model follows an object-oriented approach, and has been implemented in Smalltalk language, following XP process itself. It is able to vary the usage level of some XP practices and to simulate how all the project entities evolve consequently.

In recent years Extreme Programming and Agile Methodologies are becoming very popular among academics and practitioners of software engineering. In order to create a knowledge base on XP and agile methodologies, a common standard for process data representation is needed. This standard can also be used for interchanging data among different tools supporting XP projects. In this paper we present XMI as a possible solution to this problem. We show the advantages of XMI for XP project data collection and interchange. XMI is an OMG standard for modelling data object semantics in XML syntax. It integrates XML and UML and requires the definition of a model for data that must be interchanged. In this context we have defined a UML model for an XP project. The XP project model consists of a set of UML classes diagrams representing the XP project entities, their properties and relationships. The model can be easily extended to other agile methodologies. We used this model for exporting process data from XPSwiki, a tool for XP project management and for process data collection.