基于Java平台的多语言混合编程

Java领域混合语言编程时代已经到来。本文首先回顾静态类型语言和动态类型语言、命令式语言和声明式语言的基本概念和各自的优缺点,然后介绍Java语言的发展趋势和基于Java Virture Machine的代表性语言Jython、JRuby、Groovy、Scala和Clojure,最后指出软件项目的未来在于混合语言编程,Java仍将是JVM生态系统中的重要组成部分。     

Executing continuation semantics: A comparison

Several authors have suggested translating denotational semantics into prototype interpreters written in high-level programming languages to provide evaluation tools for language designers. These implementations have generally been understandable when restricted to direct denotational semantics. This paper considers using two declarative programming languages, Prolog and Standard ML, to implement an interpreter that follows the continuation semantics of a small imperative programming language, called Gull. Each of the two declarative languages presents certain difficulties related to evaluation strategies and expressiveness. The implementations are compared in terms of their ease of use for prototyping, their resemblance to the denotational definitions, and their efficiency.     

Automated analysis of concurrent systems with the constrainedexpression toolset

The constrained expression approach to analysis of concurrent software systems can be used with a variety of design and programming languages and does not require a complete enumeration of the set of reachable states of the concurrent system. The construction of a toolset automating the main constrained expression analysis techniques and the results of experiments with that toolset are reported. The toolset is capable of carrying out completely automated analyses of a variety of concurrent systems, starting from source code in an Ada-like design language and producing system traces displaying the properties represented bv the analysts queries. The strengths and weaknesses of the toolset and the approach are assessed on both theoretical and empirical grounds     

2APL: a practical agent programming language

This article presents a BDI-based agent-oriented programming language, called 2APL (A Practical Agent Programming Language). This programming language facilitates the implementation of multi-agent systems consisting of individual agents that may share and access external environments. It realizes an effective integration of declarative and imperative style programming by introducing and integrating declarative beliefs and goals with events and plans. It also provides practical programming constructs to allow the generation, repair, and (different modes of) execution of plans based on beliefs, goals, and events. The formal syntax and semantics of the programming language are given and its relation with existing BDI-based agent-oriented programming languages is discussed.     

Synchronous/Reactive Programming of Concurrent System Software

Synchronous languages are intended for programming reactive systems. Reactive systems, which include real-time systems and key operating system components, interact continually with their environment. This paper considers the applicability of imperative synchronous/reactive languages to the development of general system software, that is, to the implementation of operating system kernels, file systems, databases, networks, server architectures, device drivers, etc. The languages Esterel and Reactive C (RC) receive special attention as Esterel is the oldest and most developed such language and RC is specifically designed for compatibility with C systems programming. An alternative soft-instruction software architecture is described, which is well suited to real-world system programming. © 1997 by John Wiley & Sons, Ltd.     

Seamless design: Impedance mismatch revisited

A pattern for information system implementation is proposed. The pattern is based on the commonly accepted object-oriented methodologies of design and development oriented toward widely used imperative programming languages. At the same time, this pattern makes it possible to fully use the power of declarative possibilities of the DBMS query language. The presented estimations demonstrate much higher performance of the applications obtained compared to those created by means of commonly accepted techniques.     

Implementation of visual languages using pattern‐based specifications

The implementation of visual languages requires a wide range of conceptual and technical knowledge from issues of user interface design and graphical implementation to aspects of analysis and transformation for languages in general. We present a powerful toolset that incorporates such knowledge. Our toolset generates editors from high‐level specifications. A language is specified by identifying certain patterns in the language structure and selecting a visual representation from a set of precoined solutions. Visual programs are represented by attributed abstract trees. Therefore, further phases of processing visual programs can be generated by state‐of‐the‐art tools for language implementation. We demonstrate that even challenging visual languages can be implemented with reasonably little effort and with rather limited technical knowledge. The approach is suitable for a large variety of visual language styles. Copyright © 2003 John Wiley & Sons, Ltd.     

On OCL-based imperative languages

The Object Constraint Language (OCL) is a well-accepted ingredient in model-driven engineering and accompanying modeling languages such as UML (Unified Modeling Language) and EMF (Eclipse Modeling Framework) that support object-oriented software development. Among various possibilities, OCL offers the formulation of class invariants and operation contracts in form of pre- and postconditions, and side-effect free query operations. Much research has been done on OCL and various mature implementations are available for it. OCL is also used as the foundation for several modeling-specific programming and transformation languages. However, an intrusive way of embedding OCL into these language hampers us when we want to benefit from the existing achievements for OCL. In response to this shortcoming, we propose the language SOIL (Simple OCL-like Imperative Language), which we implemented in the UML and OCL modeling tool USE to amend its declarative model validation features. The expression sub-language of SOIL is identical to OCL. SOIL adds imperative constructs for programming in the domain of models. Thus by employing OCL and SOIL, it is possible to describe any operation in a declarative way and in an operational way on the modeling level without going into the details of a conventional programming language. In contrast to other similar approaches, the embedding of OCL into SOIL is done in a careful, non-intrusive way so that purity of OCL is preserved.     

Programming with narrowing: A tutorial

Narrowing is a computation implemented by some declarative programming languages. Research in the last decade has produced significant results on the theory and foundation of narrowing, but little has been published on the use of narrowing in programming. This paper introduces narrowing from a programmer’s viewpoint; shows, by means of examples, when, why and how to use narrowing in a program; and discusses the impact of narrowing on software development activities such as design and maintenance. The examples are coded in the programming language Curry, which provides narrowing as a first class feature.     

Designing and prototyping data-intensive applications in the Logresand Algres programming environment

The authors present an environment and a methodology for the design and rapid prototyping of data-intensive software applications, i.e., applications which perform substantial retrieval and update activity on persistent data. In the approach, the application is formally specified using Logres, a database language which combines object-oriented data modeling and rule-based programming. These specifications are translated into Algres, an extended relational algebra, thus yielding a rapid executable prototype. Algres programs embedded into a conventional programming language interface may be converted to conventional programs operating on a commercial relational system. This methodology helps automate the conversion from declarative requirements to imperative code, performing several tasks fully automatically and reducing the probability of human errors, while integrity constraints and application specifications are expressed in a declarative language, at a very high level of abstraction     

Design wizards and visual programming environments for GenVocagenerators

Domain-specific generators will increasingly rely on graphical languages for declarative specifications of target applications. Such languages will provide front-ends to generators and related tools to produce customized code on demand. Critical to the success of this approach will be domain-specific design wizards, tools that guide users in their selection of components for constructing particular applications. The authors present the P3 ContainerStore graphical language, its generator, and design wizard     

宣告式网络程序设计语言比较研究

网络技术的发展和异构计算设备种类的增多给网络协议的设计开发带来诸多挑战。网络协议设计者面临的最基本问题是如何脱离繁琐的协议实现细节,而将主要精力放在协议的功能设计上。近年来,为了解决这个问题,宣告式网络程序设计语言,被提出。宣告式网络程序设计语言吸取数据库管理系统成功的经验,将网络划分为逻辑层和物理层。网络协议设计者只需利用其提供的高层编程抽象设计网络协议的功能,而不用关心繁杂的物理层实现。通过分析和比较不同宣告式网络程序设计语言,对其发展进行了总结,并指出了进行进一步的研究工作需要注意的问题。     

流程图编程语言和编辑软件的设计开发

为解决小型微型就地控制或显示设备的流程图显示问题,设计了一种适用于有限资源的基于矢量方式、顺序文件模式的流程图编程语言和配套的绿色图形化编辑软件.较为详尽地介绍了它们的设计思想和设计方法.     

Understanding Declare models: strategies,pitfalls, empirical results

Declarative approaches to business process modeling are regarded as well suited for highly volatile environments, as they enable a high degree of flexibility. However, problems in understanding and maintaining declarative process models often impede their adoption. Likewise, little research has been conducted into the understanding of declarative process models. This paper takes a first step toward addressing this fundamental question and reports on an empirical investigation consisting of an exploratory study and a follow-up study focusing on the system analysts’ sense-making of declarative process models that are specified in Declare. For this purpose, we distributed real-world Declare models to the participating subjects and asked them to describe the illustrated process and to perform a series of sense-making tasks. The results of our studies indicate that two main strategies for reading Declare models exist: either considering the execution order of the activities in the process model, or orienting by the layout of the process model. In addition, the results indicate that single constraints can be handled well by most subjects, while combinations of constraints pose significant challenges. Moreover, the study revealed that aspects that are similar in both imperative and declarative process modeling languages at a graphical level, while having different semantics, cause considerable troubles. This research not only helps guiding the future development of tools for supporting system analysts, but also gives advice on the design of declarative process modeling notations and points out typical pitfalls to teachers and educators of future systems analysts.     

MODELS AND TRENDS IN PARALLEL PROGRAMMING

This paper introduces and discusses programming models for parallel processing and recent trends in the area of parallel programming. The paper discusses different parallel programming languages and tools that reflect various parallel computation models. These language differ in expressiveness, portability and performance. Software design and implementation largely varies by using different languages that make the programmer task easy or complex. We describe here the design goals and the main issues of parallel programming models and languages belonging to the following categories: shared-space based languages, message-based languages, parallel toolkits, data-parallel languages, parallel declarative languages, parallel object-oriented languages, and parallel composition-based languages. Tools and languages such as HPF, Linda, Java, OpenMP, PVM, MPI, Parallel C+ +, Sisal, Orca, Mentat, SkieCL, BSP and others are described in some detail. Their main features for design and implementation of high performance applications are discussed. Finally, we outline directions of research and development in the parallel programming area with a special attention to novel approaches based on high-level programming structures that make transparent to the users the architectural details of parallel computing machines.     

On legal contracts,imperative and declarative smart contracts,and blockchain systems

This paper provides an analysis of how concepts pertinent to legal contracts can influence certain aspects of their digital implementation through smart contracts, as inspired by recent developments in distributed ledger technology. We discuss how properties of imperative and declarative languages including the underlying architectures to support contract management and lifecycle apply to various aspects of legal contracts. We then address these properties in the context of several blockchain architectures. While imperative languages are commonly used to implement smart contracts, we find that declarative languages provide more natural ways to deal with certain aspects of legal contracts and their automated management.     

External relationships of objects

External relationships of objects represent semantic dependencies between objects that enable inter-object communication and augment the services the objects provide with role-specific behaviors. Most of the object-oriented design methodologies support the notion of external relationships at the conceptual level, but OO programming languages have no language construct to directly implement the external relationships, which are implemented as containment relationships with embedded pointers resulting in the semantics of the relationships being buried in code. Moreover, object-oriented programming languages lack a mechanism to allow a dynamic classification of objects according to the roles they play in external relationships. This paper describes a technique to treat an external relationship as a conceptually useful abstraction at the specification stage and a separately identifiable structure at the implementation stage, by providing a declarative specification and an implementation in C++ with special focus on the implementation of object roles. © 1998 John Wiley & Sons, Ltd.     

Functional programming for finite elements

The problems of software reliability can, to some extent, be attributed to the nature of conventional imperative programming languages (FORTRAN, Pascal, etc.). Functional programming languages, on the other hand, adopt a radically different approach where the only control structure is the recursive application of a pre-defined function. This gives the advantage that programs are mathematical expressions and can be treated formally as such for the purpose of correctness proofs. The suitability of the functional approach is examined by writing a standard finite element program in SASL, which is a purely functional language. The clarity and conciseness of the solution is noted, and although certain problems of efficiency and optimal algorithm design require further research, it is clear that the overall top-down design imposed by a functional language is beneficial to the computational engineer.     

Construction of Interactive Programs in Computer Graphics

In interactive computer graphics, one often finds a gap between sophisticated algorithms, using very high level data structures, and poor methods of program and object construction. Particular programming languages are too readily adopted for solving problems, before a precise specification of the problem to be solved has been formulated.
This paper shows that progress can be made by using modern engineering methods to specify and develop graphical software. Two programming techniques are studied here: the algebraic specification of data types and a functional static modular method of problem statement.
The paper also discusses these proposals in the context of other modes of computer graphics specification and programming.