Search

Designing and programming require several types of knowledge. Beside conceptual knowledge, procedural knowledge is of importance. Procedural knowledge, however, is often missed in courses about software design and implementation. As a consequence, students can easily be stuck and do not know how to proceed.Considering software engineering as a complex task, the didactic approach 4C/ID is applicable. This approach prescribes that besides mental models, cognitive strategies should be learned, consisting of overall steps and rules and procedures per step. As an example, a procedure for designing and programming a concurrent program is briefly described. This procedure will scaffffold studentfis learning of concurrency concepts and their application.

Software robustness is an ever-challenging problem in the face of today's evolving software and hardware that has undergone recent shifts. Instruction-grain monitoring is a powerful approach for improved software robustness that affords comprehensive runtime coverage for a wide spectrum of bugs and security exploits. Unfortunately, existing instruction-grain monitoring frameworks, such as dynamic binary instrumentation, are either prohibitively expensive (slowing down applications by an order of magnitude or more) or offer limited coverage. This work introduces BugSifter, a new design that drastically decreases monitoring overhead without sacrificing flexibility or bug coverage. The main overhead of instruction-grain monitoring lies in execution of software event handlers to monitor nearly every application instruction to check for bugs. BugSifter identifies common monitoring activities that result in redundant monitoring actions, and filters them using general, light-weight hardware, eliminating the majority of costly software event handlers. Our proposed design filters 80-98% of events while monitoring for a variety of commonly-occurring bugs, delegating the rest to flexible software handlers. BugSifter significantly reduces the overhead of instruction-grain monitoring to an average of 40% over unmonitored application time. BugSifter makes instruction-grain monitoring practical, enabling efficient and timely detection of a wide range of bugs, thus making software more robust.

Soft robotics is a growing field of research and one of its challenges is how to efficiently design a controller for a soft morphology.This paper presents a marine soft robot inspired by the ghost knifefish that swims on the water surface by using an undulating fin underneath its body. We investigate how propagating wave functions can be evolved and how these affect the swimming performance of the robot. The fin and body of the robot are constructed from silicone and six wooden fin rays actuated by servo motors. In order to bypass the reality gap, which would necessitate a complex simulation of the fish, we implemented a Covariance Matrix Adaptation Evolution Strategy (CMA-ES) directly on the physical robot to optimize its controller for travel speed. Our results show that evolving a simple sine wave or a Fourier series can generate controllers that outperform a hand programmed controller. The results additionally demonstrate that the best evolved controllers share similarities with the undulation patterns of actual knifefish. Based on these results we suggest that evolution on physical robots is promising for future application in optimizing behaviors of soft robots. Soft robotics is a growing field of research and one of its challenges is how to efficiently design a controller for a soft morphology.This paper presents a marine soft robot inspired by the ghost knifefish that swims on the water surface by using an undulating fin underneath its body. We investigate how propagating wave functions can be evolved and how these affect the swimming performance of the robot. The fin and body of the robot are constructed from silicone and six wooden fin rays actuated by servo motors. In order to bypass the reality gap, which would necessitate a complex simulation of the fish, we implemented a Covariance Matrix Adaptation Evolution Strategy (CMA-ES) directly on the physical robot to optimize its controller for travel speed. Our results show that evolving a simple sine wave or a Fourier series can generate controllers that outperform a hand programmed controller. The results additionally demonstrate that the best evolved controllers share similarities with the undulation patterns of actual knifefish. Based on these results we suggest that evolution on physical robots is promising for future application in optimizing behaviors of soft robots.

© 2018 Association for Computing Machinery. In the state-of-practice, developing web applications requires dealing with multiple programming languages or codebases. To address this issue, researchers have proposed multi-tier languages such as Hop or Links that support client and server development in a single language and in one codebase. Even if such multi-tier languages are often strongly based on an existing language - for instance Hop is based on Scheme - they are new languages, and require a new compiler. The objective of this paper is to define a multi-tier language as a library-based Scala DSL. Scala already supports compilation to both the Java VM and to JavaScript. The multi-tier language we propose in this paper, Scalagna, combines the existing Scala JVM and JavaScript ecosystems into a single programming model without requiring changes to, or rewrites of the existing Scala compilers. We discuss how this is possible using Scala's excellent support for definining DSLs, and the experimental Scala macro system. We show that Scalagna has reasonable performance, and by porting an existing Eliom application, we provide evidence that Scalagna is as expressive as other established and existing multi-tier languages. location: Nice, France numpages: 6 acmid: 3191731 keywords: Scala, multi-tier, web programming ispartof: pages:69-74 ispartof: Programming'18 Companion: Conference Companion of the 2nd International Conference on Art, Science, and Engineering of Programming vol:Part F137691 pages:69-74 ispartof: ProWeb location:Nice, France date:9 Apr - 12 Apr 2018 status: published

This paper explores the concept of files as directories (FAD) as a unified interface to structured data within a file by representing such a file as (virtual) directory and the structured data as subdirectories and subfiles. Transparent conversion of files and their structured data into directory trees is to be handled by virtual filesystem providers. This allows for arbitrary applications and programming languages to read and write data within supported file types without the need to understand the file format - e.g., in order to modify pixel values within an image file, paragraphs in a text document, or settings in a configuration file. Advantages of this approach compared to API-mediated file access might include better learnability, modularity, explorability, synchronous access, better integration of proprietary applications, and a few other nice features. While technical issues of the FAD concept have been discussed by developers in the past, no major operating system allows FAD at the moment. In this paper I present concept, advantages, limitations, and use cases of FAD.

© 2017 ACM. Web applications are inherently event-driven and traditionally implemented using imperative callbacks in Javascript. An alternative approach for such programs is functional reactive programming (FRP). FRP offers abstractions to make event-driven programming convenient, safe and composable, but like pure functions it is isolated from the 'outside' world. In this paper we describe our experience in developing a library that binds FRP to the document object model (DOM). We describe that in its current state there are fundamental issues that do not yet have a perfect solution. We expand upon the functionality of existing FRP DOM libraries with an FRP model for DOM properties. We show that despite of some design problems a pragmatic library can be created that can be used to create web applications. location: Brussels, Belgium articleno: 23 numpages: 6 acmid: 3079405 ispartof: pages:23:1-23:1 ispartof: Programming '17: International Conference on the Art, Science, and Engineering of Programming vol:Part F129681 ispartof: ProWeb location:Brussels date:3 Apr - 3 Apr 2017 status: published

A recent trend in application development for the web is a move towards rich internet applications (RIAs). As more and more of the application logic is moved to the client, RIAs can benefit from concurrency in order to increase overall performance as well as responsiveness of the application. Additionally, RIAs are often written in an event-driven style of programming to react to incoming events of a multitude of services that are integrated within the application. In this paper we argue that, while individual technologies exist to tackle both concerns, these technologies cannot easily be integrated in an ad hoc way. To increase the modularisability and composability of RIAs we propose a new programming model based on actors and reactors that encapsulate different parts of the application. We show that our model is able to exploit some of the available concurrency while reducing the required amount of event-driven code. Both actors and reactors are modular components that can be glued together via a unified communication mechanism. We evaluate our approach by means of a motivating example of a collaborative code editor.

The Internet of Things (IoT) requires us to rethink the way distributed event-driven applications are programmed. IoT applications differ from traditional distributed applications on a number of points. First, they are comprised of an order of magnitude more devices that operate within a dynamic network. Second, failure in large dynamic networks is no longer an exceptional state but a given and thus needs to be part of the core semantics when programming such networks. Third, the hardware in these networks is not homogeneous so that a common software stack is impossible. We believe that contemporary event-driven languages do not offer appropriate abstractions to write IoT applications. We propose a novel computational model for programming IoT applications by identifying four key abstractions for designating network nodes and handle failures that facilitate writing large-scale IoT applications.

International audience; Most of our interactions with the digital world are mediated by apps: desktop, web, or mobile applications. Apps impose artificial limitations on collaboration among users, distribution across devices, and the changing procedures that constantly occur in real work. These limitations are partially due to the engineering principles of encapsulation and program-data separation. By contrast, the field of hypermedia envisions collaboration , distribution and flexible practices as fundamental features of software. We discuss shareable dynamic media, an alternative model for software that unifies hypermedia and interactive systems, and Webstrates, an experimental implementation of that model. We give examples of patterns and challenges for software architecture that have emerged in our experimentation with Webstrates, and show that it subverts the principles of encapsulation and program-data separation.

Designing a secure software system requires the ability to represent and reason about a wide variety of security concerns. Existing modelling representations lack a comprehensive set of security building blocks or lack support for composition or refinement of the design under consideration. We propose a new modular meta-model for representing these security designs. This model supports both composition for more complex solutions and representing different levels of abstraction to model the underlying details. This meta-model can subsequently be used for the construction of security solutions, supporting a wide range of mechanisms on a wide variety of abstraction levels, thereby providing a foundation for the security-by-design approach. ispartof: pages:16-16 ispartof: Programming '17: Companion to the First International Conference on the Art, Science and Engineering of Programming vol:Part F129681 pages:16-16 ispartof: Modularity in Modelling (MoMo) location:Brussels, Belgium date:3 Apr - 3 Apr 2017 status: published