Service-oriented computing: key concepts and principles

Traditional approaches to software development - the ones embodied in CASE tools and modeling frameworks - are appropriate for building individual software components, but they are not designed to face the challenges of open environments. Service-oriented computing provides a way to create a new architecture that reflects components' trends toward autonomy and heterogeneity. We thus emphasize SOC concepts instead of how to deploy Web services in accord with current standards. To begin the series, we describe the key concepts and abstractions of SOC and the elements of a corresponding engineering methodology.     

Integrating a case-based reasoning shell and Web 2.0: design recommendations and insights

The design and implementation of case-based reasoning (CBR) applications is time-consuming. To facilitate the development of CBR applications in various problem domains, the CBR community has created a number of CBR shells and software frameworks in the past twenty years. This paper provides a review of the state-of-the-art of CBR shells and software frameworks, highlights why the integration of Web 2.0 and CBR development tools is useful, and gives an example as to how we implement such integration. We use this example to illustrate how Web 2.0 features such as blogging functions can be integrated in a CBR system. Design recommendations and insights for implementing a Web 2.0-based CBR shell are also provided.     

Ranking open source application integration frameworks based on maintainability metrics: A review of five-year evolution

Integration frameworks are specialized software tools built and adapted to facilitate the design and implementation of integration solutions. An integration solution allows for the reuse of applications from the software ecosystem of companies to support their business processes. There are several open-source integration frameworks available on the market designed to operate in a business context to manipulate structured data; however, increasingly, they are required to deal with unstructured and large volumes of data, thus requiring effort to adapt these frameworks to work with unstructured and large volume of data. Choosing the framework, which is the easiest to be adapted, is not a trivial task. In this article, we review the newest stable versions of four open-source integration frameworks by analyzing how they have evolved regarding their adaptive maintainability over five years. We rank them according to their maintainability degree and compare past and current versions of each framework. To encourage and enable researchers and developers to replicate our experiments, with the aim of verifying our findings, and to experiment with new versions of the integration frameworks analyzed, we detail the experimental protocol used while also having made all the required software involved available on the Web.     

An object based algebra for specifying a fault tolerant software architecture

In this paper we present an algebra of actors extended with mechanisms to model crash failures and their detection. We show how this extended algebra of actors can be successfully used to specify distributed software architectures. The main components of a software architecture can be specified following an object-oriented style and then they can be composed using asynchronous message passing or more complex interaction patterns. This formal specification can be used to show that several requirements of a software system are satisfied at the architectural level despite failures. We illustrate this process by means of a case study: the specification of a software architecture for intelligent agents which supports a fault tolerant anonymous interaction protocol.     

The role of computer-aided modelling in learning physics

Abstract Physics education should take the chance to link research about students' alternative frameworks and new teaching strategies with the use of modern information technology tools. The article shows how iconic model building software like STELLA can be used to help students gain a deeper qualitative conceptual understanding.     

Efficient Abstractions for GPGPU Programming

General purpose (GP)GPU programming demands to couple highly parallel computing units with classic CPUs to obtain a high performance. Heterogenous systems lead to complex designs combining multiple paradigms and programming languages to manage each hardware architecture. In this paper, we present tools to harness GPGPU programming through the high-level OCaml programming language. We describe the SPOC library that allows to handle GPGPU subprograms (kernels) and data transfers between devices. We then present how SPOC expresses GPGPU kernel: through interoperability with common low-level extensions (from Cuda and OpenCL frameworks) but also via an embedded DSL for OCaml. Using simple benchmarks as well as a real world HPC software, we show that SPOC can offer a high performance while efficiently easing development. To allow better abstractions over tasks and data, we introduce some parallel skeletons built upon SPOC as well as composition constructs over those skeletons.     

基于软件体系结构的测试及其工具研究

1 引言软件体系结构层测试的目的是找出体系结构的错误和缺陷,这与传统测试有很大的不同。SA测试分为体系结构的静态测试(即体系结构分析)和体系结构的动态测试(即体系结构模拟)两个方面。前者是对体系结构的静态行为特征进行分析,如各类一致性分析等;后者是对体系结构的动态行为特征进行模拟。 SA中的结构模式提供了一个设计和分析大型软件系统的自然框架,也为可重用的构件提供了组合成系统的规则。通过对软件体系结构的描述,使得复杂系统的测试与分析变得     

An evaluation of expert system development tools

Abstract: There is a significant amount of interest in expert systems and the software tools that are available for developing these systems. Most tools that are developed at university research labs are described in some detail in books, articles, or technical reports. However, there is a need for objective information on commercial software tools for building expert systems. These tools can be used for research, prototyping and developing end-user applications. Necessarily we must establish a set of criteria which can be used to evaluate these tools. These criteria include an evaluation of the basic features, the development environment, what a tool can be used for, how easy it is to learn and use, how much it costs, and how it is supported. In the first part of this paper, a set of criteria is described for evaluating expert system software tools. In the second part, these criteria are used to evaluate several currently available commercial tools.     

Extending the reflexion method for consolidating software variants into product lines

Software variants emerge from ad-hoc copying in-the-large with adaptations to a specific context. As the number of variants increases, maintaining such software variants becomes more and more difficult and expensive. In contrast to such ad-hoc reuse, software product lines offer organized ways of reuse, taking advantage of similarities of different products. To re-gain control, software variants may be consolidated as organized software product lines. In this paper, we describe a method and supporting tools to compare software variants at the architectural level extending the reflexion method to software variants. Murphy’s reflexion method allows one to reconstruct the module view, a static architectural view describing the static components, their interfaces and dependencies and their grouping as layers and subsystems. The method consists of the specification of the module view and the mapping of implementation components onto the module view. An automatic analysis determines differences between the module view and its implementation. We extend the reflexion method from single systems to software variants. Because software variants share a very large amount of code, we can expect components of one variant to re-occur in the other variant either identically or at least similarly. We use similarity metrics to determine this type of correspondence among implementation components between two variants. Because the similarity metrics are expensive to compute, we use clone detection techniques to reduce the number of candidate pairs of implementation components for which the similarity is computed. The correspondence is then used to transfer as much as possible of the mapping for the analyzed variants to the next variant to be analyzed. Furthermore, we describe how to unify the individual product architectures into a software product line architecture.     

基于RISC-V架构的强化学习容器化方法研究

RISC-V作为近年来最热门的开源指令集架构,被广泛应用于各个特定领域的微处理器,特别是机器学习领域的模块化定制.但是,现有的RISC-V应用需要将传统软件或模型在RISC-V指令集上重新编译或优化,故如何能快速地在RISC-V体系结构上部署、运行和测试机器学习框架是一个亟待解决的技术问题.使用虚拟化技术可以解决跨平台...     

Interfacing the hardware API with a feature-based operating system family

Multiprocessor systems on a chip (MPSoCs) are a popular class of course-grained parallel computer architectures, which are very useful, because they support re-use of legacy software components and application-specific tailoring of hardware structures at the same time. Furthermore, model-driven design frameworks for MPSoCs such as Xilinx’ EDK or our own LavA-framework facilitate very fast system development. However, in this paper we argue that these design frameworks are not ideal from the development process perspective. Instead, we propose a software-centric approach that is based on the hardware API concept. The API is a representation of hardware components on the software level, which is generated from a hardware meta-model. It allows us to automatically derive a hardware structure based on access patterns in software, revealed by a static code analysis. This trick reduces the number of hardware details the developer needs to deal with and avoids configuration inconsistencies between the hardware and software levels by design. Furthermore, we present how the development process can benefit from the hardware API, when the API is interfaced with a configurable operating system.     

A model-driven approach for the derivation of architectural requirements of software product lines

The alignment of the software architecture and the functional requirements of a system is a demanding task because of the difficulty in tracing design elements to requirements. The four-step rule set (4SRS) is a unified modeling language (UML)-based model-driven method for single system development which provides support to the software architect in this task. This paper presents an evolution of the 4SRS method aimed at software product lines. In particular, we describe how to address the transformation of functional requirements (use cases) into component-based requirements for the product line architecture. The result is a UML-based model-driven method that can be applied in combination with metamodeling tools such as the eclipse modeling framework (EMF) to derive the architecture of software product lines. We present our approach in a practical way and illustrate it with an example. We also discuss how our proposals are related to the work of other authors.     

ABE: an environment for engineering intelligent systems

The ABE multilevel architecture for developing intelligent systems addresses the key problems of intelligent systems engineering: large-scale applications and the reuse and integration of software components. ABE defines a virtual machine for module-oriented programming and a cooperative operating system that provides access to the capabilities of that virtual machine. On top of the virtual machine, ABE provides a number of system design and development frameworks, which embody such programming metaphors as control flow, blackboards, and dataflow. These frameworks support the construction of capabilities, including knowledge processing tools, which span a range from primitive modules to skeletal systems. Finally, applications can be built on skeletal systems. In addition, ABE supports the importation of existing software, including both conventional and knowledge processing tools     

Scientific workflows with the jABC framework

The jABC is a framework for process modelling and execution according to the XMDD (eXtreme model-driven design) paradigm, which advocates the rigorous use of user-level models in the software development process and software life cycle. We have used the jABC in the domain of scientific workflows for more than a decade now—an occasion to look back and take stock of our experiences in the field. On the one hand, we discuss results from the analysis of a sample of nearly 100 scientific workflow applications that have been implemented with the jABC. On the other hand, we reflect on our experiences and observations regarding the workflow development process with the framework. We then derive and discuss ongoing further developments and future perspectives for the framework, all with an emphasis on simplicity for end users through increased domain specificity. Concretely, we describe how the use of the PROPHETS synthesis plugin can enable a semantics-based simplification of the workflow design process, how with the jABC4 and DyWA frameworks more attention is paid to the ease of data management, and how the Cinco SCCE Meta-Tooling Suite can be used to generate tailored workflow management tools.     

High Level Data Structures for GPGPU Programming in a Statically Typed Language

To increase software performance, it is now common to use hardware accelerators. Currently, GPUs are the most widespread accelerators that can handle general computations. This requires to use GPGPU frameworks such as Cuda or OpenCL. Both are very low-level and make the benefit of GPGPU programming difficult to achieve. In particular, they require to write programs as a combination of two subprograms, and, to manually manage devices and memory transfers. This increases the complexity of the overall software design. The idea we develop in this paper is to guarantee expressiveness and safety for CPU and GPU computations and memory managements with high-level data-structures and static type-checking. In this paper, we present how statically typed languages, compilers and libraries help harness high level GPGPU programming. In particular, we show how we added high-level user-defined data structures to a GPGPU programming framework based on a statically typed programming language: OCaml. Thus, we describe the introduction of records and tagged unions shared between the host program and GPGPU kernels described via a domain specific language as well as a simple pattern matching control structure to manage them. Examples, practical tests and comparisons with state of the art tools, show that our solutions improve code design, productivity, and safety while providing a high level of performance.