White-box methodologies, programming abstractions and libraries

EXCESS deliverable D2.2. More information at http://www.excess-project.eu/This deliverable reports the results of white-box methodologies and early results ofthe first prototype of libraries and programming abstractions as available by projectmonth 18 by Work Package 2 (WP2). It reports i) the latest results of Task 2.2on white-box methodologies, programming abstractions and libraries for developingenergy-efficient data structures and algorithms and ii) the improved results of Task2.1 on investigating and modeling the trade-off between energy and performance ofconcurrent data structures and algorithms. The work has been conducted on two mainEXCESS platforms: Intel platforms with recent Intel multicore CPUs and MovidiusMyriad1 platform

Using the Internet of Things to Teach Good Software Engineering Practice to High School Students

This paper describes a course to introduce high school students to software engineering in practice using the Internet Of Things (IoT). IoT devices allow students to get quick, visible results without watering down technical aspects of programming and networking. The course has three broad goals: (1) to make software engineering fun and applicable, with the aim of recruiting traditionally underrepresented groups into computing; (2) to make young students begin to approach problems with a design mindset; and (3) to show students that computer science, generally, and software engineering, specifically, is about much more than programming. The course unfolds in three segments. The first is a whirlwind introduction to a subset of IoT technologies. Students complete a specific task (or set of tasks) using each technology. This segment culminates in a “do-it-yourself” project, in which the students implement a simple IoT application using their basic knowledge of the technologies. The course’s second segment introduces software engineering practices, again primarily via hands-on practical tutorials. In the third segment of the course, the students conceive of, design, and implement a project that uses the technologies introduced in the first segment, all while being attentive to the good software engineering practices acquired in the second segment. In addition to presenting the course curriculum, the paper also discusses a first offering of the course in a threeweek summer intensive program in 2017, including assessments done to evaluate the curriculum.Cockrell School of Engineerin

Semi-Automated SVG Programming via Direct Manipulation

Direct manipulation interfaces provide intuitive and interactive features to a broad range of users, but they often exhibit two limitations: the built-in features cannot possibly cover all use cases, and the internal representation of the content is not readily exposed. We believe that if direct manipulation interfaces were to (a) use general-purpose programs as the representation format, and (b) expose those programs to the user, then experts could customize these systems in powerful new ways and non-experts could enjoy some of the benefits of programmable systems. In recent work, we presented a prototype SVG editor called Sketch-n-Sketch that offered a step towards this vision. In that system, the user wrote a program in a general-purpose lambda-calculus to generate a graphic design and could then directly manipulate the output to indirectly change design parameters (i.e. constant literals) in the program in real-time during the manipulation. Unfortunately, the burden of programming the desired relationships rested entirely on the user. In this paper, we design and implement new features for Sketch-n-Sketch that assist in the programming process itself. Like typical direct manipulation systems, our extended Sketch-n-Sketch now provides GUI-based tools for drawing shapes, relating shapes to each other, and grouping shapes together. Unlike typical systems, however, each tool carries out the user's intention by transforming their general-purpose program. This novel, semi-automated programming workflow allows the user to rapidly create high-level, reusable abstractions in the program while at the same time retaining direct manipulation capabilities. In future work, our approach may be extended with more graphic design features or realized for other application domains.Comment: In 29th ACM User Interface Software and Technology Symposium (UIST 2016

Metamodel-based model conformance and multiview consistency checking

Model-driven development, using languages such as UML and BON, often makes use of multiple diagrams (e.g., class and sequence diagrams) when modeling systems. These diagrams, presenting different views of a system of interest, may be inconsistent. A metamodel provides a unifying framework in which to ensure and check consistency, while at the same time providing the means to distinguish between valid and invalid models, that is, conformance. Two formal specifications of the metamodel for an object-oriented modeling language are presented, and it is shown how to use these specifications for model conformance and multiview consistency checking. Comparisons are made in terms of completeness and the level of automation each provide for checking multiview consistency and model conformance. The lessons learned from applying formal techniques to the problems of metamodeling, model conformance, and multiview consistency checking are summarized

A meta-semantic language for smart component-adapters

The issues confronting the software development community today are significantly different from the problems it faced only a decade ago. Advances in software development tools and technologies during the last two decades have greatly enhanced the ability to leverage large amounts of software for creating new applications through the reuse of software libraries and application frameworks. The problems facing organizations today are increasingly focused around systems integration and the creation of information flows. Software modeling based on the assembly of reusable components to support software development has not been successfully implemented on a wide scale. Several models for reusable software components have been suggested which primarily address the wiring-level connectivity problem. While this is considered necessary, it is not sufficient to support an automated process of component assembly. Two critical issues that remain unresolved are: (1) semantic modeling of components, and (2) deployment process that supports automated assembly. The first issue can be addressed through domain-based standardization that would make it possible for independent developers to produce interoperable components based on a common set of vocabulary and understanding of the problem domain. This is important not only for providing a semantic basis for developing components but also for the interoperability between systems. The second issue is important for two reasons: (a) eliminate the need for developers to be involved in the final assembly of software components, and (b) provide a basis for the development process to be potentially driven by the user. To resolve the above remaining issues (1) and (2) a late binding mechanism between components based on meta-protocols is required. In this dissertation we address the above issues by proposing a generic framework for the development of software components and an interconnection language, COMPILE, for the specification of software systems from components. The computational model of the COMPILE language is based on late and dynamic binding of the components\u27 control, data, and function properties. The use of asynchronous callbacks for method invocation allows control binding among components to be late and dynamic. Data exchanged between components is defined through the use of a meta- language that can describe the semantics of the information but without being bound to any specific programming language type representation. Late binding to functions is accomplished by maintaining domain-based semantics as component metainformation. This information allows clients of components to map generic requested service to specific functions

A methodology for component-based system integration

Component-based software based on software architectures is emerging to be the next generation software development paradigm. The paradigm shifts the development focus from lines-of-codes to coarser-grained components and the interconnections among them. It consists of system architecture design, architecture description, component search and system integration from components to generate a software system. However, one of the bottlenecks in this paradigm is the integration of the individual components into the overall system. In this dissertation a methodology for component-based system integration is proposed. It is based on an architectural aggregation view, a component model, flowgraphs and cyclomatic complexity. We introduce this view, model, and new ways to compute cyclomatic complexity based on flowgraphs. The methodology makes use of Jackson diagram to represent the detailed design of a system and decomposes the system into components and aggregations. An aggregation is a set of components glued together by one connector, and is represented as a flowgraph. Then an aggregation flowgraph is decomposed into prime flowgraphs called prime connections. An Implementation Description Language (IDL) is introduced to represent the aggregations and components. Finally a system synthesis mechanism is proposed that is responsible for translating prime connections, embedding functional units into them, and composing aggregations and the integrated system from them