Pardis: a process calculus for parallel and distributed programming in Haskell

Parallel programming and distributed programming involve substantial amounts of boilerplate code for process management and data synchronisation. This leads to increased bug potential and often results in unintended non-deterministic program behaviour. Moreover, algorithmic details are mixed with technical details concerning parallelisation and distribution. Process calculi are formal models for parallel and distributed programming but often leave details open, causing a gap between formal model and implementation. We propose a fully deterministic process calculus for parallel and distributed programming and implement it as a domain-specific language in Haskell to address these problems. We eliminate boilerplate code by abstracting from the exact notion of parallelisation and encapsulating it in the implementation of our process combinators. Furthermore, we achieve correctness guarantees regarding process composition at compile time through Haskell’s type system. Our result can be used as a high-level tool to implement parallel and distributed programs.     

Experiments with service-oriented architectures for industrial robotic cells programming

Integration of equipment in industrial robot cells is to an increasing part involved with interfacing modern Ethernet technologies and low-cost mass produced devices, such as vision systems, laser cameras, force–torque sensors, soft-PLCs, digital pens, pocket-PCs, etc. This scenario enables integrators to offer powerful and smarter solutions, more adapted to small and medium enterprises (SMEs), capable of integrating process knowledge and interface better with humans. Nevertheless, programming all these devices efficiently requires too much specific knowledge about the devices, their hardware architectures and specific programming languages, details about system communication low-level protocols, and other tricky details at the system level. To address these issues, this paper describes and analyses two of the most interesting service-oriented architectures (SOA) available, which exhibit characteristics that are well adapted to industrial robotics cells. To compare, discuss and evaluate their programming features and applicability a test bed was specially designed, and the two SOA are fully implemented to program the test bed. Special focus is given to the way services are specified and to the orchestration tools used to manage system logic. The obtained results show clearly that using integrations schemes based on SOA reduces system integration time and are more adapted to industrial robotic cell system integrators.     

Coquand's calculus of constructions: A mathematical foundation for a proof development system

The calculus of constructions of Coquand, which is a version of higher order typed-calculus based on the dependent function type, is considered from the perspective of its use as the mathematical foundation for a proof development system. The paper considers formulations of the calculus, the underlying consistency of the formalism (i.e., the strong normalisation theorem), and the proof theory of adding assumptions for notions from logic and set theory. Proofs are not given, but references to them are.A preliminary version of this paper was presented at the Third Banff Higher Order Workshop, 23–28 September 1989.     

Synthesis of a unification algorithm in a logic programming calculus

A formal specification of unification is presented and a unification algorithm is synthesized from it. The synthesis is done by logical deduction within the logic programming calculus developed by Hansson and Tärnlund. First-order logic with identity is used as the specification language and extended Horn clause logic as the target language.     

do considered od: A contribution to the programming calculus

Summary The utility of repetitive constructs is challenged. Recursive refinement is claimed to be semantically as simple, and superior for programming ease and clarity. Some programming examples are offered to support this claim. The relation between the semantics of predicate transformers and least fixed point semantics is presented.This work was partially supported by the National Research Council of Canada     

A theoretical basis for stepwise refinement and the programming calculus

A uniform treatment of specifications, programs, and programming is presented. The treatment is based on adding a specification statement to a given procedural language and defining its semantics. The extended language is thus a specification language and programs are viewed as a subclass of specifications. A partial ordering on specifications/programs corresponding to ‘more defined’ is defined. In this partial ordering the program/specification hybrids that arise in the construction of a program by stepwise refinement form a monotonic sequence. We show how Dijkstra's calculus for the derivation of programs corresponds to constructing this monotonic sequence. Formalizing the calculus thus gives some insight into the intellectual activity it demands and allows us to hint at further developments.     

TinySOA: a service-oriented architecture for wireless sensor networks

Wireless sensor networks provide the means for gathering vast amounts of data from physical phenomena, and as such they are being used for applications such as precision agriculture, habitat monitoring, and others. However, there is a need to provide higher level abstractions for the development of applications, since accessing the data from wireless sensor networks currently implies dealing with very low-level constructs. We propose TinySOA, a service- oriented architecture that allows programmers to access wireless sensor networks from their applications by using a simple service-oriented API via the language of their choice. We show an implementation of TinySOA and the results of an experiment where programmers developed an application that exemplifies how easy Internet applications can integrate sensor networks.

一种基于流演算的动态规划程序设计语言*

提出了一种基于流演算的动态规划程序设计语言DPPLFC(dynamic planning programming language based on fluent calculus)。通过定义动作表达式来描述顺序、并发、非确定选择等复杂动作,解决了FLUX不方便用户编程的问题。DPPLFC的动态规划算子是当在线执行的状态与前一次离线执行相对应的状态不同时才进行再次离线执行,改进了基于情景演算的动态规划算子。采用了一种新颖的离/在线执行方式,能够及时处理外部动作;并给出了DPPLFC语言的组成,程序语义及其     

Opening web applications for third-party development: a service-oriented solution

Web applications are nowadays prevalent software systems in our everyday’s life. A lot of these applications have been developed for end users only. Thus, they are not designed by considering future extensions that would be developed by third parties. One possible and interesting solution for opening these applications for such kind of extension development is to create and deploy Web services starting from these applications. In this paper, we present a method and a tool for semiautomatically creating Web service implementations from applications having Web interfaces. The proposed method generates operations that are published in Web services for each functionality provided by a Web application. In addition, it generates new operations starting from Web interfaces. Our approach goes further in the creation of services by generating executable orchestrations, as BPEL processes, starting from navigations in the Web interfaces of these applications and by providing BPMN choreography specifications starting from the collaborations between the generated Web services. We implemented and experimented our solution in the migration of three real-world Web applications toward Web service-oriented systems.     

MOMI: a calculus for mobile mixins

MOMI (Mobile Mixins) is a coordination language for mobile processes that communicate and exchange object-oriented code in a distributed context. MOMI's key idea is structuring mobile object-oriented code by using mixin-based inheritance. Mobile code is compiled and typed locally, and can interact successfully with code present on foreign sites only if its type is subtyping-compliant with the type of what is expected by the receiving site. The key feature of the paper is the definition of this subtyping relation on classes and mixins that enables a significantly flexible, yet still simple, communication pattern. We show that communication by subtyping is type-safe in that exchanged code is merged into local code without requiring further type analysis and recompilation. This work has been partially supported by EU within the FET - Global Computing initiative, project MIKADO IST-2001-32222 and DART project IST-2001-33477 and by MIUR project EOS. The funding bodies are not responsible for any use that might be made of the results presented here.     

Midland: a service-oriented cluster computing infrastructure

Midland is a service-oriented software infrastructure that enables the clustering of arbitrarily large collections of computing resources. The resulting clusters may be integrated to form an open, dynamically configurable computational grid system where each cluster defines a self-reliant and independent management domain. Web Services make up the primary integration mechanism both at the cluster and grid levels, respectively. This is complemented by a light XML based messaging protocol exclusively used for cluster bound interactions. The paper describes Midland’s architecture, and the service-oriented approach taken to develop the associated resource management mechanisms. It also includes an exposition of the model of service capacity which is one of the enablers of the service-centric strategy underlying the cluster management mechanisms. The operational performance of Midland is illustrated experimentally in the context of a Grid test-bed comprising three clusters. The experimental results highlight the performance of the model of service capacity as well as some aspects of Midland operational performance.     

Forgetting techniques for stream-based matrix factorization in recommender systems

Forgetting is often considered a malfunction of intelligent agents; however, in a changing world forgetting has an essential advantage. It provides means of adaptation to changes by removing effects of obsolete (not necessarily old) information from models. This also applies to intelligent systems, such as recommender systems, which learn users’ preferences and predict future items of interest. In this work, we present unsupervised forgetting techniques that make recommender systems adapt to changes of users’ preferences over time. We propose eleven techniques that select obsolete information and three algorithms that enforce the forgetting in different ways. In our evaluation on real-world datasets, we show that forgetting obsolete information significantly improves predictive power of recommender systems.     

SOCAM: a service-oriented computing architecture modeling method

Software and Systems Modeling - Software architecture models are considered first-class artifacts in current software engineering best practices. Thus, usable and well-understood modeling methods...     

StreamPI: a stream-parallel programming extension for object-oriented programming languages

Because multicore CPUs have become the standard with all major hardware manufacturers, it becomes increasingly important for programming languages to provide programming abstractions that can be mapped effectively onto parallel architectures. Stream processing is a programming paradigm where computations are expressed as independent actors that communicate via FIFO data-channels. The coarse-grained parallelism exposed in stream programs facilitates such an efficient mapping of actors onto the underlying multicore hardware. We propose a stream-parallel programming abstraction that extends object-oriented languages with stream-programming facilities. StreamPI consists of a class hierarchy for actor-specification together with a language-independent runtime system that supports the execution of stream programs on multicore architectures. We show that the language-specific part of StreamPI, i.e., the class hierarchy, can be implemented as a library-level programming language extension. A library-level extension has the advantage that an existing programming language implementation need not be touched. Legacy-code can be mixed with a stream-parallel application, and the use of sequential legacy code with actors is supported. Unlike previous approaches, StreamPI allows dynamic creation and subsequent execution of stream programs. StreamPI actors are typed. Type-safety is achieved through type-checks at stream graph creation time. We have implemented StreamPI??s language-independent runtime system and language interfaces for Ada?2005 and C++ for Intel multicore architectures. We have evaluated StreamPI for up to 16 cores on a two?CPU 8-core Intel Xeon X7560 server, and we provide a performance comparison with StreamIt?(Gordon et al. in International Conference on Architectural Support for Programming Languages and Operating Systems, 2006), which is the de facto standard for stream-parallel programming. Although our approach provides greater programming flexibility than StreamIt, the performance of StreamPI compares favorably to the static compilation model of StreamIt.     

The realization of service-oriented e-Marketplaces

Electronic Marketplaces (or e-Marketplaces) require technologies which provide support for the adaptability, flexibility and the integration of business applications in order to meet rapid changes in business environment. Traditional web technologies are unable to meet the new business requirements which are derived from the rapid growth of e-Marketplaces. In this research, a service-oriented framework is proposed in order to address the issues associated with the development of e-Marketplaces. Specifically, it introduces a generic trading model oriented to e-Marketplaces so as to overcome the inadequacy of existing models and to facilitate the development of a computational trading process. In the proposed framework, required services are identified through the utilization of the business-centric trading model. Using a service metamodel, services are equipped with intelligence such that they work seamlessly and coherently within and across e-Marketplaces. A multi-model driven integrated development platform has been developed to support the proposed models and framework. The proposed framework and concepts have been validated through a case study of a mutual funds auction in an e-Marketplace.

Experiences with optimizing two stream-based applications for cluster execution

We explore optimization strategies and resulting performance of two stream-based video applications, video texture and color tracker, on a cluster of SMPs. The two applications are representative of a class of emerging applications, which we call “stream-based applications”, that are sensitive to both latency of individual results and overall throughput. Such applications require non-trivial parallelization techniques in order to improve both latency and throughput, given that the stream data emanates from a limited set of sources (exactly one in the two applications studied) and that the distribution of the data cannot be done a priori.We suggest techniques that address in a coordinated fashion the problems of data distribution and work partitioning. We believe the two problems are related and need to be addressed together. We have parallelized two applications using the Stampede cluster programming system that provides abstractions for implementing time- and throughput-sensitive applications elegantly and efficiently. For the Video Textures application we show that we can achieve a speedup of 24.26 on a 112 processor cluster. For the Color Tracker application, where latency is more crucial, we identify the extent of data parallelism that ensures that the slowest member of the pipeline is no longer the bottleneck for achieving a decent frame rate.     

翻转课堂教学模式的研究——以《程序设计基础》课程为例

针对《程序设计基础》课程的特点和教学中存在的问题,按照"教为主导,学为主体"、"突出能力提升"的理念,提出在课程中应用"翻转课堂"模式改进教学,分别从教学流程、师生角色、学习资源的设计等几个方面陈述了"翻转课堂"的核心,通过课堂实际教学案例说明了该教学模式的创新点,并检验了该模式的教学效果和意义。     

《程序设计基础》实验教学模式改革研究

本文在分析了《程序设计基础》课程实验教学现状的基础上,从教学内容,教学方法以及实验环境等方面对教学模式改革进行了研究,所做的研究具有一定的实用价值。     

CA-PLAN,a service-oriented workflow

Workflow management systems (WfMSs) are accepted worldwide due to their ability to model and control business processes. Previously, we defined an intra-organizational workflow specification model, Process LANguage (PLAN). PLAN, with associated tools, allowed a user to describe a graph specification for processes, artifacts, and participants in an organization. PLAN has been successfully implemented in Agentflow to support workflow (Agentflow) applications. PLAN, and most current WfMSs are designed to adopt a centralized architecture so that they can be applied to a single organization. However, in such a structure, participants in Agentflow applications in different organizations cannot serve each other with workflows. In this paper, a service-oriented cooperative workflow model, Cooperative Agentflow Process LANguage (CA-PLAN) is presented. CA-PLAN proposes a workflow component model to model inter-organizational processes. In CA-PLAN, an inter-organizational process is partitioned into several intra-organizational processes. Each workflow system inside an organization is modeled as an Integrated Workflow Component (IWC). Each IWC contains a process service interface, specifying process services provided by an organization, in conjunction with a remote process interface specifying what remote processes are used to refer to remote process services provided by other organizations, and intra-organizational processes. An IWC is a workflow node and participant. An inter-organizational process is made up of connections among these process services and remote processes with respect to different IWCs. In this paper, the related service techniques and supporting tools provided in Agentflow systems are presented.     

面向服务软件的蜕变测试方法

在面向服务软件的测试过程中,由于在服务发现之前不可知的交互对象和同一个服务可能会有不同实现,往往出现程序执行结果不能提前预知的Oracle问题。为了有效地解决面向服务软件测试中的Oracle问题,基于面向服务架构(SOA)的特点,提出将蜕变测试方法用于面向服务软件的单元测试和集成测试过程中,依据面向服务软件每个服务的自身性质构造蜕变关系,设计蜕变测试类执行测试用例并验证蜕变关系是否保持,如果蜕变关系被违反了,则发现和报告缺陷,从而有效地支持面向服务软件的测试。