Hide Implementation Details Research Articles

Parallel programming in mobile devices with FancyJCL

Mobile devices and handheld systems, such as the smartphones and tablets universally extended, are becoming increasingly powerful. Their basic hardware configuration is usually state-of-the-art heterogeneous architectures consisting of multi-core processors and some kind of accelerator such as GPUs or DSPs. Specific code adapted to the architecture is mandatory if high-performance computation is required and low-level libraries and parallelism are needed, which constitutes an important barrier for the usual developer in such devices. In this context, we propose the FancyJCL framework. It provides a high-level abstraction layer that hides implementation details and allows to develop parallel programs for mobile devices. The target platform for FancyJCL is mainly Android and Java developers due to their high market penetration. A very simple, seemingly sequential encoding results in parallel efficient OpenCL code. FancyJCL is itself based on the Fancier framework, which enables optimal memory management across memory spaces on unified memory systems. Benchmarks of FancyJCL code developed for a wide range of image processing algorithms show good performance with low development effort.

CEPchain: A graphical model-driven solution for integrating complex event processing and blockchain

Blockchain provides an immutable distributed ledger for storing transactions. One of the challenges of blockchain is the particular processing of dynamic queries due to accumulating costs. Complex Event Processing (CEP) provides efficient and effective support for this in a way, however, that is difficult to integrate with blockchain. This paper addresses the research challenges of integrating blockchain with CEP. More specifically, we envision an effective development environment in which (i) event-driven smart contracts are modeled in a graphical way, which are, in turn, (ii) automatically transformed into complementary code that is deployed in both a CEP engine and a blockchain network, and then (iii) executed on off-chain CEP applications which, connected to different data sources and sinks, automatically invoke smart contracts when event pattern conditions are met. We follow a classic systems engineering approach for defining the concepts of our system, called CEPchain, which addresses the described requirements. CEPchain was evaluated using a real-world case study for vaccine delivery, which requires an unbroken cold chain. The results demonstrate that our approach can be applied without requiring experts on event processing and smart contract languages. Our contribution simplifies the design of integrated CEP and blockchain functionality by hiding implementation details and supporting efficient deployment.

Characterizing Visual Programming Approaches for End-User Developers: A Systematic Review

Recently many researches have explored the potential of visual programming in robotics, the Internet of Things (IoT), and education. However, there is a lack of studies that analyze the recent evidence-based visual programming approaches that are applied in several domains. This study presents a systematic review to understand, compare, and reflect on recent visual programming approaches using twelve dimensions: visual programming classification, interaction style, target users, domain, platform, empirical evaluation type, test participants' type, number of test participants, test participants' programming skills, evaluation methods, evaluation measures, and accessibility of visual programming tools. The results show that most of the selected articles discussed tools that target IoT and education, while other fields such as data science, robotics are emerging. Further, most tools use abstractions to hide implementation details and use similar interaction styles. The predominant platforms for the tools are web and mobile, while desktop-based tools are on the decline. Only a few tools were evaluated with a formal experiment, whilst the remaining ones were evaluated with evaluation studies or informal feedback. Most tools were evaluated with students with little to no programming skills. There is a lack of emphasis on usability principles in the design stage of the tools. Additionally, only one of the tools was evaluated for expressiveness. Other areas for exploration include supporting end users throughout the life cycle of applications created with the tools, studying the impact of tutorials on improving learnability, and exploring the potential of machine learning to improve debugging solutions developed with visual programming.

Large-scale Interactive Numerical Experiments of Chaos, Solitons and Fractals in Real Time via GPU in a Web Browser.

The study of complex systems has emerged as an important field with many discoveries still to be made. Computer simulation and visualization provide important tools for studying complex dynamics including chaos, solitons, and fractals, but available computing power has been a limiting factor. In this work, we describe a novel and highly efficient computing and visualization paradigm using a Web Graphics Library (WebGL 2.0) methodology along with our newly developed library (Abubu.js). Our approach harnesses the power of widely available and highly parallel graphics cards while maintaining ease of use by simplifying programming through hiding implementation details, running in a web browser without the need for compilation, and avoiding the use of plugins. At the same time, it allows for interactivity, such as changing parameter values on the fly, and its computing is so fast that zooming in on a region of a fractal like the Mandelbrot set can incur no delay despite having to recalculate values for the entire plane. We demonstrate our approach using a wide range of complex systems that display dynamics from fractals to standing and propagating waves in 1, 2 and 3 dimensions. We also include some models with instabilities that can lead to chaotic dynamics. For all the examples shown here we provide links to the codes for anyone to use, modify and further develop with other models. Overall, the enhanced visualization and computation capabilities provided by WebGL together with Abubu.js have great potential to facilitate new discoveries about complex systems.

Modular Termination Verification of Single-Threaded and Multithreaded Programs

We propose an approach for the modular specification and verification of total correctness properties of object-oriented programs. The core of our approach is a specification style that prescribes a way to assign a level expression to each method such that each callee’s level is below the caller’s, even in the presence of dynamic binding. The specification style yields specifications that properly hide implementation details. The main idea is to use multisets of method names as levels, and to associate with each object levels that abstractly reflect the way the object is built from other objects. A method’s level is then defined in terms of the method’s own name and the levels associated with the objects passed as arguments. We first present the specification style in the context of programs that do not modify object fields. We then combine it with separation logic and abstract predicate families to obtain an approach for programs with heap mutation. In a third step, we address concurrency, by incorporating an existing approach for verifying deadlock freedom of channels and locks. Our main contribution here is to achieve information hiding by using the proposed termination levels for lock ordering as well. Also, we introduce call permissions to enable elegant verification of termination of programs where threads cause work in other threads, such as in thread pools or fine-grained concurrent algorithms involving compare-and-swap loops. We explain how our approach can be used also to verify the liveness of nonterminating programs.

Polymorphic Manifest Contracts, Revised and Resolved

Manifest contracts track precise program properties by refining types with predicates—for example, { x :Int∣ x > 0} denotes the positive integers. Contracts and polymorphism make a natural combination: programmers can give strong contracts to abstract types, precisely stating pre- and post conditions while hiding implementation details— for instance, an abstract type of stacks might specify that the pop operation has input type { x :α Stack ∣ not (empty x )}. This article studies a polymorphic calculus with manifest contracts and establishes fundamental properties including type soundness and relational parametricity. Indeed, this is not the first work on polymorphic manifest contracts, but existing calculi are not very satisfactory. Gronski et al. developed the S age language, which introduces polymorphism through the Type:Type discipline, but they do not study parametricity. Some authors of this article have produced two separate works: Belo et al. [2011] and Greenberg [2013] studied polymorphic manifest contracts and parametricity, but their calculi have metatheoretical problems in the type conversion relations. Indeed, they depend on a few conjectures, which turn out to be false. Our calculus is the first polymorphic manifest calculus with parametricity, depending on no conjectures—it resolves the issues in prior calculi with delayed substitution on casts.

Decentralised LTL monitoring

Users wanting to monitor distributed or component-based systems often perceive them as monolithic systems which, seen from the outside, exhibit a uniform behaviour as opposed to many components displaying many local behaviours that together constitute the system's global behaviour. This level of abstraction is often reasonable, hiding implementation details from users who may want to specify the system's global behaviour in terms of a linear-time temporal logic (LTL) formula. However, the problem that arises then is how such a specification can actually be monitored in a distributed system that has no central data collection point, where all the components' local behaviours are observable. In this case, the LTL specification needs to be decomposed into sub-formulae which, in turn, need to be distributed amongst the components' locally attached monitors, each of which sees only a distinct part of the global behaviour. The main contribution of this paper is an algorithm for distributing and monitoring LTL formulae, such that satisfaction or violation of specifications can be detected by local monitors alone. We present an implementation and show that our algorithm introduces only a negligible delay in detecting satisfaction/violation of a specification. Moreover, our practical results show that the communication overhead introduced by the local monitors is generally lower than the number of messages that would need to be sent to a central data collection point. Furthermore, our experiments strengthen the argument that the algorithm performs well in a wide range of different application contexts, given by different system/communication topologies and/or system event distributions over time.

NeoIDL: A Domain Specific Language for Specifying REST Contracts Detailed Design and Extended Evaluation

Service-oriented computing has emerged as an effective approach for integrating business (and systems) that might spread throughout different organizations. A service is a unit of logic modularization that hides implementation details using well-defined contracts. However, existing languages for contract specification in this domain present several limitations. For instance, both WSDL and Swagger use language-independent data formats (XML and JSON) that are not suitable for specifying contracts and often lead to heavyweight specifications. Interface description languages, such as CORBA IDL and Apache Thrift, solve this issue by providing specific languages for contract specifications. Nevertheless, these languages do not target to the REST architectural style and lack support for language extensibility. In this paper we present the design and implementation of NeoIDL, an extensible domain specific language and program generator for writing REST based contracts that are further translated into service’s implementations. In addition, we also present a systematic evaluation of our approach from different perspectives, which involved the implementation of different services using NeoIDL from the domain of Command & Control. In particular, we found initial evidences that shows that NeoIDL can contribute: (i) to bring return on investment with respect to the design and development of NeoIDL, after the implementation of 4 to 7 services; and (ii) to reduce significantly the number of lines of specification when compared to an existing service specification language such as Swagger.

Audit: A new synchronization API for the GET/PUT protocol

The GET/PUT protocol is considered an effective communication API for parallel computing. However, the one-sided nature of the GET/PUT protocol lacks synchronization functionality for the target process. To date, several techniques have been proposed to tackle this problem. The APIs suggested thus far have failed to hide implementation details of the synchronization functionality. In this paper, a new synchronization API for the GET/PUT protocol is proposed. The central idea here is to associate synchronization flags with the GET/PUT memory regions. Using this technique, synchronization flags are hidden from users, and they are freed from managing the associations between the memory regions and the synchronization flags. The proposed API, named Audit, does not incur additional programming and thus enables natural parallel programming. The evaluations show that Audit exhibits better performance compared to the Notify API proposed in ARMCI.

The architecture of MEG simulation and analysis software

MEG (Mu to Electron Gamma) is an experiment dedicated to search for the $\mu^+ \rightarrow e^+\gamma$ decay that is strongly suppressed in the Standard Model but predicted in several Super Symmetric extensions of it at an accessible rate. MEG is a small-size experiment ($\approx 50-60$ physicists at any time) with a life span of about 10 years. The limited human resource available, in particular in the core offline group, emphasized the importance of reusing software and exploiting existing expertise. Great care has been devoted to provide a simple system that hides implementation details to the average programmer. That allowed many members of the collaboration to contribute to the development of the software of the experiment with limited programming skill. The offline software is based on two frameworks: {\bf REM} in FORTRAN 77 used for the event generation and detector simulation package {\bf GEM}, based on GEANT 3, and {\bf ROME} in C++ used in the readout simulation {\bf Bartender} and in the reconstruction and analysis program {\bf Analyzer}. Event display in the simulation is based on GEANT 3 graphic libraries and in the reconstruction on ROOT graphic libraries. Data are stored in different formats in various stage of the processing. The frameworks include utilities for input/output, database handling and format conversion transparent to the user.

On The Roles of APIs in the Coordination of Collaborative Software Development

The principle of information hiding has been very influential in software engineering since its inception in 1972. This principle prescribes that software modules hide implementation details from other modules in order to reduce their dependencies. This separation also decreases the dependency among software developers implementing these modules, thus simplifying the required coordination. A common instantiation of this principle widely used in the industry is in the form of application programming interfaces (APIs). While previous studies report on the general use and benefits of APIs, they have glossed over the detailed ways in which APIs facilitate the coordination of work. In order to unveil these mechanisms, we performed a qualitative study on how practitioners use APIs in their daily work. Using ethnographic data from two different software development teams, we identified three roles played by APIs in the coordination of software development projects. These roles are described using three metaphors: APIs as contracts, APIs as boundaries, and APIs as communication mechanisms. As contracts, APIs allow software developers to work in parallel and independently. As a communication mechanism, APIs facilitate communication among software developers by giving them something specific to talk about. At the same time, APIs establish the boundaries between developers, and, accordingly, what should be talked about. This paper also reports on problems the studied teams face when using APIs to coordinate their work. Based on these results, we draw theoretical implications for collaborative software engineering.

Principles in Practice

This paper deals with good software design principle. On what do you base your design decisions-established conventions, past experience, or principles? The author discusses about three principles that seemed to underlie many of those experts decisions: 1) distribute behavior among objects (rather than concentrate it into a single controlling object). 2) preserve design flexibility by hiding implementation details.3) define abstractions and interfaces first (before focusing on data and coding details).

New Software Framework to Share Research Tools

Solid Earth Teaching and Research Environment (SEATREE) is a modular and user‐friendly software to facilitate the use of solid Earth research tools in the classroom and for interdisciplinary research collaboration. The software provides a stand‐alone open‐source package that allows users to operate in a “black box” mode, which hides implementation details, while also allowing them to dig deeper into the underlying source code. The overlying user interfaces are written in the Python programming language using a modern, object‐oriented design, including graphical user interactions. SEATREE, which provides an interface to a range of new and existing lower level programs that can be written in any computer programming language, may in the long run contribute to new ways of sharing scientific research. By sharing both data and modeling tools in a consistent framework, published (numerical) experiments can be made truly reproducible again.

Information management in distributed collaborative systems: The case of collaboration studio

This paper presents the Collaboration Studio (CS) system, its argumentation and data-structuring models and gives some insights for dealing with information divergence. The system allows discussions among a group of participants that includes a coordinator. The working mechanisms implemented within CS are perfectly transparent to the user, hiding implementation details, giving an appealing and user-friendly environment, and so users do not have to worry about patterns of data distribution, or the details of distribution management. CS shares characteristics with other collaboration computational tools, such as synchronous and asynchronous support and both group working spaces and a local working space. However, its main purpose differs in that, instead of trying to achieve a single document as the outcome of the joint work of several users, CS aims to achieve a broader objective, which is to register (and to demonstrate) the “path” used to obtain certain knowledge.

Integrating biological research through Web services

Web services might be a way to solve the integration problem because Web services technology provides a higher layer of abstraction that hides implementation details from applications. Using this technology, applications invoke other applications' functions through well-defined, easy-to-use interfaces. To test the potential of a Web services solution, we implemented a microarray data-mining system that uses Web services in drug discovery - a research process that attempts to identify new avenues for developing therapeutic drugs. Although our implementation focuses on a problem within the life sciences, we strongly believe that Web services could be a boon to any research field that requires analyzing volumes of data and conducting complex data mining.

How a good software practice thwarts collaboration

The principle of information hiding has been very influential in software engineering since its inception in 1972. This principle prescribes that software modules hide implementation details from other modules in order to decrease their interdependencies. This separation also decreases the dependency among software developers implementing modules, thus simplifying some aspects of collaboration. A common instantiation of this principle is in the form of application programming interfaces (APIs). We performed a qualitative study on how practitioners use APIs in their daily work. Although particularly interested in aspects of collaboration, we report all findings about their observed use. The findings include mundane observations that are predicted by theory, ways that APIs support collaborative software development. But the findings also include some surprises, ways that APIs hinder collaboration. The surprises indicate directions for further improvement of collaborative software development practices and tools.

An Abstract Module Concept for Graph Transformation Systems

Abstract Graph transformation systems are a well known formal specification technique that support the rule based specification of the dynamic behaviour of systems. Recently, many specification languages for graph transformation systems have been developed, and modularization techniques are then needed in order to deal with large and complex graph transformation specifications, to enhance the reuse of specifications, and to hide implementation details. In this paper we present an abstract categorical approach to modularization of graph transformation systems. Modules are called cat –modules and defined over a generic category cat of graph transformation specifications and morphisms. We describe the main characteristics and properties of cat –modules, their interconnection operations, namely union, composition and refinement of modules, and some compatibility properties between such operations.

An Abstract Module Concept for Graph Transformation Systems

Graph transformation systems are a well known formal specification technique that support the rule based specification of the dynamic behaviour of systems. Recently, many specification languages for graph transformation systems have been developed, and modularization techniques are then needed in order to deal with large and complex graph transformation specifications, to enhance the reuse of specifications, and to hide implementation details. In this paper we present an abstract categorical approach to modularization of graph transformation systems. Modules are called cat–modules and defined over a generic category cat of graph transformation specifications and morphisms. We describe the main characteristics and properties of cat–modules, their interconnection operations, namely union, composition and refinement of modules, and some compatibility properties between such operations.

AN ARCHITECTURE FOR DATA WAREHOUSING SUPPORTING DATA INDEPENDENCE AND INTEROPERABILITY

We report on the design of a novel architecture for data warehousing based on the introduction of an explicit "logical" layer to the traditional data warehousing framework. This layer serves to guarantee a complete independence of OLAP applications from the physical storage structure of the data warehouse and thus allows users and applications to manipulate multidimensional data ignoring implementation details. For example, it makes possible the modification of the data warehouse organization (e.g. MOLAP or ROLAP implementation, star scheme or snowflake scheme structure) without influencing the high level description of multidimensional data and programs that use the data. Also, it supports the integration of multidimensional data stored in heterogeneous OLAP servers. We propose [Formula: see text], a simple data model for multidimensional databases, as the reference for the logical layer. [Formula: see text] provides an abstract formalism to describe the basic concepts that can be found in any OLAP system (fact, dimension, level of aggregation, and measure). We show that [Formula: see text] databases can be implemented in both relational and multidimensional storage systems. We also show that [Formula: see text] can be profitably used in OLAP applications as front-end. We finally describe the design of a practical system that supports the above logical architecture; this system is used to show in practice how the architecture we propose can hide implementation details and provides a support for interoperability between different and possibly heterogeneous data warehouse applications.

A message-passing class library C++ for portable parallel programming

An object-oriented message-passing class library in C++, called PPI++, for portable parallel programming has been developed. PPI++ (parallel portability interface in C++) is designed to serve as a stable (unchanging) interface between the client parallel code and the rapidly evolving distributed computing environments. By taking advantage of encapsulation, inheritance, and polymorphism supported by C++, PPI++ provides a clean and consistent programming interface, which helps improve the clarity and expressiveness of client parallel codes and hides implementation details and complexity from the user to ease parallel programming tasks. In addition, the use of strong type-checking in C++ allows the detection of potential misuses of the library at compile time, and thus promotes code reliability. This paper describes the object-oriented design and implementation of PPI++. Evaluation of PPI++ on important performance issues, such as portability, ease-of-use, extensibility, and efficiency, is also discussed.