Investigating the relationship between bad smells and bugs in software systems

2017 ◽  
Author(s):  
Rogeres Nascimento ◽  
Cláudio Sant'Anna
Keyword(s):  
Software Systems ◽  
The Relationship

scholarly journals Internal Quality Evolution of Open-Source Software Systems

2021 ◽  
Vol 11 (12) ◽  
pp. 5690
Author(s):  
Mamdouh Alenezi
Keyword(s):  
Open Source ◽  
Open Source Software ◽  
Software Evolution ◽  
Quality Metrics ◽  
Internal Quality ◽  
Software Systems ◽  
Software Metric ◽  
Significant Difference ◽  
The Relationship

The evolution of software is necessary for the success of software systems. Studying the evolution of software and understanding it is a vocal topic of study in software engineering. One of the primary concepts of software evolution is that the internal quality of a software system declines when it evolves. In this paper, the method of evolution of the internal quality of object-oriented open-source software systems has been examined by applying a software metric approach. More specifically, we analyze how software systems evolve over versions regarding size and the relationship between size and different internal quality metrics. The results and observations of this research include: (i) there is a significant difference between different systems concerning the LOC variable (ii) there is a significant correlation between all pairwise comparisons of internal quality metrics, and (iii) the effect of complexity and inheritance on the LOC was positive and significant, while the effect of Coupling and Cohesion was not significant.

Information Systems as Wicked Problems

2000 ◽  
pp. 131-144
Author(s):  
Gill Mallalieu ◽  
Steve Clarke
Keyword(s):  
Risk Assessment ◽  
Assessment Model ◽  
Wicked Problem ◽  
Software Systems ◽  
Legacy Software ◽  
It Systems ◽  
Strategic Model ◽  
Detailed Method ◽  
Medium Enterprises ◽  
The Relationship

The idea of the ‘wicked problem’ (Churchman, 1967), which advocates a pragmatic oscillation between problem and solution, rather than an attempt to reduce the problem to a series of steps to be followed sequentially, has been particularly helpful to us in conceptualising the relationships between people, organisations and information technology (IT). This conceptualisation was tested in the RAMESES project (Risk Assessment Model: Evaluation Strategy for Existing Systems), using grounded theory (Strauss and Corbin, 1997) as the basis for the methodology. The overall objective of RAMESES is ‘to provide a strategic model for the risk assessment of legacy software systems within SMEs (small-to-medium enterprises) considering business process change.’ Thus the relationship between the organisation, the way its staff carried out its processes, and their legacy IT systems was at the centre of our concerns. This chapter describes how the broad conceptualisation of the problem led to a detailed method to address it and the results available to date.

Extreme Architecture Framework

2007 ◽  
pp. 18-38 ◽  
Author(s):  
P. Robinson ◽  
F. Gout
Keyword(s):  
Human Activity ◽  
Software Systems ◽  
Shared Understanding ◽  
Architecture Framework ◽  
Planning Development ◽  
Relationship Of ◽  
The Relationship ◽  
Minimalist Framework

As consultant-educators, the authors created the extreme architecture framework (XAF) in order to quickly grasp an understanding of an organisation’s architecture from different perspectives. The framework is presented as a matrix of system types and architectural perspectives that is described by a single uncluttered diagram. Elements within the framework are defined along with the content that can include architectural representations, planning, and governance information. A discussion follows to show the relationship of the framework to planning, development, and governance activities. The minimalist framework presents a consolidated view of both human activity and software systems and can also help to foster a shared understanding between IT groups and business areas. It has been designed to answer a manager’s questions: • Which elements of the enterprise do I need to be aware of and understand; and • Which elements am I responsible for and need to manage?

Complexity and Nesting Evolution in Open Source Software Systems: Experimental Study

2020 ◽  
Vol 13 (4) ◽  
pp. 572-578 ◽  
Author(s):  
Mamdouh Alenezi ◽  
Mohammad Zarour ◽  
Mohammed Akour
Keyword(s):  
Open Source Software ◽  
Correlation Coefficients ◽  
Software Systems ◽  
Software Cost ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Cyclomatic Complexity ◽  
Code Refactoring ◽  
Nesting Problem ◽  
The Relationship

Background: Software complexity affects its quality; a complex software is not only difficult to read, maintain and less efficient, but it also can be less secure with many vulnerabilities. Complexity metrics, e.g. cyclomatic complexity and nesting levels, are commonly used to predict and benchmark software cost and efficiency. Complexity metrics are also used to decide if code refactoring is needed. Objective: Software systems with high complexity need more time to develop and test and may lead to bad understandability and more errors. Nesting level in the target structure may result in developing more complex software in what is so-called the nesting problem. Nesting problem should be shortened by rewriting the code or breaking into several functional procedures. Method: In this paper, the relationship between the nesting levels, the cyclomatic complexity, and lines of code (LOC) metrics are measured through several software releases. In order to address how strong a relationship between these factors with the nesting level, correlation coefficients are calculated. Moreover, to examine to what extent the developers are aware of and tackle the nesting problem, the evolution of nesting levels for ten releases of five open sources systems is studied to see if it is improving over successive versions or not. Results: The result shows that the nesting level has variant effects on the cyclomatic complexity and SLOC for the five studied systems. Conclusion: nesting level has the tendency to have a positive correlation with other factors (cyclomatic complexity and LOC).

Extracting Social Relationships from Social Software

2012 ◽  
pp. 405-417
Author(s):  
Jürgen Dorn ◽  
Stefan Labitzke
Keyword(s):  
Real World ◽  
Analytical Approach ◽  
Personal Relationship ◽  
Social Software ◽  
Software Systems ◽  
Software System ◽  
Internet Technologies ◽  
The Social ◽  
The Impact ◽  
The Relationship

We present an analytical approach to detect relationships between persons in the real world, such as friendship, rivalry, or others, out of the behavior of members in a social software system. In social software systems, users often evaluate submissions of other users. If these actions are somehow biased, we assume a personal relationship between these users. If we know about the relationship between two users, the validity of the evaluation, and with that, the trust into the social software, can be improved. For example, if a rival evaluates a submission unfairly, we should decrease the impact of this evaluation. We apply the approach in TechScreen, a social software system that supports the exchange of knowledge about Internet technologies. Since we try to mine competencies of its users, the validity of evaluations is very important. In this chapter we show results of experiments with about 50 users.

Extracting Social Relationships from Social Software

2014 ◽  
pp. 902-914
Author(s):  
Jürgen Dorn ◽  
Stefan Labitzke
Keyword(s):  
Real World ◽  
Analytical Approach ◽  
Personal Relationship ◽  
Social Software ◽  
Software Systems ◽  
Software System ◽  
Internet Technologies ◽  
The Social ◽  
The Impact ◽  
The Relationship

We present an analytical approach to detect relationships between persons in the real world, such as friendship, rivalry, or others, out of the behavior of members in a social software system. In social software systems, users often evaluate submissions of other users. If these actions are somehow biased, we assume a personal relationship between these users. If we know about the relationship between two users, the validity of the evaluation, and with that, the trust into the social software, can be improved. For example, if a rival evaluates a submission unfairly, we should decrease the impact of this evaluation. We apply the approach in TechScreen, a social software system that supports the exchange of knowledge about Internet technologies. Since we try to mine competencies of its users, the validity of evaluations is very important. In this chapter we show results of experiments with about 50 users.

IMPACT OF SOFTWARE COMPLEXITY ON DEVELOPMENT PRODUCTIVITY

2012 ◽  
Vol 22 (08) ◽  
pp. 1103-1122 ◽  
Author(s):  
JIZHOU ZHAN ◽  
XIANZHONG ZHOU ◽  
JIABAO ZHAO
Keyword(s):  
Development Process ◽  
Minimum Degree ◽  
Cognitive Learning ◽  
Software Systems ◽  
Factors Affecting ◽  
Effective Strategies ◽  
Software Complexity ◽  
And Behavior ◽  
The Impact ◽  
The Relationship

With increasing demands on software functions, software systems become more and more complex. This complexity is one of the most pervasive factors affecting software development productivity. Assessing the impact of software complexity on development productivity helps to provide effective strategies for development process and project management. Previous research literatures have suggested that development productivity declines exponentially with software complexity. Borrowing insights from cognitive learning psychology and behavior theory, the relationship between software complexity and development productivity was reexamined in this paper. This research identified that the relationship partially showed a U-shaped as well as an inverted U-shaped curvilinear tendency. Furthermore, the range of complexity level that is beneficial for productivity has been presented, in which, the lower bound denotes the minimum degree of complexity at which personnel can be motivated, while the upper bound shows the maximum extent of complexity that staff can endure. Based on our findings, some guidelines for improving personnel management of software industry have also been given.

Software Quality and Community Structure in Java Software Networks

2017 ◽  
Vol 27 (07) ◽  
pp. 1063-1096 ◽  
Author(s):  
Giulio Concas ◽  
Michele Marchesi ◽  
Cristina Monni ◽  
Matteo Orrù ◽  
Roberto Tonelli
Keyword(s):  
Community Structure ◽  
Software Quality ◽  
Defect Density ◽  
Power Laws ◽  
Clustering Coefficient ◽  
Software Systems ◽  
Confounding Effect ◽  
Software Network ◽  
Community Metrics ◽  
The Relationship

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.

scholarly journals A Gamification–Motivation Design Framework for Educational Software Developers

2018 ◽  
Vol 47 (1) ◽  
pp. 101-127 ◽  
Author(s):  
Jim Buckley ◽  
Tabea DeWille ◽  
Chris Exton ◽  
Geraldine Exton ◽  
Liam Murray
Keyword(s):  
Game Design ◽  
Educational Software ◽  
Self Determination Theory ◽  
Self Determination ◽  
Software Systems ◽  
Software Developers ◽  
Design Elements ◽  
Motivational Model ◽  
Game Elements ◽  
The Relationship

Gamification is the use of game design elements in nongame contexts and has been shown to be effective in motivating behavior change. By seeing game elements as “motivational affordances,” and formalizing the relationship between these elements and motivational affordances, it is the position of this article that gamification can be effectively applied to improve software systems across many different application domains. The research reported here aims to formalize the relationship between game elements and motivation, toward making gamification’s use more systematic. The focus is on the development of a framework linking commonly occurring game elements with the components of a psychological motivational model known as the self-determination theory, coupled with a proposed framework of commonly occurring game elements. The goal is to inform system designers who would like to leverage gamification of the game elements they would need to employ as motivational affordances.

The Empirical Analysis of Function-Call Graph

2013 ◽  
Vol 798-799 ◽  
pp. 663-667
Author(s):  
Yang Guo ◽  
Zheng Xu Zhao
Keyword(s):  
Complexity Analysis ◽  
Software Systems ◽  
Complex Network Theory ◽  
Call Graph ◽  
Function Call ◽  
Scripting Language ◽  
Analysis Of Function ◽  
Relationship Of ◽  
The Relationship ◽  
The Empirical Analysis

The relationship of function calling is the core of understanding and maintaining software systems for engineers, but so far there have been so little studies concentrating on this aspect. In this paper we presented a comprehensive study of analyzing the software systems at the function level with complex network theory, expecting for providing guidance to the maintaining and controlling of systems. We selected a simple scripting language Lua whose code is in appropriate size for complexity analysis mainly in degree distribution and community detection, and found the heavy-tail and high clustering phenomenon.

Sign in / Sign up

Export Citation Format

Share Document