127,510 research outputs found
Generative Software Engineering
Researching evermore abstract and powerful ways of composing programs is the meat of software engineering for half a century. Important early steps were subroutines (to encapsulate actions) and records (to encapsulate data). A large step forward came with the introduction of the object-oriented concepts (classes, subclasses and virtual methods) where classes can encapsulate both data and behaviors in a very powerful, but still flexible, way. For a long time, these concepts dominated the scene, but eventually the need for additional concepts became apparent. In this chapter, we focus on model driven engineering MDE, which complement and leverage other mechanism such generic constructs, aspect oriented programming AOP, component based software development CBSE, generative programming, domain specific languages
Domain-Driven Development: the SmartTools Software Factory
With the increasing dependency on the Internet and the proliferation of new component and distributive technologies, the design and implementation of complex applications must take into account standards, code distribution, deployment of components and reuse of business logic. To cope with these changes, applications need to be more open, adaptable and capable of evolving. To accommodate to these new challenges, this paper presents a new development approach based on generators associated with domain-specific languages, each of the latter related to one possible concern useful when building an application. It relies on Generative Programming, Component Programming and Aspect-Oriented Programming. A software factory, called SmartTools , has been developed using this new approach. The main results are i) to build software of better quality and to enable rapid development due to Generative Programming and, ii) to facilitate insertion of new facets and the portability of applications to new technologies or platforms due to business logic and technology separation
"Field Manager" Application Package
One of the important problems in the development of Decision Support Systems regards the issue of designing and implementation of man-machine interface. Importance of this component of the DSS follows from the fact that the end-user is usually not a computer specialist and, therefore, even the most useful decision-theoretic framework will be rejected if communication with the computer is too difficult for him. From the other side, design and implementation of user interface requires a lot of experience from the system designer, big resources for programming and a long time for for debugging and coding. Therefore, every attempt to simplify this aspect of DSS design and development is important.
In this paper the software package Field Manager is presented. This package allows easy and quick development of user interfaces. The design is based on two novel ideas in the field of software management -- the abstract data type approach and object-oriented software specification. The package has been applied in several practical applications and the collected experience has shown its effectiveness and simplicity
Evaluation and Determination of Integration Orders in Component-based Embedded Systems
Vestavěné počítačové systémy jsou stále složitější. Jedním ze způsobů, jak tuto složitost zvládnout, je komponentově založený přístup, kdy systémy jsou postaveny z jednotlivých nezávislých SW komponent. Důležitým aspektem stavby systému je jeho softwarová integrace. Klíčovým bodem integrace je pořadí, ve kterém jsou komponenty kombinovány do výsledného celku. Dosavadní vědecké práce v dané oblasti dávají pouze hrubá doporučení a spoléhají se na zkušenost návrháře. V disertační práci jsou identifikovány parametry sofwarového integračního procesu a dále je navržen optimaliyační proces, který vede k nalezení integračního pořadí, které vyžaduje nejmenší čas a náklady.Katedra informatiky a výpočetní technikyObhájenoEmbedded software systems are getting more and more complex. One answer to handle this complexity is component-based development, in which systems are built of individual independent software components. One important aspect of the component-based development approach is software integration. Individual components have to be put together and their interactions have to be verified. The crucial point of integration is the order in which components are combined. State-of-the-art approaches are only coarse guidelines and rely strongly on integrators expertise. More elaborate methods in which an algorithm is used to derive an integration order are only available for object-oriented software and cannot be directly used in procedural programming languages. To deal with these challenges, parameters are identified the software integration process is subjected to and metrics are developed in order to evaluate a certain integration order. Furthermore, an optimization approach based on simulated annealing is presented which is used to derive an integration order with respect to the proposed parameters in a powerful and reliable manner
An ontology of agile aspect oriented software development
Both agile methods and aspect oriented programming (AOP) have emerged in recent years as new paradigms in software development. Both promise to free the process of building software systems from some of the constraints of more traditional approaches. As a software engineering approach on the one hand, and a software development tool on the other, there is the potential for them to be used in conjunction. However, thus far, there has been little interplay between the two. Nevertheless, there is some evidence that there may be untapped synergies that may be exploited, if the appropriate approach is taken to integrating AOP with agile methods. This paper takes an ontological approach to supporting this integration, proposing ontology enabled development based on an analysis of existing ontologies of aspect oriented programming, a proposed ontology of agile methods, and a derived ontology of agile aspect oriented development
Early aspects: aspect-oriented requirements engineering and architecture design
This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications
Recommended from our members
Towards an aspect weaving BPEL engine
This position paper proposes the use of dynamic aspects and
the visitor design pattern to obtain a highly configurable and
extensible BPEL engine. Using these two techniques, the
core of this infrastructural software can be customised to
meet new requirements and add features such as debugging,
execution monitoring, or changing to another Web Service
selection policy. Additionally, it can easily be extended to
cope with customer-specific BPEL extensions. We propose
the use of dynamic aspects not only on the engine itself
but also on the workflow in order to tackle the problems of
Web Service hot deployment and hot fixes to long running
processes. In this way, composing aWeb Service "on-the-fly"
means weaving its choreography interface into the workflow
Aspect-Oriented Programming
Aspect-oriented programming is a promising idea that can improve the quality of software by reduce the problem of code tangling and improving the separation of concerns. At ECOOP'97, the first AOP workshop brought together a number of researchers interested in aspect-orientation. At ECOOP'98, during the second AOP workshop the participants reported on progress in some research topics and raised more issues that were further discussed. \ud
\ud
This year, the ideas and concepts of AOP have been spread and adopted more widely, and, accordingly, the workshop received many submissions covering areas from design and application of aspects to design and implementation of aspect languages
An overview of Mirjam and WeaveC
In this chapter, we elaborate on the design of an industrial-strength aspectoriented programming language and weaver for large-scale software development. First, we present an analysis on the requirements of a general purpose aspect-oriented language that can handle crosscutting concerns in ASML software. We also outline a strategy on working with aspects in large-scale software development processes. In our design, we both re-use existing aspect-oriented language abstractions and propose new ones to address the issues that we identified in our analysis. The quality of the code ensured by the realized language and weaver has a positive impact both on maintenance effort and lead-time in the first line software development process. As evidence, we present a short evaluation of the language and weaver as applied today in the software development process of ASML
- …