The Definitive Guide to Eclipse Rich Client Development In Eclipse Rich Client Platform, Second Edition, three Eclipse Rich Client Platform (RCP) project leaders show how to use Eclipse 3.5 (Galileo) to rapidly deliver cross-platform applications with rich, native-feel GUIs. The authors fully reveal the power of Eclipse as a desktop application development platform; introduce important new improvements in Eclipse 3.5; and walk through developing a full-featured, branded RCP application for Windows, Linux, Mac, and other platformsincluding handheld devices and kiosks. Drawing on their extensive experience, the authors cover building, refining, and refactoring prototypes; customizing user interfaces; adding help and software management features; and building, branding, testing, and shipping finished software. They demonstrate current best practices for developing modular and dynamically extensible systems, using third-party code libraries, packaging applications for diverse environments, and much more. For Java programmers at all levels of experience, this book Introduces important new RCP features such as p2, Commands, and DatabindingThoroughly covers key RCP-related technologies such as Equinox, SWT, JFace, and OSGiShows how to effectively brand and customize RCP application look-and-feelWalks through user interface testing for RCP applications with SWTBotIlluminates key similarities and differences between RCP and conventional plug-in development Hands-on, pragmatic, and comprehensive, this book offers all the real-world, nontrivial code examples working developers needas well as deep dives into key technical areas that are essential to your success.

A Hands-On Guide to Equinox and the OSGi Framework In OSGI and Equinox: Creating Highly Modular Java Systems, three leading experts show developersfor the first timeexactly how to make the most of these breakthrough technologies for building highly modular dynamic systems. Youll quickly get started with Eclipse bundle tooling, create your first OSGi-based system, and move rapidly to sophisticated production development. Next, youll master best practices and techniques for creating systems with exceptional modularity and maintainability. Youll learn all about OSGis Declarative Services and how to use them to solve a wide variety of real-world problems. Finally, youll see everything that youve learned implemented in a complete case study project that takes you from early prototype through application delivery. For every Eclipse developer, regardless of previous experience, this book Combines a complete hands-on tutorial, online sample code at every step, and deep technical dives for working developersCovers the OSGi programming model, component development, OSGi services, Eclipse bundle tooling, server-side Equinox, and much moreOffers knowledge, guidance, and best practices for overcoming the complexities of building modular systems Addresses practical issues ranging from integrating third-party code libraries to server-side programmingIncludes a comprehensive case study that goes beyond prototyping to deliver a fully refined and refactored production systemWhatever your application, industry, or problem domain, if you want to build state-of-the-art software systems with OSGi and Equinox, you will find this book to be an essential resource.

Build Powerful, Cross-Platform Rich Client ApplicationsEclipse is more than a state-of-the-art IDE: its Rich Client Platform (RCP) plug-ins form an outstanding foundation for any desktop application, from chat applications to enterprise software front-ends. In Eclipse Rich Client Platform, two leaders of the Eclipse RCP project show exactly how to leverage Eclipse for rapid, efficient, cross-platform desktop development.In addition to explaining the power of Eclipse as a desktop application development platform, the authors walk step-by-step through developing a fully featured, branded RCP application. They introduce a wide range of techniques, including developing pluggable and dynamically extensible systems, using third-party code libraries, and packaging applications for diverse environments. You'll build, refine, and refactor a complete prototype; customize the user interface; add Help and Update features; and build, brand, and ship the finished software. For every Java developer, regardless of previous Eclipse experience Thoroughly covers Eclipse 3.1's new RCP features and its extensive new tools for designing, coding, and packaging RCP applications Presents techniques for branding and customizing the look and feel of RCP applications Shows how to overcome the challenges and "rough edges" of RCP development Discusses the similarities and differences between RCP and conventional plug-in development Includes an overview of OSGi, the base execution framework for EclipseIf you want to develop and deploy world-class Java applications with rich, native GUIs, and use Eclipse RCP-get this book.CD-ROM contains the Eclipse 3.1 SDK, Eclipse 3.1 RCP SDK, and Eclipse 3.1 RCP Delta Pack appropriate for Windows, Linux, and Mac OS X. It also contains all the code samples developed in the book.© Copyright Pearson Education. All rights reserved.

Proposes a method for generalizing existing distributed simulation algorithms such as the time warp and Chandy-Misra algorithms to create a unified distributed simulation (UDS) algorithm. Explicitly defining risk and aggressiveness parameters for each model allows models with different behaviors to be mixed within one simulation. The author illustrates how this results in a more powerful environment for creating complex simulations. Current distributed simulation techniques compared. The author relates computational reflection and speculation to the UDS algorithm and details the concurrent object-oriented programming environment created to support Rival, its implementation. UDS extends the functionality of the current distributed simulation techniques. UDS allows components to describe how and when they are willing to receive and process messages and, as a result, gives the user more power and flexibility.<>

Meta-levels are complex pieces of software with diverse demands in both the computation and interaction domains. Common techniques using just code to express behaviour fail to clearly assign responsibility for a particular behaviour’s definition or to provide support for the reuse or integration of existing behaviour descriptions. The techniques of fine-grained decomposition of meta-level behaviour into objects and their subsequent composition into object models provides a framework for creating, reusing and integrating complex object behaviours. Using such a framework, we show that users can develop and integrate quite different object models while retaining a high degree of abstraction and fostering meta-level component reuse.

As applications become larger and more complex, it is frequently the case that system components require varying models of computation. The use of different computational models is not well supported by standard object-oriented mechanisms and systems. Typical mechanisms implicitly encapsulate meta-level (i.e., computational) semantics along with the base-level (i.e., domain) behaviour. Objects defined using one model cannot easily be executed under another and so cannot be reused. A major problem is the inclusion of base-level language constructs in the meta-level architecture design. Meta-levels typically only facilitate concepts which are similar to those in the original base-level language and so cannot describe widely differing models of execution. We present a meta-level architecture founded on the novel principle of fine-grained, operational decomposition of the meta-level into objects. Unlike others, our approach bases the design of the architecture on the operations which occur during object execution (e.g., send, lookup) rather than the structural nature of an object’s representation (e.g., class, method). This clearly separates the elements of the meta-level from those of the base-level language and so opens the meta-level to more radical change. The power of this approach is shown via several markedly different object models and their combination and non-intrusive application to user code. We detail how computational domains are completely altered with almost no modification of the original application code or its semantics. This capability is applied to real-world problems in object reuse, object behaviour investigation and in novel application design. Detailed examples relating to distributed computing and object communication are presented. It is shown that this approach to meta-level design is more open and flexible, and better supports the application of common software engineering practices (e.g., encapsulation and reuse) to the components of the meta-level — Properties desired by anyone designing complex systems.

The creation of distributed applications is often hindered by a lack of a priori knowledge of distributed object behaviour. Designers and builders of distributed systems can benefit from an environment which allows them to explore and experiment with various computational and structural models for application objects. Our ability to do this is limited by traditional distributed systems' tendency to mix domain-specific object description and distributed behaviour specification. By using an explicit meta-level architecture, we can transparently add a wide variety of distributed behaviours to objects with little effect on their base-level behaviour or code. We outline such an architecture and detail the design of various distribution mechanisms and policies (e.g. marshaling and replication). These are shown to be independent of base-object behaviour to such a degree that they can be recursively applied to the architecture in which they are implemented.<>

f view enables the running of inference engines tobe the subject matter of a PS just as easily as say medical diagnosis. This gives usmeta-level control over the reasoning process and requires no special meta-mechanisms(other than openness). Inference engines become essentially context holders andexecution descriptors for rules. As such, they are dynamically adaptable andinterchangeable.1The term fact is problematic in the context of object-oriented reasoning systems but is used here...

Systems like CLIPS [NASA] addressed this problem in part by defining what is essentially a user callable reasoning library and allowing the library to call user-defined functions or programs. Still, there was a relatively strong separation between the CLIPS knowledge space and the user program's knowledge space. CLIPS knowledge and user program knowledge could not be directly shared and interchanged.

There have been several proposals for Concurrent Object-Oriented Programming Systems (COOPS) [Agha, Wegner and Yonezawa 89]. Unfortunately, most of these proposals are not powerful enough to be used outside the laboratory, that is, they are not industrial strength.

article Actra-a multitasking/multiprocessing smalltalk Share on Authors: D. A. Thomas Carleton Univ., Northfield, MN Carleton Univ., Northfield, MNView Profile , J. McAffer Defence Research Establishment Ottawa, Ontario, Canada Defence Research Establishment Ottawa, Ontario, CanadaView Profile , B. Barry Defence Research Establishment Ottawa, Ontario, Canada Defence Research Establishment Ottawa, Ontario, CanadaView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 24Issue 4April 1989 pp 87–90https://doi.org/10.1145/67387.67409Online:26 September 1988Publication History 15citation286DownloadsMetricsTotal Citations15Total Downloads286Last 12 Months7Last 6 weeks4 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 AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access