Dependencies between modules can trigger ripple effects when changes are made, making maintenance complex and costly, so minimizing these dependencies is crucial. Consequently, understanding what drives dependencies is important. One potential factor is code smells, which are symptoms in code that indicate design issues and reduce code quality. When multiple code smells interact through static dependencies, their combined impact on quality can be even more severe. While individual code smells have been widely studied, the influence of their interactions remains underexplored. In this study, we aim to investigate whether and how the distribution of static dependencies changes in the presence of code smell interactions. We conducted a dependency analysis on 116 open-source Java systems to quantify these interactions by comparing cases where code smell interactions exist and where they do not. Our results suggest that overall, code smell interactions are linked to a significant increase in total dependencies in 28 out of 36 cases, and that all code smells are associated with a consistent change direction (increase or decrease) in certain dependency types when interacting with other code smells. Consequently, this information can be used to support more accurate code smell detection and prioritization, as well as to develop more effective refactoring strategies.

Providing students with hands-on experience in kernel programming within a real-world operating system is highly beneficial in an Operating Systems (OS) course for teaching core operating system concepts and developing practical skills. However, accessing suitable devices for such hands-on experimentation poses significant challenges. Traditional solutions involve hosting virtual machines on cloud platforms, which are expensive and do not scale well with increasing student numbers. Additionally, many students' personal devices, such as Macs or iPads, have limited support for running Linux, creating further barriers. In this paper, we introduce KernelVM, a novel cost-effective platform that offers students a Linux virtual machine with full superuser access and pre-configured kernel programming toolchains. KernelVM is accessible via any modern browser on any device. It performs all computations locally within the user's browser, thus eliminating cloud computing costs. KernelVM provides a robust learning environment by incorporating interactive virtual hardware components and an automatic evaluation system, supporting a wide range of tasks, including multi-threaded cryptographic kernel modules and Linux drivers for hardware interaction. We detail the design of KernelVM, and describe our experiences incorporating it for the first time into an OS course with 159 undergraduate students. We found that KernelVM was instrumental in improving the quality and efficiency of hands-on learning experiences, with students reporting increased satisfaction and engagement due to the immediate feedback and the ability to experiment in a risk-free environment. Our experience suggests that KernelVM not only addresses the logistical challenges of kernel programming education, but it helps foster a highly interactive and engaging learning experience.

Complex software systems consist of multiple overlapping design structures, such as abstractions, features, crosscutting concerns, or patterns. This is similar to how a human body has multiple interacting subsystems, such as respiratory, digestive, or circulatory. Unlike in the medical domain, software designers do not have an effective way to distinguish, visualize, comprehend, and analyze these interleaving design structures. As a result, developers often struggle through the maze of source code. In this paper, we present anAutomated Concept Explanation(ACE) framework that automatically extracts and categorizes major concepts from source code based on the roles that files play in design structures and their topic frequencies. Based on these categorized concepts, ACE recovers four categories of high-level design models using different algorithms and generates a natural language explanation for each. To assess if and how ACE can help developers better understand design structures, we conducted an empirical study where two groups of graduate students were assigned three design comprehension tasks: identifying feature-related files, identifying dependencies among features, and identifying design patterns used, in an open-source project. The results reveal that the students who used ACE can accomplish these tasks much faster and more accurately, and they acknowledged the usefulness of the categorized concepts and structures, multi-type high-level model visualization, and natural language explanations.

Folk-wisdom in software engineering suggests that small functions that adhere to the principle of single-responsibility have several advantages over longer, monolithic functions, including improvement in code comprehension. Despite this widespread view, empirical research on the impact of functional decomposition on understanding code is sparse, yet it is central to software development practices.

Abstract Requirements Technical Debt (RTD) applies the Technical Debt (TD) metaphor to capture the consequences of sub-optimal decisions made concerning Requirements. Understanding the quantification of RTD is key to its management. To facilitate this understanding, we developed a conceptual model, the Requirements Technical Debt Quantification Model (RTDQM). Our work is grounded in the literature found via a systematic mapping study and informed by prior work modeling the quantification of software code-related TD types. The key finding is that although RTD is similar to code-related TD in many aspects, it also has its own components. RTD can be incurred regardless of the presence of code-related TD. Unlike code-related TD, RTD has a feedback loop involving the user. RTD can have a cascading impact on other development activities, such as design and implementation, apart from the extra costs and efforts incurred during requirements engineering activities; this is modeled by the RTD Interest constituents in our model. The model was used to compare and analyze existing quantification approaches. It helped identify what RTD quantification concepts are discussed in the existing approaches and what concepts are supported by metrics for their quantification. The model serves as a reference for practitioners to select existing or to develop new quantification approaches to support informed decision-making for RTD management.

To effectively manage Technical Debt (TD), we need reliable means to quantify it. We conducted a Systematic Mapping Study (SMS) where we identified 39 quantification approaches for Code, Design, and Architecture TD. We analyzed concepts and metrics discussed in these quantification approaches by classifying the quantification approaches based on a set of abstract TD Quantification (TDQ) concepts and their high-level themes, process/time, cost, benefit, probability, and priority, which we developed during our SMS. This helped identify gaps in the literature and to propose future research directions. Among the abstract TDQ concepts discussed in the different quantification approaches, TD item, TD remediation cost, TD interest, and Benefit of remediating TD were the most frequently discussed concepts. They were also supported by some form of measurement. However, some TDQ concepts were poorly examined, for example, the benefit of taking TD. It was evident that cost concepts were more frequently quantified among the approaches, while benefit concepts were not. Most of the approaches focused on remediating TD in retrospect rather than quantifying TD to strategically use it during software development. This raises the question of whether existing approaches reliably quantify TD and suggests the need to further explore TDQ.

Making sub-optimal design decisions during software development leads to the accumulation of Technical Debt (TD) in software projects. There are tools to identify TD Items in software code through static code analysis. However, quantifying TD to support decision-making on whether to keep taking on TD or if it is time to refactor TD is a difficult task, and proposed approaches for this still lack consensus. Prior work observed that TD Interest could be further decomposed into constituents ‘New Code Cost’ and ‘Rework Cost’, which gives an interesting direction of research to explore TD quantification in terms of these costs. Therefore, through our empirical study, we plan to explore the relationship between TD, New Code Cost and Rework Cost in Open-Source Software Projects. This paper reports on an initial motivating study, our plan for future work and implications for researchers.

Requirements Technical Debt (RTD) is a research area where the Technical Debt (TD) metaphor is used to capture the consequences of sub-optimal decisions made concerning Requirements. Understanding the quantification of RTD is key to its management. To facilitate this understanding, we model the quantification of RTD. Our work is grounded in the literature found via a Systematic Mapping Study (SMS) and informed by prior work modeling the quantification of TD for software code-related TD types. This paper reports on the SMS and the development of our model, the RTD Quantification Model (RTDQM). The key observation from our work is that, although RTD is similar in most aspects to TD in software code, it also has its own components. Requirement artifacts have a feedback loop involving the User to precisely capture User Needs. RTD Interest (i.e., additional costs due to sub-optimal decisions concerning Requirements) can incur during both Requirements Engineering and Implementation activities. Furthermore, RTD can incur regardless of the presence of software code-related TD. Similar to benefits accrued by refactoring software code, rectifying RTD can also accrue benefits.

The introduction of programming into secondary schools in New Zealand (NZ) has meant that many teachers are preparing programming students at senior level for the New Zealand Certificate of Educational Achievement (NCEA). A recent study showed that many teachers struggle with providing feedback to students on code quality, and indicated a possible issue with the available resources. In this paper, we describe a study to help us understand this phenomenon. We first analysed the data from the earlier study concerning teachers' viewpoints on the available resources. We then analysed the defining curriculum and assessment documents for NCEA, extracting quality-relating terms. We found that all teachers interviewed reported issues with the resources and that there was no clear mapping for quality concepts between the two sets of resources. Our contribution is to expose gaps in the online resources that are problematic from the perspective of teacher and student outcomes.

The quality of the code impacts the cost of its maintenance, yet "code quality" is often not given attention in introductory programming courses, perhaps due to the difficulty of providing automated code quality feedback. We have been exploring how to provide automated feedback on complexity, one aspect of code quality. We have developed CompareCFG that provides feedback based on control flow graphs (CFGs). It generates visualisations of students' submissions and provides the means for a student to compare the CFG of their own code with CFGs of less complex submissions, helping to support their understanding of code complexity. CompareCFG also provides actionable feedback by indicating specific issues in a submission that can reduce its complexity. We evaluated CompareCFG in a pilot study. We found it provides useful feedback to participants that helped them reduce the complexity of their code. CompareCFG offers a convenient way to provide programming students with automated visual feedback on code quality.

Many prescriptive approaches to developing software intensive systems have been advocated but each is based on assumptions about context. It has been found that practitioners do not follow prescribed methodologies, but rather select and adapt specific practices according to local needs. As researchers, we would like to be in a position to support such tailoring. However, at the present time we simply do not have sufficient evidence relating practice and context for this to be possible. We have long understood that a deeper understanding of situated software practices is crucial for progress in this area, and have been exploring this problem from a number of perspectives. In this position paper, we draw together the various aspects of our work into a holistic model and discuss the ways in which the model might be applied to support the long term goal of evidence-based decision support for practitioners. The contribution specific to this paper is a discussion on model evaluation, including a proof-of-concept demonstration of model utility. We map Kernel elements from the Essence system to our model and discuss gaps and limitations exposed in the Kernel. Finally, we overview our plans for further refining and evaluating the model.

Construct validity is essentially the degree to which our scales, metrics and instruments actually measure the properties they are supposed to measure. Although construct validity is widely considered an important quality criterion for most empirical research, many software engineering studies simply assume that proposed measures are valid and make no attempt to assess construct validity. Researchers may ignore construct validity because evaluating it is intrinsically difficult, or due to lack of specific guidance for addressing it. In any case, some research inevitably produces erroneous conclusions, because due to invalid measures. This article therefore attempts to address these problems by explaining the theoretical basis of construct validity, presenting a framework for understanding it, and developing specific guidelines for assessing it. The paper draws on a detailed example involving 15 software metrics, which ostensibly measure the size, coupling and cohesion of Java classes.

One means to determine whether a student understands the fundamentals of good object-oriented design is to assess designs the student has created. However, providing reliable assessment of designs efficiently is difficult due to the many viable designs that are possible and the high level of expertise required. Consequently, design assessment tends to be limited to identifying the most basic of design problems. We propose a technique---"object counts''---that involves counting the objects created at runtime. This is more efficient than manual grading because the data is gathered automatically and more reliable than using rubrics because it is based on objective data. The data is relevant because it captures the fundamental property of an object-oriented program---the creation of objects---and so provides good insight into the student's design decisions. This provides support for both summative and formative feedback. We demonstrate the technique on two corpora containing submissions for a typical first assignment of an introductory course on object-oriented design.

Debugging software is challenging, particularly for novices. Despite the importance of debugging, most novice programmers are not formally taught any debugging skills. This paper describes an online tool, Ladebug, that is designed to scaffold the learning of debugging skills. In this environment, students follow a structured debugging process to find and fix errors in predefined exercises. Overall, we find that students are positive about the tool, and report the exercises to be engaging and helpful.

Design smells are design structures that indicate poor design quality. Many identified smells are difficult to teach as they require a degree of experience and judgement that novices, by definition, do not have. We have identified a design smell, which we call "unencapsulated collection", that is common in novice designs. It is simple to describe, allowing it to be objectively detected, and the refactoring steps needed to remove the smell are usually simple to illustrate. We give a description of the smell and present the results of an empirical study showing its prevalence. We outline the general steps for refactoring the smell, and illustrate it with a case study. The simplicity of this smell makes it a good candidate for teaching good design principles to novices.

Students and instructors expend significant effort, respectively, preparing to be examined and preparing students for exams. This paper investigates question authoring, where students create practice questions as a preparation activity prior to an exam, in an introductory programming context. The key contribution of this study as compared to previous work is an improvement to the design of the experiment. Students were randomly assigned the topics that their questions should target, removing a selection bias that has been a limitation of earlier work. We conduct a large-scale between-subjects experiment (n = 700) and find that students exhibit superior performance on exam questions that relate to the topics they were assigned when compared to those students preparing questions on other assigned topics.

Many metrics have been proposed to measure coupling-the degree of association between modules in a system. However, most metrics are under-defined, meaning that different tool developers can reasonably implement the same metric in many ways. This gives rise to families of metrics, which are superficially similar but potentially produce different results. To understand how different these metrics are, we propose a single model of coupling based on the concept of dependencies. This model is useful for defining existing coupling metrics, analysing their differences and clarifying divergent implementations. We demonstrate its efficacy by using it to describe existing coupling metrics and inform tool development. We have applied the tool to the 112 systems in the Qualitas Corpus, generating 21 million measurements from 88 coupling metrics. The simplicity of the tool implementation and the number of metrics it supports demonstrates the usefulness of our model.

Code appears replete with decisions including logic, organization, presentation and library use. But are developers consciously making these decisions or does it only look that way post hoc? Analysis of 104 developer interviews indicates that developers make many decisions concerning design, architecture, scope and technology use. However, they struggle to reconstruct codefocused choices between two or more alternatives. This suggests that decision-making is not the dominant cognitive process underlying coding behavior, which raises questions about how we teach coding and how we evaluate coding performance.

Most performance engineering approaches focus on understanding the use of runtime resources. However such approaches do not quantify the value being provided in return for the consumption of these resources. Without such a measure it is not possible to compare the efficiency of these components (that is whether the runtime cost is reasonable given the benefit being provided). We have created an empirical approach that measures the value being provided by a code path in terms of the visible data it generates for the rest of the application. Combining this with traditional performance cost data, creates an efficiency measure for every code path in the application. We have evaluated our approach using the DaCapo benchmark suite, demonstrating our analysis allows us to quantify the efficiency of the code in each benchmark and find real optimisation opportunities, providing improvements of up to 36% in our case studies.

In this work we present an empirical study on the use of inheritance in a curated corpus of Python systems. Replicating a study preformed on Java, we analyzed a collection of 51 software systems written in Python, and investigated how inheritance is effectively used by Python developers in practice through a convenient set of inheritance metrics. Our results suggest that on average fewer classes inherit from other classes than in Java, but more classes are inherited from. We also see a sort of symmetry relating the number of ancestors and the number of descendants in each system.

WETSoM is a gathering of researchers and practitioners to discuss the progress on software metrics knowledge. Motivations for this workshop include the low impact that software metrics have on current software development and the increased interest in research. The goals of this workshop include critically examining the evidence for the effectiveness of existing metrics and identifying new directions for metrics. Evidence for existing metrics includes how the metrics have been used in practice and studies showing their effectiveness. Identifying new directions includes use of new theories, such as complex network theory, on which to base metrics.

Large-scale object-oriented applications consist of tens of thousands of methods and exhibit highly complex runtime behaviour that is difficult to analyse for performance. Typical performance analysis approaches that aggregate performance measures in a method-centric manner result in thinly distributed costs and few easily identifiable optimisation opportunities. Subsuming methods analysis is a new approach that aggregates performance costs across repeated patterns of method calls that occur in the application's runtime behaviour. This allows automatic identification of patterns that are expensive and represent practical optimisation opportunities. To evaluate the practicality of this analysis with a real world large-scale object-oriented application we completed a case study with the developers of letterboxd.com - a social network website for movie goers. Using the results of the analysis we were able to rapidly implement changes resulting in a 54.8% reduction in CPU load and an 49.6% reduction in average response time.

The majority of existing application profiling techniques aggregate and report performance costs by method or calling context. Modern large-scale object-oriented applications consist of thousands of methods with complex calling patterns. Consequently, when profiled, their performance costs tend to be thinly distributed across many thousands of locations with few easily identifiable optimisation opportunities.

Performance is a crucial attribute for most software, making performance analysis an important software engineering task. The difficulty is that modern applications are challenging to analyse for performance. Many profiling techniques used in real-world software development struggle to provide useful results when applied to large-scale object-oriented applications. There is a substantial body of research into software performance generally but currently there exists no survey of this research that would help identify approaches useful for object-oriented software. To provide such a review we performed a systematic mapping study of empirical performance analysis approaches that are applicable to object-oriented software. Using keyword searches against leading software engineering research databases and manual searches of relevant venues we identified over 5,000 related articles published since January 2000. From these we systematically selected 253 applicable articles and categorised them according to ten facets that capture the intent, implementation and evaluation of the approaches. Our mapping study results allow us to highlight the main contributions of the existing literature and identify areas where there are interesting opportunities. We also find that, despite the research including approaches specifically aimed at object-oriented software, there are significant challenges in providing actionable feedback on the performance of large-scale object-oriented applications.

Background: The quality of data sets used in software engineering research is of the utmost importance. To ensure credibility of results obtained from use of data sets, the quality of the data must be examined. Objective: This study provides an overview of recent research(2008-2012) involving data quality in software engineering datasets, with the goal of generally understanding what research there is that addresses data quality, and in particular to determine to what degree researchers have addressed any data quality issues in order to evaluate the trustworthiness of their results. Method: We performed a systematic mapping study to investigate treatment of data quality issues in software engineering research. A total of 64 papers published from 2008 to 2012explicitly address issues with the quality of data and use software engineering data sets. These studies were classified according to the data quality topic, data set and data quality problem. Results: We found only 31 studies gave serious consideration for how the quality of the data affected their results. We observed that there is a lack of clear and consistent terminology regarding data quality, especially with respect to the kinds of quality problems a data set might have. As a first step to address this problem, we propose a model that describes the lifecycle that research data goes through when used in research. Conclusions: The results suggest that researchers should give more attention to the quality of data sets in order to produce trustworthy data for reliable empirical research, and that the research community needs to better understand and communicate issues with data quality.

Background: Relational database-driven software applications have gained significant importance in modern software development. Given that software maintainability is an important quality attribute, predicting these applications' maintainability can provide various benefits to software organizations, such as adopting a defensive design and more informed resource management. Aims: The aim of this paper is to present the results from employing two well-known prediction techniques to estimate the maintainability of relational database-driven applications. Method: Case-based reasoning (CBR) and classification and regression trees (CART) were applied to data gathered on 56 software projects from software companies. The projects concerned development and/or maintenance of relational database-driven applications. Unlike previous studies, all variables (28 independent and 1 dependent) were measured on a 5-point bi-polar scale. Results: Results showed that CBR performed slightly better (at 76.8% correct predictions) in terms of prediction accuracy when compared to CART (67.8%). In addition, the two important predictors identified were documentation quality and understandability of the applications. Conclusions: The results show that CBR can be used by software companies to formalize and improve their process of maintainability prediction. Future work involves gathering more data and also employing other prediction techniques.

The International Workshop on Emerging Trends in Software Metrics aims at gathering 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 includes critically examining the evidence for the effectiveness of existing metrics and identifying new directions for metrics. Evidence for existing metrics includes how the metrics have been used in practice and studies showing their effectiveness. Identifying new directions includes use of new theories, such as complex network theory, on which to base metrics.

We know that students solve problems in different ways, but we know little about the kinds of variation, or the degree of variation between these student generated solutions. In this paper, we propose a taxonomy that classifies the variation between correct student solutions in objective terms, and we show how the application of the taxonomy provides instructors with additional insight about the differences between student solutions. This taxonomy may be used to inform instructors in selecting examples of code for teaching purposes, and provides the possibility of automatically applying the taxonomy to existing solution sets.

Software maintainability is a very important quality attribute. Its prediction for relational database-driven software applications can help organizations improve the maintainability of these applications. The research presented herein adopts a survey-based approach where a survey was conducted with 40 software professionals aimed at identifying and ranking the important maintainability predictors for relational database-driven software applications. The survey results were analyzed using frequency analysis. The results suggest that maintainability prediction for relational database-driven applications is not the same as that of traditional software applications in terms of the importance of the predictors used for this purpose. The results also provide a baseline for creating maintainability prediction models for relational database-driven software applications.

Different kinds of process model are prescribed for software organizations, and each offers successful project outcomes if followed. There is little evidence that organizations strictly adhere to specific models. We surveyed 195 participants from 51 New Zealand (NZ) software organizations with a view to increasing our understanding of practice implementation in NZ. We found that practices are implemented inconsistently. The implication is that organizations do not follow any one process, either prescribed or adapted, but rather select practices on a project basis and according to some unknown guidelines. Our conclusion is that, rather than attempting to impose or adapt processes at an organizational level, we should instead aim to understand the rationale behind practice selection and how practices combine to make a coherent set. We also found a collaborative, informal, iterative approach to product development with issues around clarity and availability of requirements.

Identifying and correcting syntax errors is a challenge all novice programmers confront. As educators, the more we understand about the nature of these errors and how students respond to them, the more effective our teaching can be. It is well known that just a few types of errors are far more frequently encountered by students learning to program than most. In this paper, we examine how long students spend resolving the most common syntax errors, and discover that certain types of errors are not solved any more quickly by the higher ability students. Moreover, we note that these errors consume a large amount of student time, suggesting that targeted teaching interventions may yield a significant payoff in terms of increasing student productivity.

We proposed a definition of transparency in software development to improve communication among stakeholders. The notion of transparency is important, because it enables stakeholders to identify and understand the information exchanged during communication. We designed a survey to gather evidence to support or refute our beliefs about transparency in software development. We discovered a superiority bias in our respondents when answering questions regarding communication problems. In this paper, we present our survey design and preliminary results of our survey.

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.

Mastering syntax is one of the earliest challenges facing the novice programmer. Problem solving and algorithms are the focus of many first year programming classes, leaving students to learn syntax on their own while they practice writing code. In this paper we investigate the frequency with which students encounter syntax errors during a drill and practice activity. We find that students struggle with syntax to a greater extent than we anticipated, even when writing short fragments of code.

Drill and practice exercises enable students to master skills needed for more sophisticated programming. A barrier to providing such activities is the effort required to set up the programming environment. Testing is an important component to writing good software, but it is difficult to motivate students to write tests. In this paper we describe and evaluate Code Write, a web-based tool that provides drill and practice support for Java programming, and for which testing plays a central role in its use. We describe how we have used Code Write in a CS1 course, and demonstrate its effectiveness in providing good coverage of the language features presented in the course.

In order to increase our ability to use measurement to support software development practise we need to do more analysis of code. However, empirical studies of code are expensive and their results are difficult to compare. We describe the Qualitas Corpus, a large curated collection of open source Java systems. The corpus reduces the cost of performing large empirical studies of code and supports comparison of measurements of the same artifacts. We discuss its design, organisation, and issues associated with its development.

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.

We present the first results from a survey carried out over the second quarter of 2009 examining how theories in object-oriented design are understood and used by software developers. We collected 3785 responses from software developers world-wide, which we believe is the largest survey of its kind. We targeted the use of encapsulation, class size as measured by number of methods, and depth of a class in the inheritance hierarchy. We found that, while overall practitioners followed advice on encapsulation, there was some variation of adherence to it. For class size and depth there was substantially less agreement with expert advice. In addition, inconsistencies were found within the use and perception of object-oriented concepts within the investigated group of developers. The results of this survey has deep reaching consequences for both practitioners and researchers as they highlight and confirm central issues.

Coupling is a well researched topic in the Object-Oriented (OO) research community and its influence on class cohesion is well understood. In this paper, we present an empirical study exploring the effect of method calling on class cohesion using two coupling metrics, namely fan-in and fan-out. Three Java, open-source systems (OSS) were used as a basis of the study. A small number of classes were found to account for the vast majority of fan-in and fan-out. We also found the impact of fan-out on class cohesion to be higher than that of fan-in. Classes containing fan-out tended to have lower cohesion than those containing fan-in.

This paper presents the results of a systematic review conducted to collect evidence on software maintainability prediction and metrics. The study was targeted at the software quality attribute of maintainability as opposed to the process of software maintenance. The evidence was gathered from the selected studies against a set of meaningful and focused questions. 710 studies were initially retrieved; however of these only 15 studies were selected; their quality was assessed; data extraction was performed; and data was synthesized against the research questions. Our results suggest that there is little evidence on the effectiveness of software maintainability prediction techniques and models.

A recent study on how inheritance is used in open source Java software revealed a surprising number of interfaces that were neither implemented nor extended. While innocent explanations for this exist (the interfaces are part of frameworks that only clients of the frameworks implement), it does raise the question of how much "dead code'' exists in applications. Dead code usually refers to code within a function that cannot be executed, but unused interfaces, and more generally unused public methods, represent dead code at the "design'' level, and so can potentially have a significant impact on future maintenance costs. This paper presents a large empirical study on existence of design decisions that are unused. This study examined 100 open source Java applications. The results show a significant level of unused design decisions.

Multiple dispatch uses the run time types of more than one argument to a method call to determine which method body to run. While several languages over the last 20 years have provided multiple dispatch, most object-oriented languages still support only single dispatch forcing programmers to implement multiple dispatch manually when required. This paper presents an empirical study of the use of multiple dispatch in practice, considering six languages that support multiple dispatch, and also investigating the potential for multiple dispatch in Java programs. We hope that this study will help programmers understand the uses and abuses of multiple dispatch; virtual machine implementors optimise multiple dispatch; and language designers to evaluate the choice of providing multiple dispatch in new programming languages.

Software visualization has always been expensive, special purpose, and hard to program. Most of the existing software visualization tools require too much time for end-user developers to learn and make effective use of. We are currently building a Web software visualization application that allows end-user to create, view, save, and share visualizations. In this abstract we introduce our software corpus visualization project and summarize our results thus far.

Cohesion is an attribute of software design quality for which many metrics have been proposed. The different proposals have been made largely on theoretical grounds, with little evidence of actual use. This makes it difficult to provide advice to software developers as to how to interpret the measurements any given metric produces. This paper presents the first large-scale empirical study of object- oriented cohesion metrics. We apply 16 metrics from the literature, as well as a number of variations, to 92 open source and industry Java applications ranging in size from a few classes to several thousand, over 100,000 classes in all. Our results show that by and large applications have similar distributions of measurements according to any given metric, but that the distributions can be quite different across metrics. This provides useful information for the ongoing empirical validation efforts for cohesion metrics.

The static modifier is a convenient way to make class members "global" in object-oriented software systems. Given this, we wondered if static members significantly contribute to the long dependency cycles among the classes that we observed in a previous empirical study of Java software. In this paper, we examine 81 open source Java applications. We find empirical evidence that classes that declare a non-private static field or method that is accessed from within another class are likely to be involved in dependency cycles.

Abstract Diagram‐centric applications such as software design tools, project planning tools and business process modelling tools are usually ‘thick‐client’ applications running as stand‐alone desktop applications. There are several advantages to providing such design tools as Web‐based or even PDA‐ and mobile‐phone‐based applications. These include ease of access and upgrade, provision of collaborative work support and Web‐based integration with other applications. However, building such thin‐client diagram editing tools is very challenging. We have developed several thin‐client diagram editing applications realized as a set of plug‐in extensions to a meta‐tool for visual design environment development. In this paper, we discuss key user interaction and software architecture issues, illustrate examples of interacting with our thin‐client diagram editing tools, describe our design and implementation approaches, and present the results of several different evaluations of the resultant applications. Our experiences will be useful for those interested in developing their own thin‐client diagram editing architectures and applications. Copyright © 2007 John Wiley & Sons, Ltd.

The Java Standard API has grown enormously since Java's beginnings, now consisting of over 3,000 classes and 20,000 methods. The intent of this API is to provide high quality components that can be easily reused and so increase the Java developer's productivity - but does it? In this paper, we present a study that begins to answer this question. Specifically we take a corpus-based approach to help determine the "typical" usage of the Standard API. We find that, in an extensive corpus of open-source software, only about 50% of the classes in the Standard API are used at all, and around 21% of the methods are used. We discuss the implications this has for future development of both the API itself, and for tools to support the API.

Large amounts of Java software have been written since the language's escape into unsuspecting software ecology more than ten years ago. Surprisingly little is known about the structure of Java programs in the wild: about the way methods are grouped into classes and then into packages, the way packages relate to each other, or the way inheritance and composition are used to put these programs together. We present the results of the first in-depth study of the structure of Java programs. We have collected a number of Java programs and measured their key structural attributes. We have found evidence that some relationships follow power-laws, while others do not. We have also observed variations that seem related to some characteristic of the application itself. This study provides important information for researchers who can investigate how and why the structural relationships we find may have originated, what they portend, and how they can be managed.

This paper documents efforts that the department has made to support women students between 1991 and the 1996. Our major goal has been to reduce the high withdrawal rate of women students in our entry level course in computer science. We describe the approaches that have been taken to address this concern, and present the data which has been collected to track the results of our efforts. Our data suggests that providing a gender neutral content is not enough to ensure that men and women will retain similarly. In this paper we suggest policies which we feel may be beneficial in achieving similar male and female retention rates.

We present a conceptual model for helping us understand the nature of software reusability, particularly to help us understand how language features affect the reusability of software. The fundamental concept for our model is that of dependencies. We identify properties of dependencies between segments of code that are important to reusability. We validate our model by showing its application to well understood principles of reusability. We demonstrate that being able to describe these principles in a single framework allows us to gain a better understanding of reusability.

Programmers new to the object-oriented paradigm often have difficulty learning how to use inheritance properly. In this paper we introduce an approach to explaining inheritance that is based on understanding the nature of reusability. We show how the important aspect of inheritance is interface conformance, and explain the role this plays in supporting reusability. We then outline a method for determining when and how to use both single inheritance and multiple inheritance, and discuss the implications of our approach.

We consider the sequence transmission problem, that is, the problem of transmitting an infinite sequence of messages x 1 x 2 x 3 … over a channel that can both lose and reorder packets. We define performance measures, ideal transmission cost and recovery cost, for protocols that solve the sequence transmission problem. Ideal transmission cost measures the number of packets needed to deliver x n when the channel is behaving ideally and recovery cost measures how long it takes, in terms of number of messages delivered, for the ideal transmission cost to take hold once the channel begins behaving ideally. We also define lookahead, which measures the number of messages the sender can be ahead of the receiver in the protocol. We show that any protocol with constant recovery cost and lookahead requires linear ideal transmission cost. We describe a protocol, P lin , that has ideal transmission cost 2 n , recovery cost 1, and lookahead 0.

Abstract Emerald is a general‐purpose language with aspects of traditional object‐oriented languages, such as Smalltalk, and abstract data type languages, such as Modula‐2 and Ada. It is strongly typed with a non‐traditional object model and type system that emphasize abstract types, allow separation of typing and implementation, and provide the flexibility of polymorphism and subtyping with compile‐time checking. This paper describes the Emerald language and its programming methodology. We give examples that demonstrate Emerald's features, and compare and contrast the Emerald approach to programming with the approaches used in other similar languages.

In this paper we present tight bounds on the efficiency of protocols that transmit messages through a communications channel that can lose and reorder packets and discuss new ways to measure the behavior of such protocols.