307 research outputs found
Industrial Experience Report on the Formal Specification of a Packet Filtering Language Using the K Framework
Many project-specific languages, including in particular filtering languages, are defined using nonformal
specifications written in natural languages. This leads to ambiguities and errors in the specification
of those languages. This paper reports on an industrial experiment on using a tool-supported
language specification framework (K) for the formal specification of the syntax and semantics of a
filtering language having a complexity similar to those of real-life projects. This experimentation
aims at estimating, in a specific industrial setting, the difficulty and benefits of formally specifying a
packet filtering language using a tool-supported formal approach
Watch the Gap: Making code more intelligible to users without sacrificing decentralization?
The potential for blockchain technology to eliminate the middleman and
replace the top down hierarchical model of governance with a system of
distributed cooperation has opened up many new opportunities, as well as
dilemmas. Surpassing the level of acceptance by early tech adopters, the market
of smart contracts is now moving towards wider acceptance from regular (non
tech) users. For this to happen however, smart contract development will have
to overcome certain technical and legal obstacles to bring the code and the
user closer. Guided by notions from contract law and consumer protection we
highlight the information gap that exists between users, legal bodies and the
source code. We present a spectrum of low-code to no-code initiatives that aim
at bridging this gap, promising the potential of higher regulatory acceptance.
Nevertheless, this highlights the so called "Pitfall of the Trustless Dream",
because arguably solutions to the information gap tend to make the system more
centralized. In this article, we aim to make a practical contribution of
relevance to the wide-spread adoption of smart contracts and their legal
acceptance by analyzing the evolving practices that bring the user and the code
closer
Little languages : little maintenance?
So-called little, or domain-specific languages (DSLs), have the potential to make software maintenance simpler: domain-experts can directly use the DSL to make required routine modifications. At the negative side, however, more substantial changes may become more difficult: such changes may involve altering the domain-specific language. This will require compiler technology knowledge, which not every commercial enterprise has easily available. Based on experience taken from industrial practice, we discuss the role of DSLs in software maintenance, the dangers introduced by using them, and techniques for controlling the risks involved
Electronic Engineering Notebook: A software environment for research execution, documentation and dissemination
The electronic engineering notebook (EEN) consists of a free form research notebook, implemented in a commercial package for distributed hypermedia, which includes utilities for graphics capture, formatting and display of LaTex constructs, and interfaces to the host operating system. The latter capability consists of an information computer-aided software engineering (CASE) tool and a means to associate executable scripts with source objects. The EEN runs on Sun and HP workstations. The EEN, in day-to-day use can be used in much the same manner as the sort of research notes most researchers keep during development of projects. Graphics can be pasted in, equations can be entered via LaTex, etc. In addition, the fact that the EEN is hypermedia permits easy management of 'context', e.g., derivations and data can contain easily formed links to other supporting derivations and data. The CASE tool also permits development and maintenance of source code directly in the notebook, with access to its derivations and data
Towards maintainer script modernization in FOSS distributions
Free and Open Source Software (FOSS) distributions are complex software
systems, made of thousands packages that evolve rapidly, independently, and
without centralized coordination. During packages upgrades, corner case
failures can be encountered and are hard to deal with, especially when they are
due to misbehaving maintainer scripts: executable code snippets used to
finalize package configuration. In this paper we report a software
modernization experience, the process of representing existing legacy systems
in terms of models, applied to FOSS distributions. We present a process to
define meta-models that enable dealing with upgrade failures and help rolling
back from them, taking into account maintainer scripts. The process has been
applied to widely used FOSS distributions and we report about such experiences
HybridMDSD: Multi-Domain Engineering with Model-Driven Software Development using Ontological Foundations
Software development is a complex task. Executable applications comprise a mutlitude of diverse components that are developed with various frameworks, libraries, or communication platforms. The technical complexity in development retains resources, hampers efficient problem solving, and thus increases the overall cost of software production. Another significant challenge in market-driven software engineering is the variety of customer needs. It necessitates a maximum of flexibility in software implementations to facilitate the deployment of different products that are based on one single core.
To reduce technical complexity, the paradigm of Model-Driven Software Development (MDSD) facilitates the abstract specification of software based on modeling languages. Corresponding models are used to generate actual programming code without the need for creating manually written, error-prone assets. Modeling languages that are tailored towards a particular domain are called domain-specific languages (DSLs). Domain-specific modeling (DSM) approximates
technical solutions with intentional problems and fosters the unfolding of specialized expertise. To cope with feature diversity in applications, the Software Product Line Engineering (SPLE)
community provides means for the management of variability in software products, such as feature models and appropriate tools for mapping features to implementation assets.
Model-driven development, domain-specific modeling, and the dedicated management of variability in SPLE are vital for the success of software enterprises. Yet, these paradigms exist in isolation and need to be integrated in order to exhaust the advantages of every single approach. In this thesis, we propose a way to do so.
We introduce the paradigm of Multi-Domain Engineering (MDE) which means model-driven development with multiple domain-specific languages in variability-intensive scenarios. MDE strongly emphasize the advantages of MDSD with multiple DSLs as a neccessity for efficiency in software development and treats the paradigm of SPLE as indispensable means to achieve a maximum degree of reuse and flexibility. We present HybridMDSD as our solution approach to implement the MDE paradigm.
The core idea of HybidMDSD is to capture the semantics of particular DSLs based on properly defined semantics for software models contained in a central upper ontology. Then, the resulting semantic foundation can be used to establish references between arbitrary domain-specific models (DSMs) and sophisticated instance level reasoning ensures integrity and allows to handle partiucular change adaptation scenarios. Moreover, we present an approach to automatically generate composition code that integrates generated assets from separate DSLs. All necessary development tasks are arranged in a comprehensive development process. Finally, we validate the introduced approach with a profound prototypical implementation and an industrial-scale case study.Softwareentwicklung ist komplex: ausfĂŒhrbare Anwendungen beinhalten und vereinen eine Vielzahl an Komponenten, die mit unterschiedlichen Frameworks, Bibliotheken oder Kommunikationsplattformen entwickelt werden. Die technische KomplexitĂ€t in der Entwicklung bindet Ressourcen, verhindert effiziente Problemlösung und fĂŒhrt zu insgesamt hohen Kosten bei der Produktion von Software. ZusĂ€tzliche Herausforderungen entstehen durch die Vielfalt und Unterschiedlichkeit an KundenwĂŒnschen, die der Entwicklung ein hohes MaĂ an FlexibilitĂ€t in Software-Implementierungen abverlangen und die Auslieferung verschiedener Produkte auf Grundlage einer Basis-Implementierung nötig machen.
Zur Reduktion der technischen KomplexitĂ€t bietet sich das Paradigma der modellgetriebenen Softwareentwicklung (MDSD) an. Software-Spezifikationen in Form abstrakter Modelle werden hier verwendet um Programmcode zu generieren, was die fehleranfĂ€llige, manuelle Programmierung Ă€hnlicher Komponenten ĂŒberflĂŒssig macht. Modellierungssprachen, die auf eine bestimmte ProblemdomĂ€ne zugeschnitten sind, nennt man domĂ€nenspezifische Sprachen (DSLs). DomĂ€nenspezifische Modellierung (DSM) vereint technische Lösungen mit intentionalen Problemen und ermöglicht die Entfaltung spezialisierter Expertise. Um der Funktionsvielfalt in Software Herr zu werden, bietet der Forschungszweig der Softwareproduktlinienentwicklung (SPLE) verschiedene Mittel zur Verwaltung von VariabilitĂ€t in Software-Produkten an. Hierzu zĂ€hlen Feature-Modelle sowie passende Werkzeuge, um Features auf Implementierungsbestandteile abzubilden.
Modellgetriebene Entwicklung, domĂ€nenspezifische Modellierung und eine spezielle Handhabung von VariabilitĂ€t in Softwareproduktlinien sind von entscheidender Bedeutung fĂŒr den Erfolg von Softwarefirmen. Zur Zeit bestehen diese Paradigmen losgelöst voneinander und mĂŒssen integriert werden, damit die Vorteile jedes einzelnen fĂŒr die Gesamtheit der Softwareentwicklung entfaltet werden können. In dieser Arbeit wird ein Ansatz vorgestellt, der dies ermöglicht.
Es wird das Multi-Domain Engineering Paradigma (MDE) eingefĂŒhrt, welches die modellgetriebene Softwareentwicklung mit mehreren domĂ€nenspezifischen Sprachen in variabilitĂ€tszentrierten Szenarien beschreibt. MDE stellt die Vorteile modellgetriebener Entwicklung mit mehreren DSLs als eine Notwendigkeit fĂŒr Effizienz in der Entwicklung heraus und betrachtet das SPLE-Paradigma als unabdingbares Mittel um ein Maximum an Wiederverwendbarkeit und FlexibilitĂ€t zu erzielen. In der Arbeit wird ein Ansatz zur Implementierung des MDE-Paradigmas, mit dem Namen HybridMDSD, vorgestellt
Calculational Proofs in ACL2s
Teaching college students how to write rigorous proofs is a critical
objective in courses that introduce formal reasoning. Over the course of
several years, we have developed a mechanically-checkable style of
calculational reasoning that we used to teach over a thousand freshman-level
undergraduate students how to reason about computation in our "Logic and
Computation" class at Northeastern University. We were inspired by Dijkstra,
who advocated the use of calculational proofs, writing "calculational proofs
are almost always more effective than all informal alternatives, ..., the
design of calculational proofs seems much more teachable than the elusive art
of discovering an informal proof." Our calculational proof checker is
integrated into ACL2s and is available as an Eclipse IDE plugin, via a Web
interface, and as a stand-alone tool. It automatically checks proofs for
correctness and provides useful feedback. We describe the architecture of the
checker, its proof format, its underlying algorithms, its correctness and
provide examples using proofs from our undergraduate class and from Dijkstra.
We also describe our experiences using the proof checker to teach
undergraduates how to formally reason about computation
- âŠ