L. Ungar

Bio: L. Ungar is an academic researcher. The author has contributed to research in topics: Middleware & Common Object Request Broker Architecture. The author has an hindex of 2, co-authored 2 publications receiving 38 citations.

Component assembly for OO distributed systems

Abstract: Software development that assembles prefabricated components faces different challenges than development that starts from scratch with programming constructs. For example, it is often impossible, or at least not economical, to change the source code of components from independent suppliers. But how do you assemble the components without doing that? How do you link them with the services they require? And how do you build a distributed system and ensure system-wide security, performance, and fault tolerance without breaking the system? These are just some of the issues that designers face when using prefabricated components in a distributed system. Object-oriented distributed systems pose some specific problems. Objects communicate by invoking methods on other objects, so they must maintain static information, such as class or interface names. Thus, objects may have strong dependencies, not only on each other but also on outside services. Distributed systems built from prefabricated components require an assembly approach that separates architecture, component, and distributed object infra-structure concerns.

A framework supporting component assembly for distributed systems

Abstract: Software development by assembling pre-fabricated components faces different challenges from software development using programming language-level constructs. This is especially true for distributed software systems. In this paper, we briefly discuss these challenges and propose a solution. Our suggested solution advocates the separation of three levels of concern: the architectural level, the component level, and the distributed object infrastructure level. A framework is proposed to facilitate the transitions between the three levels of concern. In this framework a set of Ports and Links is designed to enable separation of core component functionality from intercomponent communications. Ports are erred to handle incoming/outgoing service requests or events; links are used to deal with communications using communication protocols or middleware. In particular, Links are specialized into various styles, including local style, CORBA IIOP style, Java RMI style, and TCP Socket style, and on the abstraction level, vary from plain links to autonomously intelligent links taking full advantages of services provided by specific middleware such as CORBA services. Due to this separation, the reusability of components is substantially increased and the flexibility of software systems composed from components can be improved. A JavaBeans implementation is described with the Property Descriptor and BeanInfo features of the JavaBeans extended to give explicit information about component boundary information, particularly the Ports.

Method and system for assembling and utilizing components in component object systems

Abstract: A design tool for assembling component objects to form an object-based computer system application includes a declarative user input interface mechanism and a design engine. The declarative user input interface mechanism provides an input structure for the input of user declarations specifying operative interactions between component objects. The design engine automatically generates, in response to input user declarations, an application design definition modelling an application infrastructure for managing component object interactions. An application design definition can reference a number of application view definitions, each having a number of fields, each field having associated therewith an application view field definition. An operation usage definition defines an effect a component object operation has on one or more of the application view definitions in response to user input declarations. An event definition defines an operation usage triggered by an application view definition event in response to input user declarations. The design engine automatically generates, in response to input user declarations, a match between an application view field definition and a parameter of an associated component object operation. A runtime tool includes an application engine which is responsive to an application design definition and is operative at runtime automatically to create application view instances from respective application view definitions for managing runtime component object interactions for the application.

PORE : Procurement Oriented Requirements Engineering Method for the Component-Based Systems Engineering Development Paradigm

Abstract: Most current research in Component-Based Systems Engineering (CBSE) focuses on design and integration processes. There is little interest in the requirements engineering and product evaluation/selection processes that must precede design and integration. Also most current methods and tools support systems design and integration but neglect the requirements engineering and product evaluation/selection processes. However, in spite of this lack of focus on requirements engineering, a consensus seems to be emerging that the CBSE development process should be an iterative one of requirements engineering, systems design, product evaluation/selection and systems integration. This paper proposes a new method, PORE, to address the lack of requirements engineering methods and product evaluation/selection process guidance for the CBSE process. The paper ends with a ‘vision’ for future research directions for component-based systems engineering development process.

Architecture paradigms and their influences and impacts on component-based software systems

Abstract: Object-oriented architecture (OOA), component-based architecture (CBA), and service-based architecture (SBA) represent three technical architecture paradigms in current software systems object, component, and service are three key concepts in distributed software systems From implementation point of view, a service is implemented by one or more components, which in turn are often implemented in object-oriented programming languages like C+ + and Java Distributed component-based software systems can be structured in any of the architecture paradigms, some have more advantages than others depending on business requirements Understanding the characteristics, features, benefits, and concerns of the architecture paradigms is crucial to the successful design, implementation and operation of a distributed system In this paper, we describe the characteristics of the three architecture paradigms and the business drivers for their applications The parallel evolution of architecture paradigms and software development methodologies is discussed in the context of practical business needs Component-based software developers for distributed systems should decide on the architecture paradigms based on business requirements The evolution of architecture paradigms and the selection of architecture paradigms have profound influences and impacts on component-based distributed systems, in the way components are designed and in the way component interactions are implemented We discuss these influences and impacts with the goal of deriving some practical principles and strategies to best deal with them in software engineering practices

Integration in component-based software development using design patterns

Abstract: Component based development is promising in improving software development productivity and software quality by reusing existing well tested software components. However, one of the challenges of component based development is how to integrate various components in software systems. An approach is presented to apply design patterns to component integration. This approach uses a formal design pattern representation and a design pattern instantiation technique of automatic generation of component wrapper from design patterns.

Interaction-oriented programming

Abstract: This paper describes a new approach to the production of robust software. We first motivate the approach by explaining why the two major goals of software engineering--correct software and reusable software--are not being addressed well by the current state of software practice. We then describe a methodology based on active, cooperative, and persistent software components, i.e., agents, and show how the methodology produces robust and reusable software. We derive requirements for the structure and behavior of the agents, and report on preliminary experiments on applications based on the methodology. We conclude with a roadmap for development of the methodology and ruminations about uses for the new computational paradigm.