General-purpose multiparadigm programming languages: an enabling technology for constructing complex systems

Multiparadigm programming is a term used to describe a style of software development that makes use of facilities originally designed in support of a number of different programming language paradigms. A conception of multiparadigm programming is illustrated by describing how various data structures can be implemented in Leda, a strongly typed compiled multiparadigm programming language. Specifically, a style of program development that draws upon features from a number of different programming language paradigms is illustrated. Aspects of imperative programming, object-oriented programming, functional programming, and logic (or relational) programming are used. It is shown how these various language paradigms can be integrated in a single problem domain, and how each can derive benefit from the others. The problem considered is the creation of a few simple data structures for lists and two-dimensional tables. The development of this example is used as a means to introduce Leda.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

In this paper we propose a set‐oriented rule‐based method definition language for object‐oriented databases. Most existing object‐oriented database systems exploit a general‐purpose imperative object‐oriented programming language as the method definition language. Because methods are written in a general‐purpose imperative language, it is difficult to analyze their properties and to optimize them. Optimization is important when dealing with a large amount of objects as in databases. We therefore believe that the use of anad hoc, set‐oriented language can offer some advantages, at least at the specification level. In particular, such a language can offer an appropriate framework to reason about method properties.In this paper, besides defining a set‐oriented rule‐based language for method definition, we formally define its semantics, addressing the problems of inconsistency and non‐determinism in set‐oriented updates. Moreover, we characterize some relevant properties of methods, such as conflicts among method specifications in sibling classes and behavioral refinement in subclasses. Copyright © 2003 John Wiley &amp; Sons, Ltd.

I+: A multiparadigm language for object-oriented declarative programming

In order to design a broadly multiparadigm language, i.e., a language that directly supports several diverse programming paradigms, one must integrate a number of seemingly incompatible paradigmatic attributes. Among the most formidable of these antagonists are the time-independent and the time-dependent features of the diverse paradigms that are to be integrated into the language design. Although at some level these antagonists are inherently irreconcilable, finding an appropriate level of integration for such diverse elements can be a significant contribution to a broadly multiparadigm language design. In order to demonstrate this, we first briefly introduce the language G-2, the latest version of the multiparadigm language G. We focus on a new linguistic feature, called a block , that was introduced into G-2 in order to reconcile the facilities of destructive assignment and lazy evaluation. Finally we examine how the block supports many of the paradigms included in G-2 in a simple and direct manner.

Developing high-performance software is a difficult task that requires the use of low-level, architecture-specific programming models (e.g., OpenMP for CMPs, CUDA for GPUs, MPI for clusters). It is typically not possible to write a single application that can run efficiently in different environments, leading to multiple versions and increased complexity. Domain-Specific Languages (DSLs) are a promising avenue to enable programmers to use high-level abstractions and still achieve good performance on a variety of hardware. This is possible because DSLs have higher-level semantics and restrictions than general-purpose languages, so DSL compilers can perform higher-level optimization and translation. However, the cost of developing performance-oriented DSLs is a substantial roadblock to their development and adoption. In this article, we present an overview of the Delite compiler framework and the DSLs that have been developed with it. Delite simplifies the process of DSL development by providing common components, like parallel patterns, optimizations, and code generators, that can be reused in DSL implementations. Delite DSLs are embedded in Scala, a general-purpose programming language, but use metaprogramming to construct an Intermediate Representation (IR) of user programs and compile to multiple languages (including C++, CUDA, and OpenCL). DSL programs are automatically parallelized and different parts of the application can run simultaneously on CPUs and GPUs. We present Delite DSLs for machine learning, data querying, graph analysis, and scientific computing and show that they all achieve performance competitive to or exceeding C++ code.

The advantages of using method Monte Carlo for simulation of radiative transfer in complex turbid random media like biological tissues are well recognized. However, in most practical applications the wave nature of probing optical radiation is ignored, and its propagation is considered in terms of neutral particles, so-called photon packets. Nevertheless, when the interference, polarization or coherent effects of scattering of optical/laser radiation constitute the fundamental principle of a particular optical technique the wave nature of optical radiation must be considered and taken into account. In current report we present the state-of-the art and the development prospects for application of method Monte Carlo to the point of taking into account the wave properties of optical radiation. We also introduce a novel Object-Oriented Programming (OOP) paradigm accelerated by Graphics Processing Unit that provides an opportunity to escalate the performance of standard Monte Carlo simulation up to 100 times.

Constructing Non-Commuting Graph of Symmetric Groups by Using Maple's Software

We describe the use of mobile agent technologies in building a framework for supporting distributed logic programming and remote conditional querying. A mobile agent moves from server to server carrying its own knowledge. When it arrives at a server it is given read access to the some part of the server's knowledge base. It then answers its queries using the server's knowledge and its own, adding the results to its own knowledge. We can view the mobile agent's queries as conditional remote queries - what answers would the server give if the knowledge carried by the agent were added to the server. To implement a prototype framework of mobile agents and knowledge servers we have used a new multiparadigm and multi-threaded programming language Go !. This supports mobile agent's as knowledge objects and has powerful knowledge structuring features. We assume some familiarity with Prolog.

This technical report consists of the two most recent papers from the MELD project. Melding Software Systems from Reusable Building Blocks describes MELD as a declarative language that combines facilities from the package library, software generation and object-oriented language approaches to reusability. MEWing Data Flow and Object-Oriented Programming emphasizes the multi-paradigm nature of MELD and introduces overriding of inherited facilities and generic features, and discusses compile-time error detection.

The programming of mathematical expressions and the implementation of numerical methods, such as those reviewed in Chapters 4 and 5, can be facilitated by the use of general-purpose scientific programming languages, such as Fortran. Libraries of specialized subprograms can be called by the programmer when required. Such programming aids can save considerable amounts of program development time and, when correctly used, can avoid the introduction of many programming errors. In some cases routines for the solution of ordinary differential equations have been brought together as a ‘package’ which allows the programmer to use a general-purpose high-level language to create a special-purpose simulation program. This is similar in principle to the use of a more general library of numerical routines, but the package may incorporate specialized features of special relevance to simulation developers. A further type of programming aid has also been developed which can allow the programmer to formulate the problem in a more direct form than is possible using a general-purpose high-level language. This takes the form of a problem-oriented language, or support language, which contains specialized features of value only for the specialized computational tasks involved in a particular type of application. Continuous system simulation languages form one important class of problem-oriented language.

The complexity of problems facing society continues to grow, and decision-makers and problem-solvers are finding many of today's emerging problems to be beyond their capability to adequately address. There is agreement in the literature that problems of this nature are complex system problems, inextricably linked to some highly complex system of systems. Establishing a clear understanding of the specific complex system context is fundamental to the process of understanding and analyzing complex systems and complex system problems across all of the different systems-based disciplines. While complex system context is widely referred to in systems literature, there is no clear characterization of exactly what system context is, making this foundational system concept ambiguous. This research addressed this gap in the systems body of knowledge by providing the needed detail and clarity to the concept of complex system context. A rigorous research methodology, employing the grounded theory method, was used to analyze data collected through a series of semi-structured interviews conducted with individuals reflecting a wide range of systems education and practical experience. Two research questions were identified as integral to increasing the understanding of context within complex systems. (1) What are the constituent elements of complex system context, and what attributes and dimensions characterize these elements? (2) What systems-based framework can be developed for constructing and articulating complex system context? Using the grounded theory method, a theory of system context was constructed, adding to the systems body of knowledge and substantiating a comprehensive and unambiguous theoretical construct for system context within complex systems. Then, based on this theory, a conceptual model to articulate and capture system-specific complex system context was developed---the Complex System Contextual Framework (CSCF). The CSCF shows significant promise for contribution to systems practitioners by supporting the future development of tools to help practitioners capture system context as a part of complex system problem formulation. The research also made a contribution in the area of research methodologies by furthering the use of the grounded theory method in the engineering management and systems engineering domain, an area where its application has been very limited.

This paper illustrates some specific numerical code applications using an object-oriented programming (OOP) paradigm. It is the second of two papers describing OOP issues for scientific-code development. A brief description is given of an object library as well as some simple finite difference and finite element user codes based on that library. The key to efficient OOP implementation in any environment is to conceive an effective object-oriented design of the physical problem and its mathematical abstraction in the first place. This design places a premium on understanding the physical problem from the perspective of class structure, inheritance, and communication. Some of the issues that must be addressed prior to the development of a truly successful OOP environment for large-scale scientific code development and employment are discussed. Optimization issues of OOP in general and the object-oriented programming language C++ in particular are discussed. Our research suggests that there is a tremendous potential for OOP as a development environment for scientific codes.

Object oriented (OO) is the most accepted object modeling languages nowadays. Although OO languages are successful in modeling real world entities, nevertheless, there is little to no support for modeling state of object precisely in code. To overcome this problem, a new general purpose programming language is proposed that is built on two paradigms which are typestate-oriented and permission-based. One of the most vital factor for every language to be accepted and effective for users is having an enhanced standard library and clearly one of the most important parts is Input and Output (I/O) Application Programming Interface (API). One of a new programming language is Plaid language. Since the Plaid is at its early stage of development, I/O features provided by the Plaid standard library are very basic and limited. This paper presents I/O API that we have developed for the Plaid based on the features provided by Java I/O API. For the evaluation we used two metrics which are the number of features provided by I/O API, and the number of exceptions eliminated by using Plaid and typestate-oriented programming language.

With the advent of computers, life has become a lot easier. The computer's ability to perform numerous tasks at a high speed has helped humans in many ways. Complex calculations that were previously done by hand, can now be done quickly using computers. Unlike humans, computers don't get tired. These machines can do monotonous mechanical computations reliably and efficiently. However, as computers cannot think, making a complex decision is certainly not possible for a computer. These machines face trouble in understanding complex real world problems. For instance, can a computer diagnose a disease based on the symptoms the person exhibits? This is why artificial intelligence steps in. It allows the computer to think like human. This paper discuss how software engineering is important to build an artificial indulgence. The requirement of software engineering in AI is for increased modularity, re-use ability and maintainability in the software which has accentuated interest in the object-oriented programming paradigm. In this regard, the approaches to AI, its procedure, and aspects in both dimension has been analyzed. In addition, the field of Distributed Artificial Intelligence (DAI) needs special emphasis on object-oriented multi-agent systems and particularly manufacturing applications. An application of artificial intelligence technology to the implementation of a rapid prototyping method in object-oriented performance design (OOPD) for real-time systems is very important.

Instead of writing SQL queries directly, programmers often prefer writing all their code in a general purpose programming language like Java and having their programs be automatically rewritten to use database queries. Traditional tools such as object-relational mapping tools are able to automatically translate simple navigational queries written in object-oriented code to SQL. More recently, techniques for translating object-oriented code written in declarative or functional styles into SQL have been developed. For code written in an imperative style though, current techniques are still limited to basic queries. JReq is a system that is able to identify complex query operations like aggregation and nesting in imperative code and translate them into efficient SQL queries. The SQL code generated by JReq exhibits performance comparable with hand-written SQL code.