Object-oriented Application Framework Research Articles

EXAF: A search engine for sample applications of object-oriented framework-provided concepts

Context: Object-oriented application frameworks, such as Java Swing, provide reusable code and design for implementing domain-specific concepts, such as Context Menu, in software applications. Hence, use of such frameworks not only can decrease the time and the cost of developing new software applications, but also can increase their maintainability. However, the main problems of using object-oriented application frameworks are their large and complex APIs, and often incomplete user manuals. To mitigate these problems, developers often try to learn how to implement their desired concepts from available sample applications. Nonetheless, this introduces another hard and time-consuming challenge which is finding proper sample applications.Objective: To address this difficulty, we introduce EXAF (EXample Applications Finder) that helps developers find sample applications which implement their desired framework-provided concepts.Method: The majority of existing framework comprehension approaches can only help programmers to get familiar with the usage of particular fine-grained API elements of the desired framework such as its classes and methods. Nevertheless, our approach is able to find sample applications that implement a particular framework-provided concept. To this end, EXAF benefits from the Latent Semantic Indexing (LSI) information retrieval technique. We evaluated the approach using 24 concepts on top of the Microsoft .Net, Qt, and Java Swing frameworks.Results: Based on our evaluations, the precision of EXAF is more than 79%. Besides, it can find some sample applications that could not be found by common code search engines such as the ones which are used in SourceForge and Google Code.Conclusions: The results of our evaluations indicate that EXAF is effective in practice, and yields better search results because it considers various artifacts of a project like user reviews and bug reports.

BioInt: an integrative biological object-oriented application framework and interpreter.

BioInt, a biological programming application framework and interpreter, is an attempt to equip the researchers with seamless integration, efficient extraction and effortless analysis of the data from various biological databases and algorithms. Based on the type of biological data, algorithms and related functionalities, a biology-specific framework was developed which has nine modules. The modules are a compilation of numerous reusable BioADTs. This software ecosystem containing more than 450 biological objects underneath the interpreter makes it flexible, integrative and comprehensive. Similar to Python, BioInt eliminates the compilation and linking steps cutting the time significantly. The researcher can write the scripts using available BioADTs (following C++ syntax) and execute them interactively or use as a command line application. It has features that enable automation, extension of the framework with new/external BioADTs/libraries and deployment of complex work flows.

Comparing complexity of API designs

Embedded, textual DSLs are often provided as an API wrapped around object-oriented application frameworks to ease framework integration. While literature presents claims that DSL-based application development is beneficial, empirical evidence for this is rare. We present the results of an experiment comparing the complexity of three different object-oriented framework APIs and an embedded, textual DSL. For this comparative experiment, we implemented the same, non-trivial application scenario using these four different APIs. Then, we performed an Object-Points (OP) analysis, yielding indicators for the API complexity specific to each API variant. The main observation for our experiment is that the embedded, textual DSL incurs the smallest API complexity. Although the results are exploratory, as well as limited to the given application scenario and a single embedded DSL, our findings can direct future empirical work. The experiment design is applicable for similar API design evaluations.

Mining Text with Pimiento

To perform analysis, decision-making, and knowledge management tasks, information systems use an increasing amount of unstructured information in the form of text. This data influx, in turn, has spawned a need to improve the text-mining technologies required for information retrieval, filtering, and classification. This article compares some of the options available. In particular, the authors focus on Pimiento, a new object-oriented application framework that lets developers create distributed applications that use machine-learning and statistical techniques to automatically process documents

Object-oriented application framework for IEEE 1451.1 standard

The National Institute of Standards and Technology (NIST), Gaithersburg, MD, smart sensor project focuses on the development and support of the IEEE 1451 Smart Transducer Interface Standard for Sensors and Actuators. One of the main objectives of this project is to provide reference implementations and applications of the IEEE 1451 family of standards. This paper describes an object-oriented application framework for the IEEE 1451.1 standard. This framework consists of four layers-the operating system, middleware and tools, the 1451.1 layer, and the application layer. The 1451.1 layer focuses on the class hierarchy of the IEEE 1451.1 standard. It consists of the neutral model and middleware-based 1451.1 model. The application layer focuses on the application system design that is the composition or aggregation among the objects of the 1451.1 application systems. The initial implementation of the object-oriented application framework for IEEE 1451.1 is provided using the Unified Modeling Language (UML) tools and Adaptive Communication Environment (ACE) middleware. The wastewater treatment system is used as an example to initially customize this framework. IEEE 1451.1 application developers can customize their specific applications with the help of this framework, and the time-to-market for 1451.1 applications can be reduced significantly.

Formal verification of real-time embedded software in an object-oriented application framework

With the rapid escalation in design complexity of real-time embedded software, application frameworks have become an almost indispensable tool because they greatly ease the work of a designer by performing tedious tasks on behalf of a designer and by reusing semi-complete application codes. To ensure code quality and reliability, computer-aided analysis is also performed for the generated application software in some frameworks. However, when the target is real-time embedded systems, the correctness of the software in terms of satisfying all user-given real-time and embedded constraints becomes a primary objective for such frameworks. To guarantee correctness, formal verification in the form of model checking is a viable solution due to its full automation capability. Nevertheless, little is known from either the existing literature or industrial experience on how formal verification can be integrated into an object-oriented application framework, whose primary purpose was previously only to design and generate application software. This work contributes to the state-of-art technology by showing how a design framework and a verification framework can be integrated. Three main issues are tackled: (i) what to verify?; (ii) when to verify?; and (iii) how to verify? As a solution to these three issues the authors propose a mapping from the object-oriented model to a formal model, a schedule-verify-map strategy and a compositional verification methodology, respectively. These have been implemented in a component-based framework and experiments performed to illustrate their feasibility. Due to the incorporation of industry de-facto standards such as real-time unified modelling language and real-time Java, in the proposed techniques it should now be possible for an engineer to gain access to theoretically proven formal verification technologies that would otherwise be considered to be inaccessible to an engineer unskilled in verification techniques.

High-level Transformations to Support Framework-Based Software Development

In this paper, we show how elaborate support for framework-based software development can be provided based on explicit documentation of the hot spots of object-oriented application frameworks. This support ranges from automatically verifying whether appropriate design constraints are preserved, over providing high-level transformations that guide a developer when instantiating applications from a framework, to supporting software upgrades based on these transformations. The hot spots are documented by means of design patterns, and we use metapatterns as an abstraction to define the associated design constraints and high-level transformations.

Basisarchitekturen Web-basierter Informationssysteme

In the course of time, different concepts for the implementation of Web-based information systems have emerged. This article gives an overview over three common approaches and introduces Zope as an example of a modern object-oriented web application framework.

Facilitating parallel and distributed computing

This special issue is based on a collection of selected papers presented at the Fifth International Conference on Advanced Computing held in Chennai (Madras), India in December 97. The International Conference on Advanced Computing is organized annually in India by the Advanced Computing Society (ACS) which is a premier professional society set up in India to cater to the broad interests in the area of Advanced Computing. One of the significant activities of the Society is to organize regular Meetings/Conferences/Symposia. The Conferences are held annually in India during December. Out of the shortlisted papers presented at the Conference held in Chennai (Madras) during December 97, the following six papers were finally selected after a second round of detailed review of the papers. The first paper On designing and implementing collaborative system using Java-RMI by Rajeev R. Raje, Snehasis Mukhopadhyay, Michael Boyles and Nila Patel describe the use of Java-RMI in designing a collaborative information classifier. The principles of RMI, the details of the prototype, and some preliminary results are presented. The paper primarily concentrates on web-based computing paradigms. In the second paper A framework for performance-based program partitioning , Ram Subramanian and Santosh Pande present an efficient and accurate performance model based program-partitioning approach for parallel architectures. The interactions between computation and communication are captured through behavioral edges . The approach yields significant performance improvement. The third paper DDSCHED: a distributed dynamic real-time scheduling algorithm by Anup K. Bhattacharjee, K. Ravindranath, R. Mall and A. Pal presents a dynamic soft real-time scheduling algorithm for distributed systems. The algorithm is based on a local scheduler and a distributed scheduling scheme. The algorithm takes care of the network delays assuming that the communication protocol is CSMA/CD. In the fourth paper Generic operational decomposition for concurrent systems semantics and reflection , Annie Marcoux, Christine Maurel, Frederic Migeon and Patrick Salle discuss about the reflection in concurrent languages, particularly in actor-based languages. The main objective of the paper is to extend concurrent systems to reflection. The authors present a modular and dynamic description of entity operational management, and extend the decomposition to obtain reflective entities. The fifth paper Parallel programming using visual patterns by A. S. M. Sajeev proposes a two level approach to parallel programming within the context of a visual environment. The first level is the specification of patterns encapsulating process communation and synchronization, and the second level is the use of patterns for parallel programming. The approach encourages reuse of patterns. In the sixth paper An application framework for dynamic distributed software architectures , G. R. Ribeiro-Justo and P. R. F. Cunha present an object-oriented application framework for developing evolving (reconfigurable) software architectures for distributed systems. The application framework is called C++CL. Such a requirement is encountered in banking, industrial control and telecommunications applications. We are extremely thankful to the following reviewers who have helped us in reviewing the papers submitted for this special issue: Lawrence Jenkins N. Mohan Ram Nishit Narang Rajeev Shorey Sameer Adhikari K. Balaji K. Rajan Sumit Kasera Subhrajyothi Bhar Pankaj Sethi Ravindranath Kokku Guest Editors: L. M. Patnaik, Ravi Mittal and K. M. Mehta

Rapid software prototyping in molecular modeling using the biochemical algorithms library (BALL)

In the next century, virtual laboratories will play a key role in biotechnology. Computer experiments will not only replace some of the time-consuming and expensive real-world experiments, but they will also provide insights that cannot be obtained using "wet" experiments. The field that deals with the modeling of atoms, molecules, and their reactions is called Molecular Modeling. The advent of Life Sciences gave rise to numerous new developments in this area. However, the implementation of new simulation tools is extremely time-consuming. This is mainly due to the large amount of supporting code that is required in addition to the code necessary to implement the new idea. The only way to reduce the development time is to reuse reliable code, preferably using object-oriented approaches. We have designed and implemented BALL, the first object-oriented application framework for rapid prototyping in Molecular Modeling. By the use of the composite design pattern and polymorphism we were able to model the multitude of complex biochemical concepts in a well-structured and comprehensible class hierarchy, the BALL kernel classes. The isomorphism between the biochemical structures and the kernel classes leads to an intuitive interface. Since BALL was designed for rapid software prototyping, ease of use, extensibility, and robustness were our principal design goals. Besides the kernel classes, BALL provides fundamental components for import/export of data in various file formats, Molecular Mechanics simulations, three-dimensional visualization, and more complex ones like a numerical solver for the Poisson-Boltzmann equation.

USING INCREMENTAL PLANNING TO FOSTER APPLICATION FRAMEWORK REUSE

In this work, we present an approach for documenting object-oriented application frameworks and use the documentation to guide the framework instantiation process. Our approach is based on a shift from a framework-centered to a functionality-centered documentation, through which a tool can guide the instantiation process according to the functionality required for the new application. The fundamental idea of our work is the combination of the concept of user-tasks modeling and least commitment planning methods to guide the instantiation process. Based on these techniques, the tool is able to present the different high level activities that can be carried out when creating a new application from a framework to the developer, taking as a basis the documentation provided by the designer through instantiation rules.

Application Framework for Development of Simulation Tools

Development of specialized construction simulation tools is a time-consuming and complex operation. This has hindered the effective and wide use of simulation in the construction industry. An object-oriented application framework is a promising software engineering principle, which can help in overcoming this obstacle. Application frameworks encapsulate reusable code as well as common design patterns for a specific class of applications so that development of new tools is greatly simplified. This paper describes this new principle and applies it to the development of a construction simulation object library. A case study performed to compare the efforts between framework- and nonframework-based simulation tool development revealed that productivity can be dramatically improved.

Introduction to the computing surveys' electronic symposium on object-oriented application frameworks

research-article Free Access Share on Introduction to the computing surveys' electronic symposium on object-oriented application frameworks Author: Mohamed E. Fayad Univ. of Nebraska, Lincoln Univ. of Nebraska, LincolnView Profile Authors Info & Claims ACM Computing SurveysVolume 32Issue 1esMarch 2000 pp 1–eshttps://doi.org/10.1145/351936.351937Online:01 March 2000Publication History 18citation1,749DownloadsMetricsTotal Citations18Total Downloads1,749Last 12 Months66Last 6 weeks9 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Developing flexible and high-performance Web servers with frameworks and patterns

The goal of this paper is to illustrate how frameworks and patterns address complexities that arise in the design and implementation of high-performance distributed software systems. These complexities are both inherent (e.g., latency reduction and throughput preservation), and accidental (e.g., the continuous reinvention of key concepts and components). This paper explains how complexities occurring in the development of high-performance Web servers can be alleviated with the use of design patterns and object-oriented application frameworks. These techniques were applied to the development our high-performance adaptive Web server framework, JAWS. JAWS exemplifies how a framework can remain flexible without sacrificing performance. 1 Applying Patterns and Frameworks to Web Servers Developers of Web servers strive to build fast, scalable, and configurable systems. This paper describes some common pitfalls encountered by these developers and how to avoid these pitfalls. Common pitfalls include (1) coping with tedious and error-prone low-level programming details, (2) lack of portability, and (3) the complexity of navigating the wide range of server design alternatives. By carefully utilizing patterns and frameworks, these hazards can be avoided, by allowing developers to leverage reuse of design and code. 1.1 Common Pitfalls of Developing Web Server Software Web servers perform the following tasks: connection establishment, service initialization, event demultiplexing, event handler dispatching, interprocess communication, memory management and file caching, static and dynamic component configuration, concurrency, synchronization, and persistence. In most Web servers, these tasks are implemented in an ad hoc manner using low-level native OS application programming interfaces (APIs), such as Win32 or UNIX/POSIX, which are written in C. Unfortunately, native OS APIs are not an effective way to develop Web servers or other types of communication middleware and applications [1]. The following are common pitfalls associated with the use of native OS APIs: Excessive low-level details: Building Web servers with native OS APIs requires developers to have intimate knowledge of low-level OS details. Developers must carefully track which error codes are returned by each system call and handle these OS-specific problems in their servers. Such details divert attention from the broader, more strategic issues, such as protocol semantics and server structure. For example, UNIX developers who use the wait system call must distinguish between return errors due to no child processes being present and errors from signal interrupts. In the latter case, the wait must be reissued. Reinvention of incompatible programming abstractions: A common remedy for the excessive level of detail with OS APIs is to define higher-level programming abstractions. For instance, many Web servers create a file cache to avoid accessing the filesystem for each client request. However, these types of abstractions are often rediscovered and reinvented independently by each developer or project. This ad hoc devel-

An object-oriented application framework for building water resource information and planning tools applied to the design of a flood analysis system

An object-oriented framework for building computer based modelling tools for water resource planning is presented. The focus is on building a program for flood calculations in river systems with several reservoirs and water transfer structures. The foundation for the flood model is a general application framework for building hydrological modelling tools. The general framework provides the user with tools for describing the structural components of the hydrological system, their relation in the system topology and controlling the behaviour of the system during simulation. Hydrological models are often data intensive, and the framework is equipped with tools to handle both time series and spatially-distributed data efficiently. During the development, effort has been put into supporting future changes and extensions to the model system, as well as creating sound reusable components that will benefit future development and maintenance. A flood modelling application in the Norwegian river Gudbrandsdalslågen is described to illustrate the use of the toolkit.

An architectural application framework for evolving distributed systems

Abstract In this paper, we present an object-oriented application framework to support the development of evolving distributed systems. The framework combines concepts of the object-oriented paradigm with those of architectural design. The result is a framework which supports extensible and reusable configurations of distributed components. The framework addresses the problem of evolution by allowing the addition, replacement and extension of components of a configuration. Evolution is also possible at run time, where a configuration can change dynamically depending on a particular event. The paper outlines the fundamental aspects of our framework and presents a case study, which illustrates its application.

A context-based object-oriented application framework for discrete event simulation

Applying object-oriented programming (OOP) to construct simulation programs has gained momentum in the research community. Major research efforts involved with object-oriented paradigm adopted in discrete-event simulation are reviewed in this paper, along with a simulation application framework proposed which provides special reusability mechanisms. This object-oriented simulation framework consists of three object elements, that is, model, service and scheduler. The relations and interactions among these elements are also demonstrated. In addition, the abstraction of a model under such a framework is reached by a special concept and implementation, referred to as the simulation context. Each simulation context is used to model a component sub-system, e.g. the control or physical flows of a manufacturing system. A practical system, CSIMT+ +, is also developed to validate the feasibility of such a simulation application framework. Furthermore, various forms of application models based on this framework are also illustrated.

Beyond WYSIWYG: Display of Hidden Information in Graphics Editors

Graphics editors such as computer aided design systems are complex and difficult to use. We attribute this to the fact that only a small part of the information is visible and therefore accessible and understandable. Only the graphics objects themselves are visible, but the relations between these objects remain hidden. We propose an effective way to visualise this information in the form of trees and graphs in so-called structure browsers. A prototype implements this proposal based on an object-oriented application framework for graphics editors.

Video as a high-level data type

Object-oriented application frameworks are among the most advanced tools available to software engineers for the development and maintenance of applications with sophisticated interactive user interfaces. These frameworks provide text and graphics as high-level data types but still lack support for motion video or animation, which demand high screen update rates and multi-threading. We identified the screen update model `drawing by invalidation' (or `damage repair'), which is widely used in frameworks as well as other user interface toolkits, as a major obstacle to video integration. We generalized the model to remove this obstacle and changed an application framework's internal architecture accordingly. The adapted framework together with a newly developed video class hierarchy now allows a programmer to easily place video objects in any shape and number seamlessly integrated with other visual objects in any user interface element. For instance, video objects may appear in scrollable views, as possibly overlapping building blocks in graphics editors, as characters in text editors, and as items in list or pop-up menus. The classes in the hierarchy factor out common functionality to ease the development of customized video objects. For instance, the setup of and communication with a separate thread of control as well as the implementation of the new drawing model can be inherited and reused in subclasses.

Object-oriented user interfaces (abstract)

The principles of objects, polymorphism, classes, and inheritance can apply to the end users external view of a user interface, just as it can apply to the language that is used to implement it. This tutorial shows how to design (not implement) a user interface that is truly object-oriented. It gives guidance on the design of the externals of object-oriented user interfaces, and shows how developers can capitalize on the isomorphism between the users conceptual model of the interface and the constructs provided by object-oriented programming languages. The tutorial exposes a (perhaps surprisingly) deep analogy between object-oriented programming languages and object-oriented user interfaces. This analogy is valuable because it can be used to map external user interface design in a clear and natural way onto object-oriented application frameworks. The tutorial is illustrated with historical examples, many on videotape.