1,721,000 research outputs found
Maintainable concurrent software
No full textConstructing software that is easy to maintain and reuse is not a trivial task. When the software being constructed exploits concurrency, the task is complicated further.
This thesis attempts to determine what shape an object-oriented programming language's concurrency support should take in order to aid the construction of concurrent software that is easy to maintain and reuse. This is achieved by analysing the component parts of concurrency, comparing and contrasting the way various object-oriented programming languages support concurrency, and analysing problems that arise when using these languages. Using this, the concurrency constructs that an object-oriented programming language should provide, and their inter-relationships, are described. Finally solutions to common problems requiring concurrency, constructed using these constructs, are provided.
The particular contributions this thesis makes are: a taxonomy for classifying concurrency support in object-oriented programming languages, analysis of the issues arising when introducing concurrency support into object-oriented programming languages, and a working implementation of the concurrency constructs found to be necessary for an object-oriented programming language to support concurrency in a fashion that promotes the construction of software that is easy to maintain and reuse
Measuring indirect coupling
No full textFull text is available to authenticated members of The University of Auckland only.There is an increasing awareness on the importance of software measurement within the software engineering community, as well as the necessity of respecting the scientific basis of measurement. However there is little evidence for the latter as there is a tendency for researchers and practitioners to apply software metrics without a full awareness of what they mean. Coupling, which is the measure of the interdependence between parts of a software system (e.g. classes), is one important property for which many metrics have been defined. While it is widely agreed that there is a relationship between high coupling and poor maintainability, I argue that current empirical evidence toward this is insufficient to promote a full understanding of this relationship. Part of this is due to the Iack of coverage of all forms of connections that comprise coupling. To illustrate this I identify a specific, indirect, form of coupling that manifests between two seemingly unrelated parts of the system through hidden connections. My thesis is that there is a relationship between indirect coupling and maintainability. To gather evidence for this I follow a methodology based on the philosophies of key software metrics researchers. This involves operationally defining indirect coupling so that it can be accurately measured, establishing an explanatory model as to the relationship between indirect coupling and maintainability, and finally empirically corroborating this model
An empirical study investigating the use of Python identifier names
No full textUnderstanding software programs is very difficult and time consuming. Identifier names
have an important role in the source code, so it is an important part of enhancing comprehensibility. Many studies have demonstrated that using meaningful identifier names
can improve the comprehensibility of programs. However, most of the naming conventions are rather general. We believe that more specific naming recommendations may be
needed depending on the different cases. In this thesis, we investigated 745,651 identifier
names from 100 open source Python projects from 6 different domains. We explored the
connection between naming conventions and 9 naming practices and their differences in
different contexts, such as loop statements, the size of scopes and different domains. Our
results show that the use of identifier names does vary across cases. Making more detailed
naming conventions based on different cases can help programmers to choose names that
more accurately describe the concept of identifiers and thus improve comprehensibility
An examination of lock-free synchronization in shared memory via simulation
No full textNon-blocking algorithms guarantee that, in a group of processors contending for a shared object, at least one processor can perform its operation on that object regardless of the other processors' actions. Thus a non-blocking algorithm can tolerate certain types of processor failures: in a fail-stop scenario processors can stop, and possibly restart later.
A shared memory multiprocessor experiences various types of delays, ranging from primary cache misses to page faults. If locks are used, care must be taken that the system is not delayed as a whole when a processor holding a lock is delayed. For non-blocking algorithms, however, no such care is necessary.
In this thesis, I investigate the performance of non-blocking algorithms. The investigation consists of a series of simulation experiments on non-blocking algorithms. To properly evaluate the performance of these algorithms, the simulator is accurate down to the bus-cycle level. The design and implementation of the simulator is based on a study of current shared-memory multiprocessors and their cache-coherence protocols.
For these experiments, I use non-blocking algorithms developed from a survey of recent techniques for deriving non-blocking algorithms based on primitive instructions such as Compare&Swap, and Load-Linked/Store-Conditional. A consequence of this survey was that I developed an efficient non-blocking Queue implementation.
The main conclusion of my investigation is that, even in the absence of long delays, non-blocking algorithms typically outperform traditional lock-based algorithms, and, in particular, a priority-based software protocol developed by me matches the performance of hardware-based implementations
Reusability and Class Libraries in C++
No full textA class is a concept in object-oriented programming that describes the fundamental characteristics of an object. A class library is a collection of classes organised specifically for retrieval and reuse in software development. In this report, we explore a number of issues relating to code reusability in class libraries developed with the C++ programming language. We begin by examining the nature of software reuse and the influences of object-orientation on reusability. Various techniques have been employed for the design and implementation of reusable software within class libraries. These techniques rely on specific mechanisms of the programming language that are fundamental to code reuse. We analyse some of these techniques and the mechanisms that underly them in order to assess their significance for reusability. Finally, we identify and address some of the problems and issues relating to the use of the C++ language for developing reusable class libraries
Understanding Java Programs by Visualising Object Counts
No full textFull Text is available to authenticated members of The University of Auckland only.Understanding software program is difficult. An important part of the program understanding enhancement is about hypothesis creation. There has been a great deal of research investigating ways to help developers understand the code they are working with, known as Program Comprehension. It is usually impractical to understand the entire code for a large software system, which would take too long, hence we need a technique for identifying the most relevant, useful parts of the project that the developers could start with. Also for some object-oriented designs, sometimes we may need an efficient method to assess whether it is a good design and how good itis. A quantitative technique could help the evaluator to make the evaluation decision more quickly and precisely. For addressing these concerns, object counting has been proposed as a technique to help with program comprehension. In this thesis we focus on Java programs. Providing comprehensive visualisations on the object counts data during the Java program runtime would be valuable to facilitate understanding the program
A case tool for emphasising reusability in object oriented program development
No full textCASE tools are programs that aid the development and maintenance of programs. Code reuse can also aid in the development and maintenance of code. This thesis investigates CASE tools that support code reuse, concentrating on tools that generate and analyse object oriented code. The code that is generated concerns the object oriented data structures that are reused. The thesis sets out a model for reuse, and also sets out evaluation criteria for CASE tools and applies those criteria to two commercial CASE tools. I then develop a new CASE tool to test out some ideas on supporting reuse, and apply the criteria to the new tool. The CASE tool that I developed parses, generates, and displays diagrams of C++ code
Exploring the Potential of Non-programmer Contributions in Code Review
No full textCode review is the act of one programmer reading through the code developed by another
fellow programmer to detect overlooked functional and evolvability defects. While it car-
ries many benefits for software practitioners and organizations, it also entails challenges.
One of the challenges in code review is its cost due to the need to use expert and expen-
sive programmers. In this dissertation, we investigate an approach for reducing the code
review workload imposed on those programmers.
We conducted a systematic mapping study and an online survey to understand the
challenges in code review in-depth and to identify the ones that require addressing. These
studies confirmed that the high cost has been a challenge in code review. To possibly over-
come this challenge, we propose to delegate a subset of code review tasks to less expen-
sive non-programmers instead of depending solely on expert and expensive programmers.
Thereby, we can free programmers to some extent from their code review workload allow-
ing them to work on other tasks beneficial to their organization. Moreover, the quality
of the software will be improved further, which is the ultimate target of performing code
review.
The nature of code review is such that it would seem that the reviewer needs to be
an expert. To confirm the plausibility of our proposed solution, we examined the kinds
of defects that are typically identified during code review. We identified some defects
that we believed non-programmers might be just as effective at identifying, namely, iden-
tifier name-related defects, conceptual class cohesion-related defects, software-generated
message-related defects, and API documentation grammar and typography-related de-
fects. Guided by these findings, we designed adapted representations of source code and
instructions that non-programmers might be able to use to identify the mentioned types
of defects. Then, two studies were conducted to collect evidence on the feasibility of the
proposed solution. In these studies, we also evaluated the adapted materials we designed.
The reliability of non-programmers was determined by using programmers’ decisions as
the benchmark because currently in practice, the most trustworthy detection of defects
related to the mentioned subjective aspects of code is performed by programmers.
The results from the feasibility studies revealed that non-programmers are, in fact, able to identify subsets of all 4 of the mentioned defect types. We identified the cases where non-programmers’ review outcomes were similar to the programmers and ways to improve
their review outcomes further. Finally, we also identified the most effective review method
for non-programmers including the most effective adapted materials among the ones we
evaluated. Future research in this area will look at ways to improve non-programmers’
reliability in code review further and provide appropriate automation support for non-
programmers to review code
Modelling the Quantification of Technical Debt: A Theoretical Foundation for Quantifying Code, Design, Architecture, and Requirements Technical Debt
No full textSoftware companies could make sub-optimal decisions during the process of software development. They could be made intentionally or unintentionally, but are predominantly made in pursuit of short-term goals such as faster time to market. The metaphor 'Technical Debt (TD)' captures the consequences of such sub-optimal decisions.
TD could be detrimental to a software company unless managed; it could lead to large cost overruns and have adverse effects on the company's reputation. When taken prudently and managed effectively, TD can also bring benefits to software companies. Therefore, TD must be consciously managed during software development.
There have been various efforts made to contribute toward this goal --- to make software practitioners, both technical and non-technical stakeholders, aware of the consequences of accumulating TD and how to manage it. However, TD Measurement or Quantification, one of the most important TDM activities that actually allows making informed decisions regarding TD management, has not received adequate attention in the existing research in terms of reaching a consensus on how to quantify TD. Instead, various approaches have been proposed, all introducing new methods and metrics without a consensus on what a reliable TD quantification approach may entail.
In our efforts to reach the goal of reliably quantifying TD and being able to effectively manage TD, we need to first understand its quantification conceptually. Then we must identify gaps in the existing quantification approaches based on a common model to improve existing approaches and develop new ones. Yet, there is no common model in the literature. This thesis contributes towards this goal by proposing a theoretical foundation for the problem of TD quantification.
The main contribution of this thesis is a conceptual model that holistically captures the concepts and relationships pertaining to the phenomenon of TD Quantification for software code-related and requirements-related TD types. The model concepts and relationships are grounded in the literature and are validated through empirical studies. The model provides useful insights and shows promising paths for future research
- …
