Managing software productivity and reuse

Your organization can choose from three main strategies for improving its software productivity. You can work faster, using tools that automate or speed up previously labor-intensive tasks. You can work smarter, primarily through process improvements that avoid or reduce non-value-adding tasks. Or you can avoid unnecessary work by reusing software artifacts instead of custom developing each project. Which strategy will produce the highest payoff? The author performed an extensive analysis that addressed this question for the US Department of Defense. The result of this analysis showed that work avoidance via software reuse produced the highest improvement in software productivity. The article gives advice on how to manage software reuse and the pitfalls to avoid     

How office space affects programming productivity

The relationship between office size and noise level is one of the most significant, yet least investigated, factors affecting software productivity. According to Tom DeMarco and Tim Lister (1992), US programmers with more than 80 square feet of private, noise-free office space consistently outperform programmers who occupy two- or three-person cubicles. The result was the Santa Teresa Programming Laboratory in San Jose, California, which opened in 1978. The author discusses some requirements of an optimal programming office environment. He considers the effectiveness of home working     

Programming methodology,organizational environment,and programming productivity

Programming data involving 278 commercial-type programs were collected from 23 medium- to large-scale organizations in order to explore the relationships among variables measuring program type, the testing interface, programming technique, programmer experience, and productivity. Programming technique and programmer experience after 1 year were found to have no impact on productivity, whereas on-line testing was found to reduce productivity. A number of analyses of the data are presented, and their relationship to other studies is discussed.     

Some issues in the measurement and control of programming productivity

In view of the escalating proportion of data processing expenditure going into software development, the measurement and control of software costs has become an important issue for commercial data processing managers. This paper surveys the state of the art in programming productivity research, investigates the application of research results to e.d.p. management, and suggests ways in which future research efforts can be improved. The apparent inconsistencies in the published literature of the field are high-lighted and some possible explanations for them are advanced.     

Evaluating the productivity of a reference-based programming approach: A controlled experiment

ContextDomain engineering aims at facilitating software development in an efficient and economical way. One way to measure that is through productivity indicators, which refer to the ability of creating a quality software product in a limited period and with limited resources. Many approaches have been devised to increase productivity; however, these approaches seem to suffer from a tension between expressiveness on the one hand, and applicability (or the lack of it) in providing guidance for developers.ObjectiveThis paper evaluates the applicability and efficiency of adopting a domain engineering approach, called Application-based DOmain Modeling (ADOM), in the context of the programming task with Java, and thus termed ADOM-Java, for improving productivity in terms of code quality and development time.MethodTo achieve that objective we have qualitatively evaluate the approach using questionnaires and following a text analysis procedure. We also set a controlled experiment in which 50 undergraduate students performed a Java-based programming task using either ADOM-Java or Java alone.ResultsThe qualitative evaluation reveal that the approach is easy to uses and provides valuable guidance. Nevertheless, it requires training. The outcomes of the experiment indicate that the approach is applicable and that the students that used ADOM-Java achieved better code quality, as well as better functionality and within less time than the students who used only Java.ConclusionThe results of the experiments imply that by providing a code base equipped with reuse guidelines for programmers can increase programming productivity in terms of quality and development time. These guidelines may also enforce coding standards and architectural design.     

Pair programming productivity: Novice–novice vs. expert–expert

Agile Software Development methodologies have grown in popularity both among academic researchers and industrial practitioners. Among the various methodologies or practices proposed, pair programming, which is concerned with two programmers collaborating on design, coding and testing, has become a controversial focus of interest. Even though some success stories have been reported with the use of pair-programming in real software development environment, many people remain rather skeptical of the claims on pair-programming productivity. Previous studies in pair programming have only addressed the basic understanding of the productivity of pairs and they have not addressed the variation in productivity between pairs of varying skills and experience, such as between novice–novice and expert–expert. Statistical productivity measurements reported by different researchers also seem to lead to contradictory conclusions. Until now, the literature has not addressed how those results and experiments were related to each other. In this paper, we propose a controlled experiment called repeat-programming which can facilitate the understanding of relationships between human experience and programming productivity. Repeat-programming can be performed when controversial issues in non-traditional programming methodologies and development productivity need to be investigated into. To illustrate how the proposed empirical experiment can put arguable, divisive problems into perspective, we have examined the productivity in pair programming as a case study. With repeat-programming, we are able to (i) better understand why results of previous pair programming control experiments reached different conclusions as to the productivity of pair programming and (ii) most importantly, present a case in which novice–novice pairs against novice solos are much more productive than expert–expert pairs against expert solos.     

A high‐productivity task‐based programming model for clusters

Programming for large‐scale, multicore‐based architectures requires adequate tools that offer ease of programming and do not hinder application performance. StarSs is a family of parallel programming models based on automatic function‐level parallelism that targets productivity. StarSs deploys a data‐flow model: it analyzes dependencies between tasks and manages their execution, exploiting their concurrency as much as possible. This paper introduces Cluster Superscalar (ClusterSs), a new StarSs member designed to execute on clusters of SMPs (Symmetric Multiprocessors). ClusterSs tasks are asynchronously created and assigned to the available resources with the support of the IBM APGAS runtime, which provides an efficient and portable communication layer based on one‐sided communication. We present the design of ClusterSs on top of APGAS, as well as the programming model and execution runtime for Java applications. Finally, we evaluate the productivity of ClusterSs, both in terms of programmability and performance and compare it to that of the IBM X10 language. Copyright © 2012 John Wiley & Sons, Ltd.     

Managing Interns

Internships help students determine their future career paths while providing companies with creative and energetic contributors who offer fresh perspectives and innovative skills.     

Integrating answer set programming and constraint logic programming

We introduce a knowledge representation language ${\cal AC(C)}$ extending the syntax and semantics of ASP and CR-Prolog, give some examples of its use, and present an algorithm, $\mathcal{AC}\!solver$ , for computing answer sets of ${\cal AC(C)}$ programs. The algorithm does not require full grounding of a program and combines “classical” ASP solving methods with constraint logic programming techniques and CR-Prolog based abduction. The ${\cal AC(C)}$ based approach often allows to solve problems which are impossible to solve by more traditional ASP solving techniques. We believe that further investigation of the language and development of more efficient and reliable solvers for its programs can help to substantially expand the domain of applicability of the answer set programming paradigm.     

Revised multi-segment goal programming: Percentage goal programming

The multi-segment goal programming (MSGP) model is an extension model of GP wherein the core thinking is inherited from the multi-choice goal programming (MCGP) model. In this paper, we recommend certain points of the MSGP model and offer a Revised MSGP Model as an aid to burdened decision makers who cannot expect an either-or selection of coefficients in practice. The proposed model takes into account a scenario in which the selection of all possible coefficients pertaining to each decision variable in the MSGP model can be an in-between selection instead of an exclusive-or selection. We hope this study can fill in a possible gap that might exist when applying the MSGP model, and can offer an extension model for practitioners when they use this model to solve related decision problems.     

Revision programming

In this paper we introduce revision programming — a logic-based framework for describing constraints on databases and providing a computational mechanism to enforce them. Revision programming captures those constraints that can be stated in terms of the membership (presence or absence) of items (records) in a database. Each such constraint is represented by a revision rule ← ₁,…,_k, where and all ga_i are of the form in(a) and out(b). Collections of revision rules form revision programs. Similarly as logic programs, revision programs admit both declarative and imperative (procedural) interpretations. In our paper, we introduce a semantics that reflects both interpretations. Given a revision program, this semantics assigns to any database B a collection (possibly empty) of P-justified revisions of B. The paper contains a thorough study of revision programming. We exhibit several fundamental properties of revision programming. We study the relationship of revision programming to logic programming. We investigate complexity of reasoning with revision programs as well as algorithms to compute P-justified revisions. Most importantly from the practical database perspective, we identify two classes of revision programs, safe and stratified, with a desirable property that they determine for each initial database a unique revision.     

Quasiparallel programming

This paper describes SIMONE, an extension of PASCAL,¹ which provides the quasiparallel programming facility of SIMULA 67, but without classes or references. The language is intended to be suitable for the design, testing and simulation of operating system algorithms. It is illustrated by simple examples, suitable as project material in a course on operating systems. A simple, restricted, but efficient implementation is described. It is suggested that the language might be suitable for more general simulation purposes, and an example of a general job shop simulation is given.     

Revised multi-segment goal programming: Percentage goal programming

The multi-segment goal programming (MSGP) model is an extension model of GP wherein the core thinking is inherited from the multi-choice goal programming (MCGP) model. In this paper, we recommend certain points of the MSGP model and offer a Revised MSGP Model as an aid to burdened decision makers who cannot expect an either-or selection of coefficients in practice. The proposed model takes into account a scenario in which the selection of all possible coefficients pertaining to each decision variable in the MSGP model can be an in-between selection instead of an exclusive-or selection. We hope this study can fill in a possible gap that might exist when applying the MSGP model, and can offer an extension model for practitioners when they use this model to solve related decision problems.     

基于空间的编程

全面地介绍了一种基于空间的中间层编程方法。这是一种以分布式虚拟共享内存为技术基础设施的新型编程方法。其重要性在于它将分布计算的语义环境和问题领域的语义环境在极大程度上相分离 ,从而可以为今天软件体系结构中存在的种种问题提供具有持续可靠性的解决方案。     

Adaptive programming

An adaptive program is one that changes its behavior base on the current state of its environment. This notion of adaptivity is formalized, and a logic for reasoning about adaptive programs is presented. The logic includes several composition operators that can be used to define an adaptive program in terms of given constituent programs; programs resulting from these compositions retain the adaptive properties of their constituent programs. The authors begin by discussing adaptive sequential programs, then extend the discussion to adaptive distributed programs. The relationship between adaptivity and self-stabilization is discussed. A case study for constructing an adaptive distributed program where a token is circulated in a ring of processes is presented     

Mathematical-oriented programming

Two products that transform mathematical expressions into useful results are reviewed. One is Math View Professional version 0.94, a self-contained mathematics application that is capable of performing a nearly encyclopedic range of mathematical, graphical, and statistical operations. The authors briefly summarize the program's features, touch on the manual supplied with the review copy, offer some details about the program, and suggest some future improvements. The other product reviewed is MathCAD 2.0 which allows free-form mathematical expressions to be entered in much the say way as text is entered into a word processor. These packages provide tools for the non-computer-oriented problem solver     

Immune programming

This paper describes ‘Immune Programming’, a paradigm in the field of evolutionary computing taking its inspiration from principles of the vertebrate immune system. These principles are used to derive stack-based computer programs to solve a wide range of problems.An antigen is used to represent the programming problem to be addressed and may be provided in closed form or as an input/output mapping. An antibody set (a repertoire), wherein each member represents a candidate solution, is generated at random from a gene library representing computer instructions. Affinity, the fit of an antibody (a solution candidate) to the antigen (the problem), is analogous to shape-complementarity evident in biological systems. This measure is used to determine both the fate of individual antibodies, and whether or not the algorithm has successfully completed.When a repertoire has not yielded affinity relating algorithm completion, individual antibodies are replaced, cloned, or hypermutated. Replacement occurs according to a replacement probability and yields an entirely new randomly-generated solution candidate when invoked. This randomness (and that of the initial repertoire) provides diversity sufficient to address a wide range of problems. The chance of antibody cloning, wherein a verbatim copy is placed in the new repertoire, occurs proportionally to its affinity and according to a cloning probability. The chances of an effective (high-affinity) antibody being cloned is high, analogous to replication of effective pathogen-fighting antibodies in biological systems. Hypermutation, wherein probability-based replacement of the gene components within an antibody occurs, is also performed on high-affinity entities. However, the extent of mutation is inversely proportional to the antigenic affinity. The effectiveness of this process lies in the supposition that a candidate showing promise is likely similar to the ideal solution.This paper describes the paradigm in detail along with the underlying immune theories and their computational models. A set of sample problems are defined and solved using the algorithm, demonstrating its effectiveness and excellent convergent qualities. Further, the speed of convergence with respect to repertoire size limitations and probability parameters is explored and compared to stack-based genetic programming algorithms.