Software development predictors, error analysis, reliability models and software metric analysis

The use of dynamic characteristics as predictors for software development was studied. It was found that there are some significant factors that could be useful as predictors. From a study on software errors and complexity, it was shown that meaningful results can be obtained which allow insight into software traits and the environment in which it is developed. Reliability models were studied. The research included the field of program testing because the validity of some reliability models depends on the answers to some unanswered questions about testing. In studying software metrics, data collected from seven software engineering laboratory (FORTRAN) projects were examined and three effort reporting accuracy checks were applied to demonstrate the need to validate a data base. Results are discussed

Dynamic slicing of aspect oriented programs

As software application grows larger and become more complex, program maintenance activities such as adding new functionality, debugging and testing consume increasing amount of available resources for software development. In order to cope with this increased complexity, programmer need effective computer supported methods for decomposition and dependence analysis of programs. Program slicing is one method for such decomposition and dependence analysis. Program slicing is a decomposition technique which extracts program elements related to a particular computation from a program. A program slice consists of those parts of a program that may directly or indirectly affect the values computed at some program point of interest, referred to as a slicing criterion. A program slice can be static or dynamic. Static slice contains all the statements that may affect the slicing criterion for every possible inputs to the program. Dynamic slice contains only those statements that actually affect the slicing criterion for a particular input to the program. Aspect-oriented programming is a new programming technique proposed for cleanly modularizing the cross- cutting structure of concerns. An aspect is an area of concern that cuts across the structure of a program. The main idea behind aspect-oriented programming (AOP) is to allow a program to be constructed by describing each concern separately. Aspect J is an aspect-oriented extension to the Java programming language. Aspect J adds new concepts and associated constructs called join points, pointcuts, advices, introductions, and aspects to Java. Zhao developed the aspect-oriented system dependence graph (ASDG) to represent aspect-oriented programs and used two-pass slicing algorithm to compute static slice of aspect-oriented programs. But the disadvantage of his ASDG is that the weaving process is not represented correctly and this graph cannot be used for dynamic slicing. Our objective was to develop a suitable intermediate representation of an aspectoriented program and to develop suitable dynamic slicing technique

A dynamic failure model for performing propagation and infection analysis on computer programs

This thesis introduces a methodology for determining program locations where faults can easily hide. It is a program structure-based model that analyzes program flow both statically and dynamically; each program location is analyzed relative to its preceding locations and succeeding locations. A statistical model termed propagation analysis studies the relation between incorrect internal data states and their affect on the output. Infection analysis is a statistically model which studies the relation between classes of faults and internal data states. Together these two models combine to form one model of analyzing programs termed Propagation and Infection Analysis (PIA).;PIA employs aspects of both software testing methods and verification techniques. The results of PIA distinguish it from traditional verification efforts however. Verification compares a program with its specification. The ultimate goal of verification is to show the program with its specification. The ultimate goal of verification is to show the program is correct with respect to its specification. PIA characterizes a program in terms of how its failure behavior will be impacted by the presence of faults at various locations. A location which minimally impacts the failure behavior is called fault insensitive. The goal of PIA is to identify fault insensitive location. Since program correctness, safety, and reliability are all intricately connected to the presence (or absence) of faults in the code, PIA therefore provides information useful in quantifying the effectiveness of other verification activities.;The implementation of the propagation and infection analysis model is performed through dynamic executions of the program. Propagation analysis quantifies the impacts on a program after its internal data states have been altered; infection analysis quantifies the impacts on internal data states that common faults have once injected at program locations. The statistics gathered from both altered data states and altered locations are then used to make predictions about expected program behavior if a fault were there.;Models are also provided for applying the results from propagation and infection analysis to a variety of applications dealing with software quality assurance. These include software complexity, debugging, software testing, software reliability, software security, and probable correctness

Automatic marking of Shell programs for students coursework assessment

The number of students in any programming language course is usually large; more than 100 students is not uncommon in some universities. The member of staff teaching such a course has to mark, perhaps weekly, a very large number of program assignments. Manual marking and assessing is therefore an arduous task. The aim of this work is to describe a computer system for automatic marking and assessment of students' programs written in Unix Bourne Shell. In this study, a student's program will be assessed by testing its dynamic correctness and its maintainability. For dynamic correctness to be checked the program will be run against sets of input data supplied by the teacher, whereas for maintainability the student's program will be tested statically. The program text will be analysed, and its typographic style and its complexity measured. The typographic assessment in this system is adaptable to reflect the change of emphasis as a course progresses. This study presents the results generated from the assessment of a typical class of students in a Shell programming course. The experience with the development of the typographic assessment system has been generally positive. The results have shown that it is feasible to automate the assessment of this quality factor, as well as dynamic testing. Realistic grading can be achieved and useful information feedback can be obtained. The system is useful to both the students learning programming in Shell, (Arthur, L. J. and Burns, T., 1996) and the staff who are teaching the course. Although the work here is focused on the Bourne Shell, (Bourne, S. R., 1987) the study is still valid, with little or no change, to all other shells. The method used can also be applied, with some modification, to other programming languages. Furthermore this method is not limited to university and teaching, it can also be used in other fields for the purposes of software quality assessment

Reducing Complexity of Java Source Codes in Structural Testing by Using Program Slicing

Structural testing is one of the techniques of software testing. It tests only the structure of the source code while comparing expected results and actual results. Generally, structural testing takes a long time to perform its task and not possible. Sometimes, only a small portion of the program is relevant. This can be done by program slicing. Program Slicing is to decompose the program into smaller units that depends on different types of dependencies between the program statements. The different types of program slicing are forward slicing, backward slicing, complete slicing, dynamic and static slicing, etc. Moreover, there is Tree Slicing which is also a key technique to slice and merge different Symbolic Execution (SE) sub-trees under some specific conditions.  In this paper, we combine Tree Slicing technique and Indus Kaveri where Indus is a robust framework for analyzing and slicing concurrent Java programs, and Kaveri is a feature-rich Eclipse-based GUI front end for Indus slicing. Then we present the experimental results in order to reduce the complexity of the java source code