152,210 research outputs found
The PARSE Programming Paradigm. Part I: Software Development Methodology. Part II: Software Development Support Tools
The programming methodology of PARSE (parallel software environment), a software environment being developed for reconfigurable non-shared memory parallel computers, is described. This environment will consist of an integrated collection of language interfaces, automatic and semi-automatic debugging and analysis tools, and operating system —all of which are made more flexible by the use of a knowledge-based implementation for the tools that make up PARSE. The programming paradigm supports the user freely choosing among three basic approaches /abstractions for programming a parallel machine: logic-based descriptive, sequential-control procedural, and parallel-control procedural programming. All of these result in efficient parallel execution. The current work discusses the methodology underlying PARSE, whereas the companion paper, “The PARSE Programming Paradigm — II: Software Development Support Tools,” details each of the component tools
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
Middleware Component Using Enterprise Java Bean (EJB)
Component-based software development promises to decrease software
development and maintenance costs and also providing sophisticated facilities for
software reuse. A component is a chunk of software that provides functionality
such as login validation, customer transaction and calculation [3]. It is
encapsulated which means, that it can only be accessed via its interface and can be
combined with other systems [3]. Most of these characteristics are derived from
object oriented development.
Therefore this paper presents an overview and development of component based
software using J2EE framework called Enterprise Java Bean (EJB). The aim of this
proj ect is at capturing the middleware concept using EJB where this architecture
provides loose coupling of presentation layer and business logic. Moreover, leads
Having two different clients connecting to a single middleware component which resides in the container of J2EE Server. The details about design and development
of this middleware component and testing this component on to a test bed called
bookstore application is the heart of this project. This paper will also introduce
about the advantage of EJB against distributed component model and the
interoperability of this middleware component across different platform and
programming languages
Web-centred end-user component modelling
This paper formally defines a web component model enabling end-user programmers to build
component-based rich internet applications (RIAs) that are tailored to meet their particular needs. It is
the product of a series of previously published papers. The formal definition in description logic verifies
that the model is consistent and subsumes currently existing models. We demonstrate experimentally
that it is more effective than the others.
Current tools propose very disparate web component models, which are based on the appropriate
invocation of service backends, overlooking user needs in order to exploit these services and resources in
a friendly manner. We have proposed a web model based on a detailed study of existing tools, their pros
and cons, limitations and key success factors that have enabled other web end-user development (WEUD)
solutions to help end-user programmers to build software to support their needs. In this paper we have
verified that the proposed model subsumes and is instantiated by the models of the other existing tools
that we analysed, coming a step closer to the standardization of end-user centred RIAs and development
environments. We have implemented a development tool, called EzWeb, to produce RIAs that implement
the proposed model. This tool enables users to develop their application following the model’s component
structure based on end-user programming success factors. We report a statistical experiment in which
users develop increasingly complex web software using the EzWeb tool generating RIAs that conform to
the proposed component model, and other WEUD tools generating RIAs that conform to other models.
This experiment confirms the applicability of the proposed model and demonstrates that more enduser
programmers (EUPs) (users concerned with programming primarily for personal rather public use)
successfully develop web solutions for complex problems using the EzWeb tool that implements the
model, which is more efficient than existing tools that implement other models
Asynchronous Validations using Programming Contracts in Java
Design by Contract is a software development methodology based on the idea of having contracts between two software components. Programming contracts are invariants specified as pre-conditions and post-conditions. The client component must ensure that all the pre-conditions are satisfied before calling the server component. The server component must guarantee the post-conditions are met before the call returns to the client component. Current work in Design by Contract in Java focuses on writing shorthand contracts using annotations that are processed serially.
Modern software systems require a lot of business rules validations on complicated domain objects. Often, such validations are in the form of a chain of independent tasks that need to be validated one after another. These tasks are computation-intensive and often involve numerous database calls and API calls over the web.
This paper presents a validation rule engine framework, Rule4j to facilitate writing such business rules with the help of programming contracts in Java. The contracts are organized in a hierarchy similar to the Racket programming language. The programmer can specify the business rules in the form of a series of higher-order contracts that form a chain. These chains of contracts are validated concurrently and asynchronously to present a final validation result to the programmer. A sample scenario of trade execution is used to demonstrate the performance gain and maintainability of the framework. The experiments conducted show that validations executed using Rule4J run four times faster than the traditional approach. A clear separation of business logic and business validations for the trade execution scenario was achieved using Rule4J
- …