25,575 research outputs found
Initial thoughts on rapid prototyping techniques
This paper sets some context, raises issues, and provides our initial thinking on the characteristics of effective rapid prototyping techniques.After discussing the role rapid prototyping techniques can play in the software lifecycle, the paper looks at possible technical approaches including: heavily parameterized models, reusable software, rapid prototyping languages, prefabrication techniques for system generation, and reconfigurable test harnesses.The paper concludes that a multi-faceted approach to rapid prototyping techniques is needed if we are to address a broad range of applications successfully -- no single technical approach suffices for all potentially desirable applications
Application and systems software in Ada: Development experiences
In its most basic sense software development involves describing the tasks to be solved, including the given objects and the operations to be performed on those objects. Unfortunately, the way people describe objects and operations usually bears little resemblance to source code in most contemporary computer languages. There are two ways around this problem. One is to allow users to describe what they want the computer to do in everyday, typically imprecise English. The PRODOC methodology and software development environment is based on a second more flexible and possibly even easier to use approach. Rather than hiding program structure, PRODOC represents such structure graphically using visual programming techniques. In addition, the program terminology used in PRODOC may be customized so as to match the way human experts in any given application area naturally describe the relevant data and operations. The PRODOC methodology is described in detail
An Exploratory Study of Forces and Frictions affecting Large-Scale Model-Driven Development
In this paper, we investigate model-driven engineering, reporting on an
exploratory case-study conducted at a large automotive company. The study
consisted of interviews with 20 engineers and managers working in different
roles. We found that, in the context of a large organization, contextual forces
dominate the cognitive issues of using model-driven technology. The four forces
we identified that are likely independent of the particular abstractions chosen
as the basis of software development are the need for diffing in software
product lines, the needs for problem-specific languages and types, the need for
live modeling in exploratory activities, and the need for point-to-point
traceability between artifacts. We also identified triggers of accidental
complexity, which we refer to as points of friction introduced by languages and
tools. Examples of the friction points identified are insufficient support for
model diffing, point-to-point traceability, and model changes at runtime.Comment: To appear in proceedings of MODELS 2012, LNCS Springe
Software process modelling as relationships between tasks
Systematic formulation of software process models is currently a challenging problem in software engineering. We present an approach to define models covering the phases of specification, design, implementation and testing of software systems in the component programming framework, taking into account non-functional aspects of software (efficiency, etc.), automatic reusability of implementations in systems and also prototyping techniques involving both specifications and implementations. Our proposal relies on the identification of a catalogue of tasks that appear during these phases which satisfy some relationships concerning their order of execution. A software process model can be defined as the addition of more relationships over these tasks using a simple, modular process language. We have developed also a formal definition of correctness of a software development with respect to a software process model, based on the formulation of models as graphs.Peer ReviewedPostprint (published version
Slisp: A Flexible Software Toolkit for Hybrid, Embedded and Distributed Applications
We describe Slisp (pronounced ‘Ess-Lisp’), a hybrid Lisp–C programming toolkit for the development of scriptable and distributed applications. Computationally expensive operations implemented as separate C-coded modules are selectively compiled into a small Xlisp interpreter, then called as Lisp functions in a Lisp-coded program. The resulting hybrid program may run in several modes: as a stand-alone executable, embedded in a different C program, as a networked server accessed from another Slisp client, or as a
networked server accessed from a C-coded client. Five years of experience with Slisp, as well experience with other scripting languages such as Tcl and Perl, are summarized. These experiences suggest that Slisp will be most useful for mid-sized applications in which the kinds of scripting and embeddability features provided by Tcl and Perl can be extended in an efficient manner to larger applications, while maintaining a
well-defined standard (Common Lisp) for these extensions. In addition, the generality of Lisp makes Lisp a good candidate for an application-level communication language in distributed environments
Design as conversation with digital materials
This paper explores Donald Schön's concept of design as a conversation with materials, in the context of designing digital systems. It proposes material utterance as a central event in designing. A material utterance is a situated communication act that depends on the particularities of speaker, audience, material and genre.
The paper argues that, if digital designing differs from other forms of designing, then accounts for such differences must be sought by understanding the material properties of digital systems and the genres of practice that surround their use. Perspectives from human-computer interaction (HCI) and the psychology of programming are used to examine how such an understanding might be constructed.</p
Experience in using a typed functional language for the development of a security application
In this paper we present our experience in developing a security application
using a typed functional language. We describe how the formal grounding of its
semantic and compiler have allowed for a trustworthy development and have
facilitated the fulfillment of the security specification.Comment: In Proceedings F-IDE 2014, arXiv:1404.578
Using pattern languages in participatory design
In this paper, we examine the contribution that pattern languages could make to user participation in the design of interactive systems, and we report on our experiences of using pattern languages in this way.
In recent years, there has been a growing interest in the use of patterns and pattern languages in the design of interactive systems. Pattern languages were originally developed by the architect, Christopher Alexander, both as a way of understanding the nature of building designs that promote a ‘humane’ or living built environment; and as a practical tool to aid in participatory design of buildings.
Our experience suggests that pattern languages do have considerable potential to support participatory design in HCI, but that many pragmatic issues remain to be resolved.</p
Proceedings of International Workshop "Global Computing: Programming Environments, Languages, Security and Analysis of Systems"
According to the IST/ FET proactive initiative on GLOBAL COMPUTING, the goal is to obtain techniques (models, frameworks, methods, algorithms) for constructing systems that are flexible, dependable, secure, robust and efficient.
The dominant concerns are not those of representing and manipulating data efficiently but rather those of handling the co-ordination and interaction, security, reliability, robustness, failure modes, and control of risk of the entities in the system and the overall design, description and performance of the system itself.
Completely different paradigms of computer science may have to be developed to tackle these issues effectively. The research should concentrate on systems having the following characteristics: • The systems are composed of autonomous computational entities where activity is not centrally controlled, either because global control is impossible or impractical, or because the entities are created or controlled by different owners.
• The computational entities are mobile, due to the movement of the physical platforms or by movement of the entity from one platform to another.
• The configuration varies over time. For instance, the system is open to the introduction of new computational entities and likewise their deletion.
The behaviour of the entities may vary over time.
• The systems operate with incomplete information about the environment.
For instance, information becomes rapidly out of date and mobility requires information about the environment to be discovered.
The ultimate goal of the research action is to provide a solid scientific foundation for the design of such systems, and to lay the groundwork for achieving effective principles for building and analysing such systems.
This workshop covers the aspects related to languages and programming environments as well as analysis of systems and resources involving 9 projects (AGILE , DART, DEGAS , MIKADO, MRG, MYTHS, PEPITO, PROFUNDIS, SECURE) out of the 13 founded under the initiative. After an year from the start of the projects, the goal of the workshop is to fix the state of the art on the topics covered by the two clusters related to programming environments and analysis of systems as well as to devise strategies and new ideas to profitably continue the research effort towards the overall objective of the initiative.
We acknowledge the Dipartimento di Informatica and Tlc of the University of Trento, the Comune di Rovereto, the project DEGAS for partially funding the event and the Events and Meetings Office of the University of Trento for the valuable collaboration
- …