Two-Language, Two-Paradigm Introductory Computing Curriculum Model and its Implementation

This paper analyzes difficulties with the introduction of object-oriented concepts in introductory computing education and then proposes a two-language, two-paradigm curriculum model that alleviates such difficulties. Our two-language, two-paradigm curriculum model begins with teaching imperative programming using Python programming language, continues with teaching object-oriented computing using Java, and concludes with teaching object-oriented data structures with Java

Enhancing apprentice-based learning of Java

Various methods have been proposed in the past to improve student learning by introducing new styles of working with assignments. These include problem-based learning, use of case studies and apprenticeship. In most courses, however, these proposals have not resulted in a widespread significant change of teaching methods. Most institutions still use a traditional lecture/lab class approach with a strong separation of tasks between them. In part, this lack of change is a consequence of the lack of easily available and appropriate tools to support the introduction of new approaches into mainstream courses.In this paper, we consider and extend these ideas and propose an approach to teaching introductory programming in Java that integrates assignments and lectures, using elements of all three approaches mentioned above. In addition, we show how the BlueJ interactive programming environment [7] (a Java development environment aimed at education) can be used to provide the type of support that has hitherto hindered the widespread take-up of these approaches. We arrive at a teaching method that is motivating, effective and relatively easy to put into practice. Our discussion includes a concrete example of such an assignment, followed by a description of guidelines for the design of this style of teaching unit

Análisis de las propuestas de la enseñanza de la programación orientada a objetos en los primeros cursos

Existe un fuerte debate sobre qué paradigma conviene impartir en el primer curso de los planes de estudio de Informática: orientación a objetos (OO) o procedimental, así como sobre el lenguaje de soporte de las sesiones prácticas. Muchos artículos presentan sus experiencias o proponen nuevas metodologías de forma aislada, pero no encontramos un estudio sistemático de los distintos enfoques. En este trabajo se presenta una visión crítica de las propuestas de diferentes autores, se evalúan sus ventajas e inconvenientes. Se concluye la necesidad de reconducir el debate de la planificación de los primeros cursos de programación, hoy día centrado en el orden en que se enseñan los paradigmas y el lenguaje para implementarlo, hacia la búsqueda de los conceptos fundamentales y herramientas pedagógicas que permitan una exposición gradual de los conceptos de la programación.Este trabajo se ha financiado con el proyecto TIC2000-1413 de la CICYT

Teaching and learning introductory programming : a model-based approach

The dissertation identifies and discusses impact of a model-based approach to teaching and learning introductory object-oriented programming both for practitioners and for computer science education research.Learning to program is notoriously difficult. This dissertation investigates ways to teach introductory object-oriented programming at the university level. It focuses on a model-based approach, describes and argues for this approach and investigates several of its aspects. It gives an overview of the research in teaching introductory programming in an objects-first way. The dissertation also investigates ways for university teachers to share and document best practices in teaching introductory object-oriented programming through pedagogical patterns. The dissertation addresses both traditional young full-time students and experienced programmers (although not in object-orientation) participating in part-time education. It examines whether the same success factors for learning programming apply to a model-based approach as to introductory programming courses in general for full-time students and gives a general overview of research in success factors for introductory programming. Some factors are the same, because students‘ math competence is positively correlated with their success. The dissertation examines how experienced programmers link a model-based programming course to their professional practices. The general answer is that the part-time students do not need to have a direct link to their specific work-practice, they expect to create the link themselves; but the teacher must be aware of the conditions facing the part-time students in industry. Furthermore, the dissertation addresses interaction patterns for part-time students learning model-based introductory programming in a net-based environment. A previously prepared solution to an exercise is found to mediate the interaction in three different ways. Design patterns have had a major impact on the quality of object-oriented software. Inspired by this, researchers have suggested pedagogical patterns for sharing best practices in teaching introductory object-oriented programming. It was expected that university teachers‘ knowledge of pedagogical patterns was limited, but this research proved that to be wrong; about half of the teachers know pedagogical patterns. One of the problems this dissertation identifies is the lack of a structuring principle for pedagogical patterns; potential users have problems identifying the correct patterns to apply. An alternative structuring principle based on a constructivist learning theory is suggested and analysed

How To Touch a Running System

The increasing importance of distributed and decentralized software architectures entails more and more attention for adaptive software. Obtaining adaptiveness, however, is a difficult task as the software design needs to foresee and cope with a variety of situations. Using reconfiguration of components facilitates this task, as the adaptivity is conducted on an architecture level instead of directly in the code. This results in a separation of concerns; the appropriate reconfiguration can be devised on a coarse level, while the implementation of the components can remain largely unaware of reconfiguration scenarios. We study reconfiguration in component frameworks based on formal theory. We first discuss programming with components, exemplified with the development of the cmc model checker. This highly efficient model checker is made of C++ components and serves as an example for component-based software development practice in general, and also provides insights into the principles of adaptivity. However, the component model focuses on high performance and is not geared towards using the structuring principle of components for controlled reconfiguration. We thus complement this highly optimized model by a message passing-based component model which takes reconfigurability to be its central principle. Supporting reconfiguration in a framework is about alleviating the programmer from caring about the peculiarities as much as possible. We utilize the formal description of the component model to provide an algorithm for reconfiguration that retains as much flexibility as possible, while avoiding most problems that arise due to concurrency. This algorithm is embedded in a general four-stage adaptivity model inspired by physical control loops. The reconfiguration is devised to work with stateful components, retaining their data and unprocessed messages. Reconfiguration plans, which are provided with a formal semantics, form the input of the reconfiguration algorithm. We show that the algorithm achieves perceived atomicity of the reconfiguration process for an important class of plans, i.e., the whole process of reconfiguration is perceived as one atomic step, while minimizing the use of blocking of components. We illustrate the applicability of our approach to reconfiguration by providing several examples like fault-tolerance and automated resource control

Runtime Quantitative Verification of Self-Adaptive Systems

Software systems used in mission- and business-critical applications in domains including defence, healthcare, and finance must comply with strict dependability, performance, and other Quality-of-Service (QoS) requirements. Self-adaptive systems achieve this compliance under changing environmental conditions, evolving requirements and system failures by using closed-loop control to modify their behaviour and structure in response to these events. Runtime quantitative verification (RQV) is a mathematically-based approach that implements the closed-loop control of self-adaptive systems. Using runtime observations of a system and its environment, RQV updates stochastic models whose formal analysis underpins the adaptation decisions made within the control loop. The approach can identify and, under certain conditions, predict violation of QoS requirements, and can drive self-adaptation in ways guaranteed to restore or maintain compliance with these requirements. Despite its merits, RQV has significant computation and memory overheads, which restrict its applicability to small systems and to adaptations affecting only the configuration parameters of the system. In this thesis, we introduce RQV variants that improve the efficiency and scalability of the approach and extend its applicability to larger and more complex self-adaptive software systems, and to adaptations that modify the structure of a system. First, we integrate RQV with established efficiency improvement techniques from other software engineering areas. We use caching of recent analysis results, limited lookahead to precompute suitable adaptations for potential future changes, and nearly-optimal reconfiguration to eliminate the need for an exhaustive analysis of the entire reconfiguration space. Second, we introduce an RQV variant that incorporates evolutionary algorithms into the RQV process facilitating the efficient search through large reconfiguration spaces and enabling adaptations that include structural changes. Third, we propose an RQV-driven approach that decentralises the control loops in distributed self-adaptive systems. Finally, we devise an RQV-based methodology for the engineering of trustworthy self-adaptive systems. We evaluate the proposed RQV variants using prototype self-adaptive systems from several application domains, including an embedded system for unmanned underwater vehicles and a foreign exchange service-based system. Our results, subject to the adaptation scenarios used in the evaluation, demonstrate the effectiveness and generality of the new RQV variants

Graceful Language Extensions and Interfaces

Grace is a programming language under development aimed at education. Grace is object-oriented, imperative, and block-structured, and intended for use in first- and second-year object-oriented programming courses. We present a number of language features we have designed for Grace and implemented in our self-hosted compiler. We describe the design of a pattern-matching system with object-oriented structure and minimal extension to the language. We give a design for an object-based module system, which we use to build dialects, a means of extending and restricting the language available to the programmer, and of implementing domain-specific languages. We show a visual programming interface that melds visual editing (à la Scratch) with textual editing, and that uses our dialect system, and we give the results of a user experiment we performed to evaluate the usability of our interface

Proceedings of the 4th International Conference on Principles and Practices of Programming in Java

This book contains the proceedings of the 4th international conference on principles and practices of programming in Java. The conference focuses on the different aspects of the Java programming language and its applications

Programming Languages and Systems

This open access book constitutes the proceedings of the 28th European Symposium on Programming, ESOP 2019, which took place in Prague, Czech Republic, in April 2019, held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2019