Viewpoint modeling is an effective approach for analyzing and designing complex systems. Splitting various elements and corresponding constraints into different perspectives of interests, enables separation of concerns such as domains of expertise, levels of abstraction, and stages in lifecycle. Specifically, in Systems Engineering different viewpoints could include functional requirements, physical architecture, safety, geometry, timing, scenarios, etc. Despite partial interdependences, the models are usually developed independently by different parties, using different tools and languages. However, the essence of Systems Engineering requires repetitive integration of many viewpoints in order to find feasible designs and to make good architectural decisions, e. g., in each mapping between consecutive levels of abstraction and in each design space exploration. This integration into one consistent model becomes a significant challenge from both modeling and information management perspectives. In this paper we suggest (1) a unique modular algebraic viewpoint representation robust to design evolution and suitable for generation of the integrated optimization/analysis models, and (2) an underlying ontology-based approach for consistent integration of local viewpoint concepts into the unified design space model. We show an example of an optimization model with different combinations of partially interdependent Analysis Viewpoints. Using the proposed modeling and information management approaches the underlying viewpoints' equations can be applied without modification, making the approach pluggable. (C) 2013 The Authors. Published by Elsevier B. V. Selection and/or peer-review under responsibility of Georgia Institute of Technology

We propose two new constructs for object oriented programming that significantly increase polymorphism. Consequently, code may be reused in ways unaccounted for by existing machinery. These constructs of type correspondence and partial inheritance are motivated from metaphors of natural language and thought. They establish correspondences between types non of which is (necessarily) a subtype of the other. As a result, methods may operate on objects — and may receive arguments — of types different than the ones originally intended for. The semantics of the proposed constructs generalizes that of ordinary inheritance, thereby establishing the latter as a special case. We show that the incorporation of these constructs in programming supports the process of natural software evolution and contributes to a better conceptual organization of the type system.

A necessary and sufficient condition for a given marked tree to have no infinite paths satisfying a given formula is presented. The formulas are taken from a language introduced by Harel, covering a wide scale of properties of infinite paths, including most of the known notions of fairness. This condition underlies a proof rule for proving that a nondeterministic program has no infinite computations satisfying a given formula, interpreted over state sequences. We also show two different forms of seemingly more natural necessary and sufficient conditions to be inadequate.

We propose a component programming language that supports an integrated notion of both compile-time and runtime component. The centerpiece of this paper is the static, compile time notion of assembly, complementing our previous work on the dynamic, runtime notion of cell. An assembly is a declarative, stateless piece of code that facilitates code combination. It offers explicit typed interfaces to outsiders, called linkers, which can be used to link smaller assemblies into bigger, compound assemblies. Each assembly may in turn be loaded at run-time, producing a cell in the runtime environment. A cell is a dynamic, stateful component that interacts with other cells via explicit runtime interfaces. Thus, the static assemblies and the dynamic cells are fully integrated. Assemblies may also be dynamically linked into a running cell, thereby expanding its code base on runtime. We present the model and the concepts, and then go on to define a toy language supporting assemblies and cells. We precisely define the langauge via a formal operational semantics and a set of typing rules.

Matching is a relation between object types originally designed to support type-safe subclassing with binary methods. In this paper we generalize it to deal with general covariance by allowing field and method parameter types to change covariantly in matching types. In addition, object types may explicitly contain virtual types which can also change covariantly. The result is a significant increase in the flexibility of subclassing. The new definition is accompanied by appropriate machinery, allowing the loss of subsumption to be compensated by match-bounded parameterization and hash types. We define a language LGM supporting generalized matching, its typing rules, and its operational semantics and establish a subject reduction theorem showing the soundness of the system.

The success of Java in recent years is largely due to its targeting as a language for the Internet. Many of the network-related features of Java however are not part of the core language design. In this paper we focus on the design of a more parsimonious Internet programming language, which supports network integration smoothly and coherently as part of its core specification.The key idea is to center these extensions around the unified notion of a cell. Cells are deployable containers of objects and code, which may import (plugin) and export (plugout) classes and operations. They may be dynamically linked and unlinked, locally or across the network. Cells may be dynamically loaded, unloaded, copied, and moved, and serve as units of security. At first approximation, cells can be thought of as a hybrid between modules and components. Here we concentrate on the design of JCells, a language which builds cells on top of the fundamental Java notions of class, object, and virtual machine.

We propose a new component model with a focus on the needs of Internet components, mainly dynamism and se- curity. It is based around the concept of a cell—a new programming abstraction with component-specific responsibilities. At the heart of it is the introduction of a persistent link mode of interaction into components. In existing technolo- gies (COM/Corba/Java Beans), compo- nents interact exclusively by obtaining handles to other components on runtime and then invoking operations via inter- faces. With persistent links, components are developed assuming some imports given; then on runtime they must link to other components which will provide the implementations for the imports, via exports. Cells include both models of interaction in one entity. Supported features include cross-network persistent linking, cells as containers of objects, a connection-based security mechanism, and cross-component class inheritance. These features are expected to prove es- pecially beneficial for components in the Internet.

In this paper we propose a new form of polymorphism for object-oriented languages, called correspondence polymorphism . It lies in a different dimension than either parametric or subtype polymorphism. In correspondence polymorphism, some methods are declared to correspond to other methods, via a correspondence relation . With this relation, it is possible to reuse non-generic code in various type contexts—not necessarily subtyping or matching contexts—without having to plan ahead for this reuse. Correspondence polymorphism has advantages over other expressive object type systems in that programmer-declared types still may be simple, first-order types that are easily understood. We define a simple language LCP that reflects these new ideas, illustrating its behavior with multiple examples. We present formal type rules and an operational semantics for LCP, and establish soundness of the type system with respect to reduction.

We propose a new component model with a focus on the needs of Internet components, mainly dynamism and security. It is based around the concept of a cell—a new programming abstraction with component-specific responsibilities. At the heart of it is the introduction of a persistent link mode of interaction into components. In existing technologies (COM/Corba/Java Beans), components interact exclusively by obtaining handles to other components on runtime and then invoking operations via interfaces. With persistent links, components are developed assuming some imports given; then on runtime they must link to other components which will provide the implementations for the imports, via exports. Cells include both models of interaction in one entity. Supported features include cross-network persistent linking, cells as containers of objects, a connection-based security mechanism, and cross-component class inheritance. These features are expected to prove especially beneficial for components in the Internet.