173,068 research outputs found
An empirical study evaluating depth of inheritance on the maintainability of object-oriented software
This empirical research was undertaken as part of a multi-method programme of research to investigate unsupported claims made of object-oriented technology. A series of subject-based laboratory experiments, including an internal replication, tested the effect of inheritance depth on the maintainability of object-oriented software. Subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of three levels of inheritance depth and equivalent object-based software with no inheritance. This was then replicated with more experienced subjects. In a second experiment of similar design, subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of five levels of inheritance depth and the equivalent object-based software. The collected data showed that subjects maintaining object-oriented software with three levels of inheritance depth performed the maintenance tasks significantly quicker than those maintaining equivalent object-based software with no inheritance. In contrast, subjects maintaining the object-oriented software with five levels of inheritance depth took longer, on average, than the subjects maintaining the equivalent object-based software (although statistical significance was not obtained). Subjects' source code solutions and debriefing questionnaires provided some evidence suggesting subjects began to experience diffculties with the deeper inheritance hierarchy. It is not at all obvious that object-oriented software is going to be more maintainable in the long run. These findings are sufficiently important that attempts to verify the results should be made by independent researchers
A Metrics-based Framework for Estimating the Maintainability of Object-Oriented Software
Time, effort and money required in maintaining software has always been considered greater than its development time. Also, its ambiguity in forecast at early stage of software development makes the process more complicated. The early estimation of maintainability will significantly help software designers to adjust the software product, if there is any fault, in early stages of designing. By doing this; time, effort and money required in maintaining software will be lessened. Although Object Oriented Software Development (OOSD) approach is equipped for enhancing software maintainability, a method for finding out if the required level of maintenance is being achieved amid the development process is required. This can be accomplished through measurement. This paper outlines the need and importance of maintainability at design phase and develops a Metrics-Based Maintainability Estimation Framework for Object-Oriented software(MEFOOS) that estimates the maintainability of object oriented software components in regard of their Understandability, Modifiability and Portability—which are the sub-attributes of maintainability. Keywords: Software maintenance, Software Maintainability, maintainability model, Software Metrics, Software Component DOI: 10.7176/JIEA/9-4-02 Publication date:June 30th 201
Defining the Fluid framework
In this position paper we present the developing Fluid framework, which we believe offers considerable advantages in maintaining software stability in dynamic or evolving application settings. The Fluid framework facilitates the development of component software via the selection, composition and configuration of components. Fluid's composition language incorporates a high-level type system supporting object-oriented principles such as type description, type inheritance, and type instantiation. Object-oriented relationships are represented via the dynamic composition of component instances. This representation allows the software structure, as specified by type and instance descriptions, to change dynamically at runtime as existing types are modified and new types and instances are introduced. We therefore move from static software structure descriptions to more dynamic representations, while maintaining the expressiveness of object-oriented semantics. We show how the Fluid framework relates to existing, largely component based, software frameworks and conclude with suggestions for future enhancements. © 2007 IEEE
Concepts for slicing object-oriented programs
This paper proposes several concepts that form the basis for slicing object-oriented programs. In the case of object-oriented languages, new relations occur between language constructs such as classes, methods, and messages. Thus new forms of dependencies have to be considered in addition to the traditional control and data dependencies that form the basis of most software maintenance tools that are currently available for maintaining procedure-oriented programs. We show how the proposed slicing concepts can be applied within the software maintenance process by giving an illustration through an example of Java program
IMPLEMENTASI FRAMEWORK SPRING MVC UNTUK PEMBUATAN SISTEM INFORMASI MANAJEMEN E COMMERCE
Mudzakkir Toha. 2010. IMPLEMENTASI FRAMEWORK SPRING MVC
UNTUK PEMBUATAN SISTEM INFORMASI MANAJEMEN E
COMMERCE. The Implementation of Spring MVC Framework to Create
an E Commerce Information Management System. Computer Science
Pregraduate Program. Information Engineering. Mathematics and Natural
Sciences Faculty. Sebelas Maret University.
Object oriented technology is recent of analysis in application software
development computer based. The old way of software development is structured
programming, that is not reusable.
One way of modeling technology object oriented programming is using
UML (Unified Modeling Language). UML have become standard language for
modelling of object oriented system in world. MVC architecture will assist of
application maintaining. MVC architecture caused application more easy and
structured.
Has created an application that implementing the MVC concept.
Keyword : JEE 5, Spring MVC, Hibernate JPA
IMPLEMENTATION OF A LOCALIZATION-ORIENTED HRI FOR WALKING ROBOTS IN THE ROBOCUP ENVIRONMENT
This paper presents the design and implementation of a human–robot interface capable of evaluating robot localization performance and maintaining full control of robot behaviors in the RoboCup domain. The system consists of legged robots, behavior modules, an overhead visual tracking system, and a graphic user interface. A human–robot communication framework is designed for executing cooperative and competitive processing tasks between users and robots by using object oriented and modularized software architecture, operability, and functionality. Some experimental results are presented to show the performance of the proposed system based on simulated and real-time information. </jats:p
The object binary interface: C++ objects for evolvable shared class libraries
Object-oriented design and object-oriented languages support the development of independent software components such as class libraries. When using such components, versioning becomes a key issue. While various ad-hoc techniques and coding idioms have been used to provide versioning, all of these techniques have deficiencies - ambiguity, the necessity of recompilation or re-coding, or the loss of binary compatibility of programs. Components from different software vendors are versioned at different times. Maintaining compatibility between versions must be consciously engineered. New technologies such as distributed objects further complicate libraries by requiring multiple implementations of a type simultaneously in a program. This paper describes a new C++ object model called the Shared Object Model for C++ users and a new implementation model called the Object Binary Interface for C++ implementors. These techniques provide a mechanism for allowing multiple implementations of an object in a program. Early analysis of this approach has shown it to have performance broadly comparable to conventional implementations
Checking semantics in UML models
Modeling is one of the most crucial activities during all the phases in any software development life cycle. Typically, system development is a very complex task, and working with models helps to handle this complexity in an organized way, allowing us to reason about the properties that entities possess. In software engineering, notation, techniques and methodology for object-oriented model building has been lately the focus of active research work. In the case of object-oriented software development, models are composed by a number of communicating and well delimited elements. Although such models are sometimes harder to develop, they are easier to understand, and simpler to maintain and modify.Thus, reusability of elements among models is enhanced. In order to maximize these properties, we need tools that support the process of object- oriented development by serving as repository of previously asserted knowledge, checking the integrity of the model and maintaining the different views that form each model. Consequently, it is expected this automatic control will reduce the manual, error-prone work of maintaining model consistency across all life cycle phases.
UML, Unified Modeling Language is a graphical language for visualizing, specifying, constructing and documenting the elements of a software intensive system. UML provides notation for expressing the model, in the form of graphic and text elements. Attached to these elements, there is a semantic interpretation that attempts to capture the meaning of the model, and it is represented by the constraint mechanism. Constraints are one of the three extensibility mechanisms that UML introduces, although currently the language for expressing them is not standard (natural language or OCL can be used for this purpose). Supporting tools for object oriented development in UML should not only provide a graphic editor for the notation, but also help to ensure the coherence of its semantics aspects. This research line attempts to formalize the consistency check process in UML models.Eje: Ingeniería de SoftwareRed de Universidades con Carreras en Informática (RedUNCI
The Extension of Object-Oriented Languages to a Homogenous, Concurrent Architecture
A homogeneous machine architecture, consisting of a regular
interconnection of many identical elements, exploits the economic benefits of VLSI technology, A concurrent programming model is presented that is related to object oriented languages such as Simula and Smalltalk.
Techniques are developed which permit the execution of general purpose object oriented programs on a homogeneous machine. Both the hardware architecture and the supporting software algorithms are demonstrated to scale their performance with the size of the system.
The program objects communicate by passing messages. Objects may move about in the system and may have an arbitrary pointer topology, A
distributed, on-the-fly garbage collection algorithm is presented which
operates by message passing. Simulation of the algorithm demonstrates its
ability to collect obsolete objects over the entire machine with acceptable
overhead costs. Algorithms for maintaining the locality of object references
and for implementing a virtual object capability are also presented.
To insure the absence of hardware bottlenecks, a number of
interconnection strategies are discussed and simulated for use in a
homogeneous machine. Of those considered, the Boolean N-cube connection
is demonstrated to provide the necessary characteristics.
The object oriented machine will provide increased performance as its
size is increased. It can execute a general purpose, concurrent, object
oriented language where the size of the machine and its interconnection
topology are transparent to the programmer
Maintaining software through intentional source-code views
Maintaining the source code of large software systems is hard. One underlying cause is that existing modularisation mechanisms are inadequate to handle crosscutting concerns. We propose intentional source-code views as an intuitive and lightweight means of modelling such concerns. They increase our ability to understand, modularise and browse the source code by grouping together source-code entities that address the same concern. They facilitate software development and evolution, because alternative descriptions of the same intentional view can be checked for consistency and relations among intentional views can be defined and verified. Finally, they enable us to specify knowledge developers have about source code that is not captured by traditional program documentation mechanisms. Our intentional view model is implemented in a logic metaprogramming language that can reason about and manipulate object-oriented source code directly. The proposed model has been validated on the evolution of a medium-sized object-oriented application in Smalltalk, and a prototype tool has been implemented
- …