scholarly journals The long and winding road: Accidents and tinkering in software standardization

2020 ◽  
Author(s):  
Sergi Valverde
Keyword(s):  
Programming Languages ◽  
Road Accidents ◽  
Reusable Software ◽  
Emergent Complexity ◽  
Technological Diversity ◽  
Universal Principles ◽  
Software Production ◽  
Poor Understanding ◽  
Development Processes ◽  
Reliable Software

Software is based on universal principles but not its development. Relating software to hardware is never automatic or easy. Attempts to optimize software production and drastically reduce their costs (like in hardware) have been very restricted. Instead, highly-skilled and experienced individuals are ultimately responsible for project success. The long and convoluted path towards useful and reliable software is often plagued by idiosyncratic accidents and emergent complexity. It was expected that software standardisation would remove these sources of unwanted diversity by aiming to controllable development processes, universal programming languages, and toolkits of reusable software components. However, limited adoption of development standards suggests that we still do not understand why software is so difficult to produce. Software standardisation has been limited by our poor understanding of humans’ role at the origin of technological diversity.

scholarly journals The Study of Resource Allocation among Software Development Phases: An Economics-Based Approach

2011 ◽  
Vol 2011 ◽  
pp. 1-21 ◽  
Author(s):  
Peleg Yiftachel ◽  
Irit Hadar ◽  
Dan Peled ◽  
Eitan Farchi ◽  
Dan Goldwasser
Keyword(s):  
Resource Allocation ◽  
Software Development ◽  
Empirical Studies ◽  
Profit Maximization ◽  
Maximization Problem ◽  
Software Production ◽  
Software Product ◽  
Development Processes ◽  
Development Phases ◽  
Novel Concept

This paper presents an economics-based approach for studying the problem of resource allocation among software development phases. Our approach is structured along two parallel axes: theoretical and empirical. We developed a general economic model for analyzing the allocation problem as a constrained profit maximization problem. The model, based on a novel concept of software production function, considers the effects of different allocations of development resources on output measures of the resulting software product. An empirical environment for evaluating and refining the model is presented, and a first exploratory study for characterizing the model's components and developers' resource allocation decisions is described. The findings illustrate how the model can be applied and validate its underlying assumptions and usability. Future quantitative empirical studies can refine and substantiate various aspects of the proposed model and ultimately improve the productivity of software development processes.

Reuse in Agile Development Process

2022 ◽  
pp. 1511-1534
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Software Development ◽  
Development Process ◽  
Agile Development ◽  
Reusable Software ◽  
Model Driven ◽  
Development Processes ◽  
Agile Approach ◽  
Similar Solutions ◽  
Agile Software ◽  
Model Driven Approach

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

scholarly journals Comparison of systematically derived software metrics thresholds for object-oriented programming languages

2020 ◽  
Vol 17 (1) ◽  
pp. 181-203
Author(s):  
Tina Beranic ◽  
Marjan Hericko
Keyword(s):  
Empirical Study ◽  
Programming Languages ◽  
Software Metrics ◽  
Quality Evaluation ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Threshold Values ◽  
Data Set ◽  
Software Metric ◽  
Reliable Software

Without reliable software metrics threshold values, the efficient quality evaluation of software could not be done. In order to derive reliable thresholds, we have to address several challenges, which impact the final result. For instance, software metrics implementations vary in various software metrics tools, including varying threshold values that result from different threshold derivation approaches. In addition, the programming language is also another important aspect. In this paper, we present the results of an empirical study aimed at comparing systematically obtained threshold values for nine software metrics in four object-oriented programming languages (i.e., Java, C++, C#, and Python).We addressed challenges in the threshold derivation domain within introduced adjustments of the benchmarkbased threshold derivation approach. The data set was selected in a uniform way, allowing derivation repeatability, while input values were collected using a single software metric tool, enabling the comparison of derived thresholds among the chosen object-oriented programming languages.Within the performed empirical study, the comparison reveals that threshold values differ between different programming languages.

Governance Regimes for Large Complex Projects

2005 ◽  
Vol 36 (3) ◽  
pp. 42-50 ◽  
Author(s):  
Roger Miller ◽  
Brian Hobbs
Keyword(s):  
Project Development ◽  
Capital Projects ◽  
Private Finance Initiative ◽  
Emergent Complexity ◽  
Project Governance ◽  
Large Complex ◽  
Complex Projects ◽  
Development Life Cycle ◽  
Development Processes ◽  
Specific Project

This paper presents a framework for building governance regimes for large complex projects. The framework is based on three sources: 1) a re-examination of a study of 60 large capital projects (Miller & Lessard, 2000), 2) the institutional, corporate, and project governance literatures and 3) interviews centered on the revision of the British Private Finance Initiative and on the development of the Norwegian project approval process. The literature tends to treat governance issues as being static, but project development processes and environments are dynamic. The governance regimes must adapt to the specific project and context, deal with emergent complexity, and change as the project development process unfolds. Learning to manage project governance regimes is difficult for organizations that are not involved in great numbers of large complex projects. The framework based on the progressive shaping of the project through the project development life cycle is designed to help overcome this dilemma.

PERFORMANCE-PARAMETERIZED REUSABLE SOFTWARE COMPONENTS

1992 ◽  
Vol 02 (04) ◽  
pp. 567-587 ◽  
Author(s):  
MURALI SITARAMAN
Keyword(s):  
Programming Languages ◽  
Performance Tuning ◽  
Software Components ◽  
Reusable Components ◽  
Reusable Software

Current programming languages support construction of parameterized reusable components that can be adapted and composed to create new functionality. For widespread reuse, software components must also have readily adaptable performance. This paper introduces language mechanisms for creating such performance-parameterized reusable software components and for controlling their performance by "plugging in" appropriate constituent components. A key element of the proposed approach is that it provides inexpensive performance tuning. It permits performance of a tunable component to be changed without modifications to the functionality of the component or its clients; in principle, without the need for re-compilation or re-validation of functionality.

Reuse in Agile Development Process

2020 ◽  
pp. 164-187
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Software Development ◽  
Development Process ◽  
Agile Development ◽  
Reusable Software ◽  
Model Driven ◽  
Development Processes ◽  
Agile Approach ◽  
Similar Solutions ◽  
Agile Software ◽  
Model Driven Approach

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

Software Reuse and Object Technology

2011 ◽  
pp. 77-88
Author(s):  
Jane Fedorowicz ◽  
Denis Lee
Keyword(s):  
Software Reuse ◽  
Systems Development ◽  
Software Systems ◽  
Team Members ◽  
Good Communication ◽  
Reusable Software ◽  
New Information ◽  
Object Technology ◽  
Analysis Design ◽  
Reliable Software

Companies are increasingly requiring that new information systems development projects employ object oriented (OO) analysis, design and programming approaches. The hottest new Web tools and languages have object capabilities built into them. Much of the movement toward the OO paradigm for systems development is based on claims of pioneers and vendors that adoption will lead to better and faster designs, more maintainable systems, and most audibly, reusable software. A typical set of attributions appears in CACM: “OO technology promotes a better understanding of requirements and results in more modifiable and maintainable applications, providing other benefits such as reusability, extensibility, robustness, reliability, and scalability. OO technology promotes better teamwork, good communication among team members, and a way to engineer reliable software systems and applications” (Fayad and Tsai, 1995).

Sign in / Sign up

Export Citation Format

Share Document