Designing Software Architectures As a Composition of Specializations of Knowledge Domains

This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience

Enhancing simulation education with intelligent tutoring systems

The demand for education in the area of simulation is in the increase. This paper describes how education in the field of simulation can take advantage of the virtues of intelligent tutoring with respect to enhancing the educational process. For this purpose, this paper gives an overview of what constitutes the objectives and the content of a comprehensive course in discrete event simulation. The architecture of an intelligent tutoring system is presented and it is discussed how these sophisticated learning aids offer individualised student guidance and support within a learning environment. The paper then introduces a prototype intelligent tutoring system, the simulation tutor, and suggests how the system might be developed to enhance education in simulation

Out-Of-Place debugging: a debugging architecture to reduce debugging interference

Context. Recent studies show that developers spend most of their programming time testing, verifying and debugging software. As applications become more and more complex, developers demand more advanced debugging support to ease the software development process. Inquiry. Since the 70's many debugging solutions were introduced. Amongst them, online debuggers provide a good insight on the conditions that led to a bug, allowing inspection and interaction with the variables of the program. However, most of the online debugging solutions introduce \textit{debugging interference} to the execution of the program, i.e. pauses, latency, and evaluation of code containing side-effects. Approach. This paper investigates a novel debugging technique called \outofplace debugging. The goal is to minimize the debugging interference characteristic of online debugging while allowing online remote capabilities. An \outofplace debugger transfers the program execution and application state from the debugged application to the debugger application, both running in different processes. Knowledge. On the one hand, \outofplace debugging allows developers to debug applications remotely, overcoming the need of physical access to the machine where the debugged application is running. On the other hand, debugging happens locally on the remote machine avoiding latency. That makes it suitable to be deployed on a distributed system and handle the debugging of several processes running in parallel. Grounding. We implemented a concrete out-of-place debugger for the Pharo Smalltalk programming language. We show that our approach is practical by performing several benchmarks, comparing our approach with a classic remote online debugger. We show that our prototype debugger outperforms by a 1000 times a traditional remote debugger in several scenarios. Moreover, we show that the presence of our debugger does not impact the overall performance of an application. Importance. This work combines remote debugging with the debugging experience of a local online debugger. Out-of-place debugging is the first online debugging technique that can minimize debugging interference while debugging a remote application. Yet, it still keeps the benefits of online debugging ( e.g. step-by-step execution). This makes the technique suitable for modern applications which are increasingly parallel, distributed and reactive to streams of data from various sources like sensors, UI, network, etc

Traits at Work: the design of a new trait-based stream library

International audienceRecent years saw the development of a composition mechanism called Traits. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition. To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not exhibit all possible composition problems, since the hierarchies were previously expressed using single inheritance and following certain patterns. This paper presents our work on designing and implementing a new trait-based stream library named Nile. It evaluates how far traits enable reuse, what problems can be encountered when building a library using traits from scratch and compares the traits solution to alternative composition mechanisms. Nile's core allows the de?nition of compact collection and ?le streaming libraries as well as the implementation of a backward-compatible new stream library. Nile method size shows a reduction of 40% compared to the Squeak equivalent. The possibility to reuse the same set of traits to implement two distinct libraries is a concrete illustration of trait reuse capability

Separable User Interface Architectures in Teaching Object Technology

This paper concerns the critical role of separable user interface design in teaching object-oriented systems. M206 "Computing: An Object-oriented Approach" is a large-scale university-level introduction to software development designed from scratch for distance learning, using an objects-first approach with Smalltalk. The course is degree-level, counting as one sixth, and is being offered in the UK, Western Europe and Singapore. To address the needs of industry we have developed a radical syllabus that adheres to the principle of designing complex systems by separating view and model, and have developed a programming and learning environment to support these ideas. In the paper we examine how separable user interface architectures have guided our teaching of object technology and the design of powerful microworlds that are both usable and extendible by neophytes. The course and relevant teaching with software is outlined and the technical design and pedagogic use of the microworlds and GUI builder tool are described

A Programming Environment Evaluation Methodology for Object-Oriented Systems

The object-oriented design strategy as both a problem decomposition and system development paradigm has made impressive inroads into the various areas of the computing sciences. Substantial development productivity improvements have been demonstrated in areas ranging from artificial intelligence to user interface design. However, there has been very little progress in the formal characterization of these productivity improvements and in the identification of the underlying cognitive mechanisms. The development and validation of models and metrics of this sort require large amounts of systematically-gathered structural and productivity data. There has, however, been a notable lack of systematically-gathered information on these development environments. A large part of this problem is attributable to the lack of a systematic programming environment evaluation methodology that is appropriate to the evaluation of object-oriented systems

Enhancing the early home learning environment through a brief group parenting intervention: study protocol for a cluster randomised controlled trial.

BACKGROUND: The quality of the home learning environment has a significant influence on children's language and communication skills during the early years with children from disadvantaged families disproportionately affected. This paper describes the protocol and participant baseline characteristics of a community-based effectiveness study. It evaluates the effects of 'smalltalk', a brief group parenting intervention (with or without home coaching) on the quality of the early childhood home learning environment. METHODS/DESIGN: The study comprises two cluster randomised controlled superiority trials (one for infants and one for toddlers) designed and conducted in parallel. In 20 local government areas (LGAs) in Victoria, Australia, six locations (clusters) were randomised to one of three conditions: standard care (control); smalltalk group-only program; or smalltalk plus (group program plus home coaching). Programs were delivered to parents experiencing socioeconomic disadvantage through two existing age-based services, the maternal and child health service (infant program, ages 6-12 months), and facilitated playgroups (toddler program, ages 12-36 months). Outcomes were assessed by parent report and direct observation at baseline (0 weeks), post-intervention (12 weeks) and follow-up (32 weeks). Primary outcomes were parent verbal responsivity and home activities with child at 32 weeks. Secondary outcomes included parenting confidence, parent wellbeing and children's communication, socio-emotional and general development skills. Analyses will use intention-to-treat random effects ("multilevel") models to account for clustering. RECRUITMENT AND BASELINE DATA: Across the 20 LGAs, 986 parents of infants and 1200 parents of toddlers enrolled and completed baseline measures. Eighty four percent of families demonstrated one or more of the targeted risk factors for poor child development (low income; receives government benefits; single, socially isolated or young parent; culturally or linguistically diverse background). DISCUSSION: This study will provide unique data on the effectiveness of a brief group parenting intervention for enhancing the early home learning environment of young children from disadvantaged families. It will also provide evidence of the extent to which additional one-on-one support is required to achieve change and whether there are greater benefits when delivered in the 1st year of life or later. The program has been designed for scale-up across existing early childhood services if proven effective. TRIAL REGISTRATION: 8 September 2011; ACTRN12611000965909 .This research was commissioned and funded by the Victorian Government Department of Education and Early Childhood (now the Department of Education and Training, DET). JN, MT, SB, TH, VH, EW and NH were employees of the Parenting Research Centre when this study was designed and conducted. JN, SB, EW & NH are currently supported by the Australian Communities Foundation through the Roberta Holmes Transition to Contemporary Parenthood Program (Coronella sub-fund); EW was part-funded by the Centre for Research Excellence in Child Language at Murdoch Children’s Research Institute (NHMRC grant 1023493). OU is funded by the UK National Institute for Health Research (NIHR) Collaboration for Leadership in Applied Health Research and Care (CLAHRC) for the South West Peninsula at the Royal Devon and Exeter NHS Foundation Trust. The views expressed in this publication are those of the authors and not necessarily those of the funding bodies

Benzo: Reflective Glue for Low-level Programming

International audienceThe goal of high-level low-level programming is to bring the abstraction capabilities of high-level languages to the system programming domain, such as virtual machines (VMs) and language runtimes. However, existing solutions are bound to compilation time and expose limited possibilities to be changed at runtime and from language-side. They do not fit well with fully reflective languages and environments. We propose Benzo1, a lightweight framework for high- level low-level programming that allows developers to generate and execute at runtime low-level code (assembly). It promotes the implementation, and dynamic modification, of system components with high-level language tools outperforming existing dynamic solutions. Since Benzo is a general framework we choose three applications that cover an important range of the spectrum of system programming for validating the infrastructure: a For- eign Function Interface (FFI), primitives instrumentation and a just-in-time bytecode compiler (JIT). With Benzo we show that these typical VM-level components are feasible as reflective language-side implementations. Due to its unique combination of high-level reflection and low-level programming, Benzo shows better performance for these three applications than the comparable high-level implementations

The role of concurrency in an evolutionary view of programming abstractions

In this paper we examine how concurrency has been embodied in mainstream programming languages. In particular, we rely on the evolutionary talking borrowed from biology to discuss major historical landmarks and crucial concepts that shaped the development of programming languages. We examine the general development process, occasionally deepening into some language, trying to uncover evolutionary lineages related to specific programming traits. We mainly focus on concurrency, discussing the different abstraction levels involved in present-day concurrent programming and emphasizing the fact that they correspond to different levels of explanation. We then comment on the role of theoretical research on the quest for suitable programming abstractions, recalling the importance of changing the working framework and the way of looking every so often. This paper is not meant to be a survey of modern mainstream programming languages: it would be very incomplete in that sense. It aims instead at pointing out a number of remarks and connect them under an evolutionary perspective, in order to grasp a unifying, but not simplistic, view of the programming languages development process