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.     

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.     

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.     

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.     

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     

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.     

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.     

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.     

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.     

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.     

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...     

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.

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

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

Fragtypes: a basis for programming environments

The author introduces a novel basis for programming environments that encourages development of software in fragments of various types, called fragtypes. Fragtypes range from a simple expression type to a complete subsystem type. As a result, they are suited to the development of software in an enlarged scope that includes both programming in the small and programming in the large. The author shows how proposed operations on fragtypes can achieve unusual effects on the software development process. Fragtypes and their associated construction rules form the basis of the programming environment MUPE-2, which is currently under development at McGill University. The target and the implementation language of this environment is the programming language Modula-2     

Web Services技术综述--一种面向服务的分布式计算模式

Web Services引出了新一代的分布式计算模式。首先介绍了Web Service的基本概念,分析了面向服务的计算模式。然后阐述了Web Services的核心支撑技术：XML,SOAP,WSDL,UDDI以及扩展的协议栈。将Web Services与已广泛应用的分布式对象计算模式CORBA进行了详细比较,分析了它们的特点和优劣,指出了各自的应用领域。最后分析了Web Services当前研究状况,指出了下一步研究方向。     

Exploring service-oriented system engineering challenges: a systematic literature review

Service-oriented system engineering (SOSE) has drawn increasing attention since service-oriented computing was introduced in the beginning of this decade. A large number of SOSE challenges that call for special software engineering efforts have been proposed in the research community. Our goal is to gain insight into the current status of SOSE research issues as published to date. To this end, we conducted a systematic literature review exploring SOSE challenges that have been claimed between January 2000 and July 2008. This paper presents the results of the systematic review as well as the empirical research method we followed. In this review, of the 729 publications that have been examined, 51 were selected as primary studies, from which more than 400 SOSE challenges were elicited. By applying qualitative data analysis methods to the extracted data from the review, we proved our hypotheses about the classification scheme. We are able to conclude that the SOSE challenges can be classified along two dimensions: (a) based on themes (or topics) that they cover and (b) based on characteristics (or types) that they reveal. By analyzing the distribution of the SOSE challenges on the topics and types in the years 2000–2008, we are able to point out the trend in SOSE research activities. The findings of this review further provide empirical evidence for establishing future SOSE research agendas.