Computer Languages

The flow of information in a computing system is a crucial indicator for the security of the system. In a system of multiple messagepassing processes, the flow of information could depend on the states of different processes. We devise a type-based verification technique for flow policies with such multi-process (global) dependencies, to provide confidentiality guarantees. In this technique, the confidentiality requirements for the presence and content of messages are dealt with separately. We develop a pair of synergetic static analyses to over-approximate the potential sets of values of the variables depended upon by the flow policies -covering global value correspondence between the variables of different processes. We significantly improve the permissiveness of security typing by exploiting information about which variables are live, and by specializing the flow policies using the conditional expressions of branching and looping constructs. We prove the soundness of our verification technique, provide a proof-of-concept implementation of it, and illustrate its effectiveness at an example system where the flow of information depends on how the headers of the messages from different processes correlate.

The flow of information in a computing system is a crucial indicator for the security of the system. In a system of multiple messagepassing processes, the flow of information could depend on the states of different processes. We devise a type-based verification technique for flow policies with such multi-process (global) dependencies, to provide confidentiality guarantees. In this technique, the confidentiality requirements for the presence and content of messages are dealt with separately. We develop a pair of synergetic static analyses to over-approximate the potential sets of values of the variables depended upon by the flow policies -covering global value correspondence between the variables of different processes. We significantly improve the permissiveness of security typing by exploiting information about which variables are live, and by specializing the flow policies using the conditional expressions of branching and looping constructs. We prove the soundness of our verification technique, provide a proof-of-concept implementation of it, and illustrate its effectiveness at an example system where the flow of information depends on how the headers of the messages from different processes correlate.

We present a tool for the design and validation of embedded real-time applications. The tool integrates two approaches, the use of the synchronous programming language ESTEREL for design and the application of model-checking techniques for validation of real-time properties. Validation is carried out on a global formal model (timed automata) taking into account the effective implementation of the application on the target hardware architecture as well as its external environment behavior.

We address the problem of 3D medical volume reconstruction using web services. The use of proposed web services is motivated by the fact that the problem of 3D medical volume reconstruction requires significant computer resources and human expertise in medical and computer science areas. Web services are implemented as an additional layer to a dataflow framework called Data to Knowledge. In the collaboration between UIC and NCSA, pre-processed input images at NCSA are made accessible to medical collaborators for registration. Every time UIC medical collaborators inspected images and selected corresponding features for registration, the web service at NCSA is contacted and the registration processing query is executed using the Image to Knowledge library of registration methods. Co-registered frames are returned for verification by medical collaborators in a new window. In this paper, we present 3D volume reconstruction problem requirements and the architecture of the developed prototype system at . We also explain the tradeoffs of our system design and provide experimental data to support our system implementation. The prototype system has been used for multiple 3D volume reconstructions of blood vessels and vasculogenic mimicry patterns in histological sections of uveal melanoma studied by fluorescent confocal laser scanning microscope.

There will be a permanently manned, fully operational space station by the mid-1990s. Automation of the station will increase space station autonomy and utilize the crew more effectively. Artificial intelligence technology (robotics, image perception, expert systems, and planning systems) will play an important role. This paper describes expert systems and indicates the use of these systems in space station automation. We first discuss the nature of expert systems, typical applications, and limitations. The role of expert systems in space station automation is then indicated, and the necessary research and development is described.

The importance of function valued functions (operators) in APL is now well recognized, and considerable attention has been paid to the introduction of more general operators into the language. In this article we consider some of the consequences for the implementation of interpreters and compilers for APL. We first consider the difficulties that arise with the introduction of basic valued and operator valued operators. We then discuss various modifications to the syntactic and semantic structure of APL that serve to avoid these difficulties. Abstraction operators as in the ), calculus are also introduced. Finally, we describe an abstract machine for interpreting APL-like expressions which is analogous to the SECD machine used in the 2 calculus. APL Programming languages Higher-order functions Operators Parsing Interpretation Compilation Evaluation * The grammar given in Keenan [4] contains a minor error: (array) : : = (function) (value) should read (array) :: = (function) (array). * As a syntax directed translation scheme 1"7] we can consider the output grammar to be identical to the input grammar except that the symbols occurring in the right-hand-sides of the rewriting rules are permuted according to the permutation of xt and x2 in Table . However, unlike normal syntax directed translation schemes, the permutation of each rule is not invariant, but depends on the attributes of the symbol occurrences in the outout derivation tree. * If a dyadic operator is used [ 1] then it is not possible to represent dyadic operators as abstractions without modifying the parsing scheme. In particular, the parser would have to look ahead two symbols rather than one. CL. 62 n About the Author--JAROSLAV KAUTSKY studied mathematics at the Charles University and received his Ph.D. from the Czechoslovak Academy of Sciences in Prague where he lived and worked until August 1968. Since then he joined the Flinders University of South Australia where he teaches Numerical Analysis and Computing. His main research interests are mesh selection problems (Gauss quadratures, optimal quadratures and spline approximations, equidistributing adaptive meshes, etc.} as well as the development and usage (both in research and teaching) of applicative languages such as APL.

A photovoltaic array (PVA) simulation model to be used in Matlab-Simulink GUI environment is developed and presented in this paper. The model is developed using basic circuit equations of the photovoltaic (PV) solar cells including the effects of solar irradiation and temperature changes. The new model was tested using a directly coupled dc load as well as ac load via an inverter. Test and validation studies with proper load matching circuits are simulated and results are presented here.

Programs which perform partial evaluation, beta-expansion, and certain optimizations on programs, are studied with respect to implementation and application. Two implementations are described, one "'interpretive" partial evaluator, which operates directly on the program to be partially evaluated, and a "compi/ing" system, where the program to be partially evaluated is used to generate a specialized program, which in its turn is executed to do the partial evaluation. Three applications with different requirements on these programs are described. Proofs are given for the equivalence of the use of the interpretive system and the compili.,:g system in two of the three cases. The general use of the partial evaluator as a tool for the programmer in conjunction with certain programming techniques is discussed. Partial evaluation has traditionally been considered as a toy, to be used only as a subroutine in very experimental research programs. The present paper argues that if properly developed and utilized, partial evaluation can also be very useful as a practical working tool for the serious programmer. The paper describes a set of programs for partial evaluation (Sections 3 and 8), and experiments which have been done with them (Sections 4-6), as well as of how such programs can be put to use (the remaining sections). Some figures from the experiments are to be found in the appendix. In the simplest case, a partial evaluation program is a progra~ which takes a procedure P of some arguments (xl, xy,..., xn) together with values (cl,..., c,) for the first m of these n arguments, and which generates a new procedure P' such that P' (xm+~,..., xn) = P(ct,..., c,, xm+l,..., xn) for all x. In doing so, it

Most current-day software engineering tools and environments do not su ciently allow software engineers to declare or enforce the intended software architecture. On the one hand, architectures are typically described at a too low l e v el, inhibiting their evolution and understanding. On the other hand most tools provide little support to automatically verify whether the source code conforms to the architecture. Therefore, a formalism is needed in which architectures can be expressed at a su ciently abstract level, without losing the ability to perform automatic conformance checking. We propose to declaratively codify software architectures using virtual software classi cations and relationships among these classi cations. We illustrate how software architectures can be expressed elegantly in terms of these virtual classi cations and how t o k eep them synchronized with the source code. Research funded by the Brussels Capital Region Belgium y Research conducted on a doctoral grant from the Instituut voorWetenschap en Technologie Flanders, Belgium 1 We use the term `codifying' in a slightly stronger sense than SG96 . In our terminology, `codifying' means: to make explicit so that it can be automatically manipulated in tools".

Most current-day software engineering tools and environments do not su ciently allow software engineers to declare or enforce the intended software architecture. On the one hand, architectures are typically described at a too low l e v el, inhibiting their evolution and understanding. On the other hand most tools provide little support to automatically verify whether the source code conforms to the architecture. Therefore, a formalism is needed in which architectures can be expressed at a su ciently abstract level, without losing the ability to perform automatic conformance checking. We propose to declaratively codify software architectures using virtual software classi cations and relationships among these classi cations. We illustrate how software architectures can be expressed elegantly in terms of these virtual classi cations and how t o k eep them synchronized with the source code. Research funded by the Brussels Capital Region Belgium y Research conducted on a doctoral grant from the Instituut voorWetenschap en Technologie Flanders, Belgium 1 We use the term `codifying' in a slightly stronger sense than SG96 . In our terminology, `codifying' means: to make explicit so that it can be automatically manipulated in tools".

The structure of object-oriented systems typically forms a complicated, tangled web of interdependent classes. Understanding this implicit and hidden structure poses severe problems to developers and maintainers who want to use, extend or adapt those systems. This paper advocates the use of a logic meta-language to express and extract structural relationships in class-based object-oriented systems. As validation the logic meta-language SOUL was implemented and used to construct a declarative framework that allows reasoning about the structure of Smalltalk programs. The declarative framework's usefulness is illustrated by expressing di erent high-level structural relationships such as those described by design patterns.

This paper describes a rapid prototyping system for extensions to an existing programming language. Such extensions might include new language features or might introduce notation specific to a particular problem domain. The system consists of a dialect description language used to specify the syntax and semantics of extensions, and a context sensitive syntactic transducer that automatically implements the extensions by transforming source programs written using them to equivalent programs in the original unextended language. Because the transformer is context sensitive, it is more powerful than traditional context free preprocessors and extensible languages and can be used to prototype language extensions involving significantly new programming paradigms such as object oriented programming.

mostly focuses on computational applications in life sciences. Usually, this involves fairly typical partial differential equations such as the incompressible Navier-Stokes equations, elasticity equations, and parabolic and elliptic PDEs, but these PDEs are typically coupled either with each other or with ordinary differential equations (ODEs). Hence, even though the PDEs themselves are reasonably well understood, the couplings between them make the problems we study quite challenging. Our design goals are therefore threefold. First, we want to easily define systems of PDEs. Second, we want it to be easy to play with different solution algorithms for systems of coupled PDEs. Finally, we want to reuse existing software to avoid reinventing the wheel. We use many good and mature libraries from the Web, including Dolfin (www.fenics.org/dolfin/), GiNaC (www.ginac.de), MayaVi (. sourceforge.net), NumPy (), PETSc (www.mcs.anl.gov/petsc/), SciPy (www. scipy.org), Trilinos ( trilinos/), and VTK (www.vtk.org). In fact, we're mixing these libraries with our own packages: 48 THIS ARTICLE HAS BEEN PEER-REVIEWED. COMPUTING IN SCIENCE & ENGINEERING Using Python to Solve Partial Differential Equations This article describes two Python modules for solving partial differential equations (PDEs): PyCC is designed as a Matlab-like environment for writing algorithms for solving PDEs, and SyFi creates matrices based on symbolic mathematics, code generation, and the finite element method.

Design by contract is a practical methodology for developing code together with its specification. The contract consists of class invariants and method preand postconditions. As the code is refactored, specifications of internal units change with the code. There are mutual influences between the code and the contract. The assertions that constitute the contract are Java expressions; refactorings such as Rename Method must change these assertions as well as the code. The contract has methodological implications, which serve as preconditions on some refactorings; these must be checked before performing those refactorings. In addition, some contract modifications follow from certain refactorings, and can be done automatically. Development environments that support design by contract must take these influences into account. We report on the implementation in Eclipse of several refactorings that involve both code and contract. These show how contracts are modified in response to code changes, how contracts prevent certain changes, and how new contracts are computed for newly-generated methods and classes.

Design of large dependable real-time embedded systems relies on integration of software elements onto a set of hardware nodes. In this paper an overall process of how to generate a Platform Specific Model (PSM) from a set of Platform Independent Models (PIM) and a hardware resource description is presented in the course of designing such embedded systems. Subsystems with different requirements are allocated and integrated onto shared hardware resources based on the constraints of the specified HW resources. The focus of this paper lies on developing the methodologies and tools for the generation of the PSM. Ac- cordingly a dual-track approach has been proposed. First track is based on a transformational process and the second is a Multi Variable Optimization (MVO) approach.

Before attempting to synthesize hardware from a programming language like C or C++, we need to introduce additional semantics to be able to describe hardware behavior accurately. In particular, concurrency, reactivity, communication mechanisms, and event handling semantics need to be added. Also, a synthesizable subset of the language needs to be defined, together with synthesis semantics for programming language constructs. With these enhancements, it is possible to create C/C++ descriptions of hardware at the well-understood RTL and behavioral levels of abstraction, providing an opportunity to leverage existing, mature hardware-synthesis technology that has been developed in the context of HDL based synthesis to create a C/C++ synthesis system. In this paper, we will present some of the key ingredients of a C/C++ synthesis system and elaborate on the challenges of hardware synthesis from C/C++.

In this paper we introduce a methodology for utilizing concurrency in place of backtracking in the implementation of nondeterministic algorithms. This is achieved in an applicative setting through the use of the Friedman-Wise multiprogramming primitive frons, and a paradigm which views the action of nondeterministic algorithms as one of data structure construction. The element by element nondeterminism arising from a linearized search is replaced by a control structure which is oriented towards constructing sets of partial computations. This point of view is facilitated by the use of suspensions, which allow control disciplines to be embodied in the form of conceptual data structures that in reality manifest themselves only for purposes of control. We apply this methodology to the class of problems usually solved through the use of simple backtracking (e.g. "'eight queens"), and to a problem presented by Lindstrom to illustrate the use of coroutine controlled backtracking, to produce backtrack-free solutions. Our solution to the latter illustrates the coroutine capability of suspended structures, but also demonstrates a need for further investigations into resolving problems of process communication in applicative languages. Nondeterministic algorithms Concurrency structures Applicative languages Multiprocessing Multisets Suspended

Automating the assessment of programming assignments in higher education institutions is important to provide prompt feedback to the students, reduce teachers’ workload on repetitive tasks, avoid human errors, and enable the exploration of new educational paradigms such as gamification and course adaptation based on learning analytics. However, the automatic assessment of programming assignments is challenging because of the variety of programming languages, the variety of assessment strategies, the difficulty to assess quality attributes beyond functional correctness, and the need to integrate with e-learning and students management platforms. There are several platforms for automatic assessment that are used namely in programming contests, but that support only one assessment strategy or do not integrate with students management platforms. To overcome those limitations, the authors, from the Faculty of Engineering of the University of Porto, developed an extensible web based platf...

We address the complete design flow from specification models of new automotive functions captured in Matlab-Simulink to their distributed execution on hierarchical bus-based electronic architectures hosting the release of already deployed automotive functions. We propose an automated design space exploration process resulting in a costoptimized extension of the existing target hardware and an allocation of balanced task structures automatically derived from the specification model on this modified target hardware which is sufficient to guarantee both system-level timing requirements and deadlines extracted from the Matlab-Simulink specification model.

In this paper we present a generalization of the active electronic notebook, OMNotebook, for handling multiple programming languages for educational purposes. OMNotebook can be an alternative or complementary tool to the traditional teaching method with lecturing and reading textbooks. Experience shows that using such an electronic book will lead to more engagement from the students. OMNotebook can contain technical computations and text, as well as graphics. Hence it is a suitable tool for teaching, experimentation, simulation, scripting, model documentation, storage, etc. OMNotebook is part of the open source platform OpenModelica. It is already used for the course material DrModelica in teaching the Modelica language but can easily be adapted to other programming languages which is also shown in this paper. The notebook can also be adapted to other areas, such as physics, chemistry, biology, biomechanics etc., where phenomena can be illustrated by dynamic simulations within the notebook. The idea behind this paper is to show that by using a standardized interface the notebook can be extended to any computer language, i.e., being language independent. This is shown in the form of an implementation and adaptation of the notebook to support the Scheme language.

Only recently has the research community started to consider how to make software process models interoperable and reusable. The task is difficult. Software processes are inherently creative and dynamic, difficult to define and repeat at an enactable level of detail. Additionally, interoperability and reusability have not been considered important issues. Recent interoperability and reusability solutions advocate the development of standard process model representations based on common concepts or generic schemas, which are used as a basis for translating between heterogeneous process representations. In this paper we propose an alternative approach through the development of process-based components. We present the Open Process Components Framework, a componentbased framework for software process modeling. In this approach, process models are constructed as sets of components which interact in meaningful ways. Interoperability and reuse are obtained through encapsulation of process representations, an explicit representation of process state, and an extendable set of class relationships.

Information-flow control tracks how information propagates through the program during execution to make sure that the program handles the information securely. Secure information flow is comprised of two related aspects: information confidentiality and information integrity -intuitively pertaining to the reading and writing of the information. The prevailing basic semantic notion of secure information flow is noninterference, demanding independence of public (or, in the case of integrity, trusted) output from secret (or, in the case of integrity, untrusted) input. This document gives an account of the state-of-the-art in confidentiality and integrity policies and their enforcement with a systematic formalization of four dominant formulations of noninterference: termination-insensitive, termination-sensitive, progress-insensitive, and progress-sensitive, cast in the setting of two minimal while languages.

This paper proposes a concurrency model which integrates the asynchronous and event-driven nature of wireless sensor networks with higher-level abstractions that provide a more familiar programming style for the developer. As a basis for this proposal, we designed and implemented a cooperative multitasking scheduler, based on coroutines, for the TinyOS operating system. We then used this scheduler to implement RPC-like interfaces that capture different communication patterns common in wireless sensor networks. This allows the programmer to work, when appropriate, with a synchronous style, while maintaining an asynchronous model at the message exchange level.

1. To give some simple examples of Prolog programs. This will introduce us to the three basic constructs in Prolog: facts, rules, and queries. It will also introduce us to a number of other themes, like the role of logic in Prolog, and the idea of performing matching with the aid of variables.

In previous work, we introduced the concept of structural clone as recurring configurations of simple clones (ie, similar code fragments). We also described a technique for detection of certain types of structural clones. The premise of our approach is that structural clones can provide a higher level and more useful view of the similarity situation in software than simple clones alone. In this paper, we set up a ground for systematic analysis of the structural clone phenomenon: We define structural clones more formally and more ...

Generic (polymorphic) type-safe containers are the primary motivation for generics (in Ada, Eiffel, and recently proposed additions to Java and C#) and templates (in C++). We studied buffer classes and found that they could not be unified by type parameters. At times, unification required non-type parameters (e.g., parameters representing operators, keywords or algorithmic details) and at other times-the nature of variations was not parametric which called for a more general unification mechanism. Investigation of the reasons behind the observed symptoms revealed that unification problems were caused by "feature combinations": Other than by type, each class was also affected by yet other features and implementation of various features interacted with classes in rather chaotic ways. In the paper, we show examples of how the feature combination manifests in programs. We believe that we are dealing with a fundamental phenomenon that will cause many other class containers and application programs to suffer from the same problem. In our case study, some of the difficulties were caused by limitations specific to Java generics. Yet others were more fundamental and reflected the weakness of parameterization mechanisms supported by today's programming languages. We suggest that stronger generics systems would considerably enhance capabilities of programming languages in the areas of generic programming, reuse and maintenance. We refer to a meta-level parameterization mechanism that can effectively unify any types of variations triggered by feature combination, and can be applied to any programming language. We discuss the trade-offs between conventional type-parametric generics built-into today's programming languages and the meta-level parameterization approach.

Robots are becoming interactive and robust enough to be adopted outside laboratories and in industrial scenarios as well as interacting with humans in social activities. However, the design of engaging robotbased applications requires the availability of usable, flexible and accessible development frameworks, which can be adopted and mastered by researchers and practitioners in social sciences and adult end users as a whole. This paper surveys Visual Programming Environments aimed at enabling a paradigm fostering the so-called End-User Development of applications involving robots with social capabilities. The focus of this article is on those Visual Programming Environments that are designed to support social research goals as well as to cater for professional needs of people not trained in more traditional text-based computer programming languages. This survey excludes interfaces aimed at supporting expert programmers, at allowing industrial robots to perform typical industrial tasks (such as pick and place operations), and at teaching children how to code. After having performed a systematic search, sixteen programming environments have been included in this survey. Our goal is twofold: first, to present these software tools with their technical features and Authoring Artificial Intelligence modeling approaches, and second, to present open challenges in the development of Visual Programming Environments for end users and social researchers, which can be informative and valuable to the community. The results show that the most recent such tools are adopting distributed and Component-Based Software Engineering approaches and web technologies. However, few of them have been designed to enable the independence of end users from high-tech scribes. Moreover, findings indicate the need for (i) more objective and comparative evaluations, as well as usability and user experience studies with real end users; and (ii) validations of these tools for designing applications aimed at working "in-the-wild" rather than only in laboratories and structured settings.

Due to the critical nature o f r eal-time systems, there is an ever growing burden on the designer to not only guarantee that the tasks would meet their deadlines at design time, but would continue to do so as the system evolves. This implies that the schedulability analysis has to be r obust. In this study we identify the sensitivity of schedulability analysis to the task execution times. The impact, this parameter has on the schedulability analysis is captured by formulating a general scaling problem. This problem is shown to relate to the problems of scalability, portability and execution time estimation. A technique to solve this general problem is developed. A proof of correctness and optimality of the technique is presented.

A system for assisting in the testing phase of compilers is described. The definition of the language to be compiled drives an automatic sentence generator. The language is described by an extended BNF grammar which can be augmented by actions to ensure contextual congruence, e.g. between definition and use of identifiers. For deep control of the structure of the produced sample the grammar can be described by step-wise refinements: the generator is iteratively applied to each level of refinement, producing at last compilable, complete programs. The implementation is described and some experimental results are reported concerning PLZ, MINIPL and some other languages.

Associative Language Descriptions are a recent grammar model, theoretically less powerful than Context Free grammars, but adequate for describing the syntax of programming languages. ALD do not use nonterminal symbols, but rely on permissible contexts for specifying valid syntax trees. In order to assess ALD adequacy, we analyze the descriptional complexity of structurally equivalent CF and ALD grammars, finding comparable measures. The compression obtained using CF copy rules is matched by context inheritance in ALD. The family of hierarchical parentheses languages, an abstract paradigm of HTML, and of expressions with operator precedences is studied. A complete ALD grammar of Pascal testifies of the practicality of the ALD approach.

The copyright law of the United States (Title 17, United States Code) governs the making of photocopies or other reproductions of copyrighted material. Under certain conditions specified in the law, libraries and archives are authorized to furnish a photocopy or other reproduction. One of these specified conditions is that the photocopy or reproduction is not to be "used for any purpose other than private study, scholarship, or research." If a, user makes a request for, or later uses, a photocopy or reproduction for purposes in excess of "fair use" that user may be liable for copyright infringement, This institution reserves the right to refuse to accept a copying order if, in its judgment, fulfillment of the order would involve violation of copyright law.

We describe work on development of a software system for ~riting and testing programs for a computer controlled manipulator. We examine in particular how the development of working programs is facilitated by the use of an interactive system based on an interpreter. The paper presents the main features of POINTY. the system developed at Stanford Artificial Intelligence Laboratory as a tool for writing assembly programs. The user. interacting with the manipulator, constructs an incremental model of the objects invotved in the assembly and develops the corresponding symbolic program.

Gypsy is a component-based, dynamically extensible environment for mobile agent systems. The runtime environment consists of lightweight servers that provide a distributed execution environment for agents, and a remote administration tool that supports the setup and shutdown of servers and agents. A server hosts a number of places to which agents may move to execute their functions. Each place is specialized to support a particular service. A supervisor agent may contain several worker agents that may execute concurrently. A supervisor agent travels from place to place according to its itinerary and launches its workers at appropriate places. A mobile agent is the basic abstraction from which all other components, including servers and supervisor agents, are constructed. The primary goal of the Gypsy project is to build a multi-language, extensible environment for experimenting with mobile agents as a programming paradigm. The environment is implemented in Java and currently supports agents written in the Java or Python programming languages. This paper presents an overview of the Gypsy project, the current system architecture and the design of the important components of the Gypsy system.

We propose a context-free semantic localisation approach to visualise and analyse indoor movements. We focus on settings where indoor location or rooms have strongly associated semantics, such as hospitals. We describe an approach that can work with different localisation systems, with little knowledge of the physical space properties, and with minimal bootstrapping required. We propose a movement representation that consists of time-encoded strings, and discuss how our approach can be used for analysing and visualising longitudinal indoor localisation data. CCS CONCEPTS • Human-centered computing → Empirical studies in HCI; • Human-centered computing → Ubiquitous and mobile computing; • Human-centered computing → Smartphones.

In this paper, we propose extended Rebeca as a toolsupported actor-based language for modeling and verifying concurrent and distributed systems. We enrich Rebeca with a formal concept of components which integrates the message-driven computational model of actor-based languages with synchronous message passing. Components are used to encapsulate a set of internal active objects which react asynchronously to messages by means of methods and which additionally interact via a synchronous message passing mechanism. Components themselves interact only via asynchronous and anonymous messages. We present our compositional verification approach and abstraction techniques, and the theory corresponding to it, based on the formal semantics of Rebeca. These techniques are exploited to overcome the state explosion problem in model checking.

This paper outlines the important role that actual and, mainly, potential intermodular dependecies play in the maintenance phase of a sofnvare product. The authors discuss the problem with reference to Pascal systems and they show how reverse engineering and static code analysis enable the identification of the actual and the potential intermodular dataflow and relationships. Some costraints are proposed to prevent an uncontrollable proliferation of data binding among modules and their reciprocal calls. To achieve the consistency of the programs respect to the adopted costraints, the intermodular dependencies knowledge, as produced by reverse engineering, is used to restructure both data and module declarations also. I2

This paper describes a simple image-based method that applies engraving stylisation to portraits using ordered dithering. Face detection is used to estimate a rough proxy geometry of the head consisting of a cylinder, which is used to warp the dither matrix, causing the engraving lines to curve around the face for better stylisation. Finally, an application of the approach to colour engraving is demonstrated.

This paper describes a simple image-based method that applies engraving stylisation to portraits using ordered dithering. Face detection is used to estimate a rough proxy geometry of the head consisting of a cylinder, which is used to warp the dither matrix, causing the engraving lines to curve around the face for better stylisation. Finally, an application of the approach to colour engraving is demonstrated.

Wireless Sensor Network (WSN) applications working on TinyOS operating system is widely used in various areas. However, the requirement of managing the power constraints makes TinyOS different from ordinary systems and hence building WSNs with TinyOS can be a challenging and time-consuming task. As successfully applied in many other domains, model-driven engineering (MDE) can facilitate the design and implementation of such applications. Within this context, the researchers have performed noteworthy studies on deriving various MDE approaches and tools. However, these studies do not support the synchronization between TinyOS application models and the generated programs especially when any change is made in the programs. Hence, in this paper, we introduce a model-driven round-trip engineering (RTE) methodology in which both the MDE of TinyOS applications and synchronization between TinyOS instance models and corresponding code are provided with the use of a toolchain. A domain-specific modeling language, called DSML4TinyOS is used for the MDE of such applications while existing TinyOS programs can be reverse engineered in an environment, called RE4TinyOS. Models retrieved from the existing programs can be automatically processed again with DSML4TinyOS. Evaluation results showed that it is possible to obtain the configurations of the TinyOS applications completely just modeling with DSML4TinyOS whereas the same process leads the automatic creation of almost half of the module parts of these applications. Moreover, the time required for developing such systems from scratch decreased approximately to its half. The results also showed that both model-code synchronization and the integration of existing TinyOS applications which do not have system models previously, into the proposed MDE are possible with using RE4TinyOS. RE4TinyOS succeeded in the reverse engineering of all main parts of the TinyOS applications taken from the official TinyOS Github repository and generated models were able to be visually processed in the MDE environment for further modifications.

Greenplum Database is a massively parallel processing (MPP) analytics database that adopts a shared-nothing architecture with multiple cooperating processors. A query submitted to the Greenplum master is optimized by the Orca query optimizer [7] which is based on state-of-the-art top-down query optimization techniques. Joins are commonly used SQL operations. When querying large amounts of data, it is crucial to generate a nearoptimal join to ensure that the user query does indeed complete. In this paper, we present the join enumeration algorithm employed in Orca. Our proposed approach seamlessly handles workloads consisting of a mixture of inner, left and right joins. Optimization effort is directly proportional to the complexity of the join query. Our technique employs an exhaustive approach to generate an optimal join order when the number of join participants is less than 10. For larger join queries, we gracefully transition into a greedy based approach to reduce optimization tim...

M ost authors distinguish two types of computer animation: computer-aided animation and modeled ani- mation. 1-3 The first type is used in the cartoons of Walt Disney and Hannah-Barbera. In this type of two-dimen- sional character animation, the computer may have a role to play in three main areas: the creation of drawings, the production of in-betweens, and painting. In each of these areas computer-assisted animation and interactive user- oriented systems are normally used: e.g., graphics editors, key-frame systems, and paint systems. The second type of animation corresponds to animation sequences in which 3-D models move about in 3-D space. The process is very complex without a computer. Modeled animation has been used in television advertise-ments4 and for special effects in films such as Star Trek II, Return of the Jedi, and especially Tron. Three-dimen- sional computer animation involves four main activities: (1) Object modeling: This consists of describing or con- structing three-dimensional objects. (2) Motion specification of objects and synchroniza- tion: To animate an object is to make it move, or to change its shape or position over a period of time.

When modelling complex computer systems, four primary modelling techniques are available to the software engineer, i.e. abstraction, composition, functional decomposition and multiple client interfaces (views). Abstraction and composition can directly be expressed in traditional object oriented models and functional decomposition can often be expressed using subsystems. However, traditional object models provide no expressiveness for multiple client interfaces. This forces designers to either model all different views on a conceptual object as a large, complex implementation object or to model each view as an object and relate the different view objects. Both approaches suffer from problems of complexity, maintainability and reusability. As a solution, we propose the layered object model that allows for the expressive, flexible and extensible definition of multiple client interfaces. To illustrate the problems associated with views and our proposed solution, the domain of industrial...

The paper presents an experimental toolkit for modeling and solving Cuuy constraint satisfaction problems (FCSPs) called JFSolver. JFSolver is a Java based library developed as an extension of a erisp constraint programming library to provide an enhanced functionality for handling fuzzy constraints including fuzzy constraint specification, propagation and search mechanisms. JFSolver comprises an application programming interface for fuzzy constraint programming and a graphical editor for interactive problem definition and solving. This functionality is demonstrated with an illustrative eumple.

Many DoD HPC users, particularly in the SIP area, run codes developed with MATLAB and related applications (MatlabMPI, StarP, pMatlab, etc.). There is a desire to run codes from a desktop instance of MATLAB and connect to and interact with codes running on HPC resources. The PET SIP team has developed and demonstrated technology that makes this possible. The SSH toolbox for MATLAB enables users to connect to and use HPC resources using SSH without leaving the MATLAB environment. The toolbox uses a freely available implementation of SSH, a modified version of which is also used by the DoD HPCMP. The SSH toolbox consists of a Windows DLL written in C, which is used by MATLAB to communicate with the SSH client. The toolbox provides simple MATLAB commands for users to connect to remote resources, run code, retrieve results and end the SSH session. The complexity of the DLL interface and most of the security needs are hidden from the user, making this a very easy to use and powerful toolbox. Since the main component of the toolbox is written is C and packaged as a DLL, the toolbox can also be extended to work with other programming languages such as Java, Python and Octave. MATLAB-style documentation for the toolbox also makes it easy to obtain help on various aspects of the toolbox and a GUI-based installer makes distribution easier. This technology provides a revolutionary way of providing support to the DoD. Software developers are now able to provide all the hooks to a complicated HPC environment, thus removing the burden of end users.

The principle of separation of concerns has long been used by software engineers to manage the complexity of software system development. Programming languages help software engineers explicitly maintain the separation of some concerns in code. As another step towards increasing the scope of concerns that can be captured cleanly within the code, Kiczales and colleagues have introduced aspect-oriented programming. In aspect-oriented programming, explicit language support is provided to help modularize design decisions that cross-cut a functionally-decomposed program. Aspect-oriented programming is intended to make it easier to reason about, develop, and maintain certain kinds of application code. To investigate these claims, we conducted two exploratory experiments that considered the impact of aspect-oriented programming, as found in AspectJ version 0.1, on two common programming activities: debugging and change. Our experimental results provide insights into the usefulness and usability of aspect-oriented programming. Our results also raise questions about the characteristics of the interface between aspects and functionallydecomposed core code that are necessary to accrue programming benefits. Most notably, the separation provided by aspect-oriented programming seems most helpful when the interface is narrow (i.e., the separation is more complete); partial separation does not necessarily provide partial benefit.

According to the paradigm of Dynamic Logic Programming, knowledge is given by a set of theories (encoded as logic programs) representing different states of the world. Different states may represent time (as in updates), specificity (as in taxonomies), strength of the updating instance (as in the legislative domain), hierarchical position of knowledge source (as in organizations), etc. The mutual relationships extant between different states are used to determine the semantics of the combined theory composed of all individual ...