Exception handling in the spreadsheet paradigm

Some legacy programming languages, e.g., C, do not provide adequate support for exception handling. As a result, users of these legacy programming languages often implement exception handling by applying an idiom. An idiomatic style of implementation has a number of drawbacks: applying idioms can be fault prone and requires significant effort. Modern programming languages provide support for structured exception handling (SEH) that makes idioms largely obsolete. Additionally, aspect-oriented programming (AOP) is believed to further reduce the effort of implementing exception handling. This paper investigates the gains that can be achieved by reengineering the idiomatic exception handling of a legacy C component to these modern techniques. First, we will reengineer a C component such that its exception handling idioms are almost completely replaced by SEH constructs. Second, we will show that the use of AOP for exception handling can be beneficial, even though the benefits are limited by inconsistencies in the legacy implementation.

Version 6 of Sun Microsystems' Java HotSpot™ VM ships with a redesigned version of the client just-in-time compiler that includes several research results of the last years. The client compiler is at the heart of the VM configuration used by default for interactive desktop applications. For such applications, low startup and pause times are more important than peak performance. This paper outlines the new architecture of the client compiler and shows how it interacts with the VM. It presents the intermediate representation that now uses static single-assignment (SSA) form and the linear scan algorithm for global register allocation. Efficient support for exception handling and deoptimization fulfills the demands that are imposed by the dynamic features of the Java programming language. The evaluation shows that the new client compiler generates better code in less time. The popular SPECjvm98 benchmark suite is executed 45% faster, while the compilation speed is also up to 40% better. This indicates that a carefully selected set of global optimizations can also be integrated in just-in-time compilers that focus on compilation speed and not on peak performance. In addition, the paper presents the impact of several optimizations on execution and compilation speed. As the source code is freely available, the Java HotSpot™ VM and the client compiler are the ideal basis for experiments with new feedback-directed optimizations in a production-level Java just-in-time compiler. The paper outlines research projects that add fast algorithms for escape analysis, automatic object inlining, and array bounds check elimination.

The synchronous language Esterel is well-suited for programming control-dominated reactive systems at the system level. It provides non-traditional control structures, in particular concurrency and various forms of preemption, which allow to concisely express reactive behavior. As these control structures cannot be mapped easily onto traditional, sequential processors, an alternative approach that has emerged recently makes use of special-purpose reactive processors. However, the designs proposed so far have limitations regarding completeness of the language support, and did not really take advantage of compile-time knowledge to optimize resource usage.This paper presents a reactive processor, the Kiel Esterel Processor 3a (KEP3a), and its compiler. The KEP3a improves on earlier designs in several areas; most notable are the support for exception handling and the provision of context-dependent preemption handling instructions. The KEP3a compiler presented here is to our knowledge the first for multi-threaded reactive processors. The translation of Esterel's preemption constructs onto KEP3a assembler is straightforward; however, a challenge is the correct and efficient representation of Esterel's concurrency. The compiler generates code that respects data and control dependencies using the KEP3a priority-based scheduling mechanism. We present a priority assignment approach that makes use of a novel concurrent control flow graph and has a complexity that in practice tends to be linear in the size of the program. Unlike earlier Esterel compilation schemes, this approach avoids unnecessary context switches by considering each thread's actual execution state at run time. Furthermore, it avoids code replication present in other approaches.

For many years there has been substantial agreement that the content of the CS2 course should be a study of the classic data structures including, but not limited to, stacks, queues, trees, and tables. In recent years we have observed a move to the object-oriented programming paradigm for the CS2 course. At this point there is significant divergence as to the best programming language to use - C++, Eiffel, Java, Oberon, Python, or Scheme, to name a few. Although many agree that to be truly object-oriented, a programming language must support (1) encapsulation of attributes and behavior in a user-defined class specification, (2) instantiation of objects of pre-defined and user-defined classes, (3) polymorphism, and (4) inheritance. From a survey of recent texts for the CS2 course, it appears that there is heavy emphasis on encapsulation and instantiation with some treatment of inheritance and little treatment of polymorphism. There is also significant treatment of generic container classes supported by template classes if the supporting language is C++. If the supporting language is Java, then the container typically manages objects of the type Object. This paper makes a case that Visual Basic .NET could be considered a viable candidate for the CS2 course since it supports user-defined class specifications with the encapsulation of attributes and behavior, instantiation of objects of pre-defined and user-defined classes, polymorphism and inheritance. Additionally, there is full support for exception handling using the now, well-known, try/catch/finally semantics. Further, there is support for dynamic memory allocation and deallocation. And finally, the student or developer has full support for visual, event-driven, net-centric programming paradigm.This paper is a follow-up to a series of papers several years ago by the same author. These papers made a case for the use of Visual Basic in CS2 even though, at the time, Visual Basic was not yet fully object-oriented. This paper will present an implementation of a stack container ADT that is fully generic, that is, it may manage a collection of arbitrary objects that demonstrate polymorphic behavior.

ChatGPT is a powerful tool that assists software engineers in identifying and rectifying errors in code. One of its primary advantages is its ability to engage in natural language conversation with humans, which allows it to collaborate more closely with engineers in improving and optimizing the code. However, despite its potential advantages, software developers do not always utilize ChatGPT as a tool for bug fixing. In this study, we aim to examine the factors that influence the adoption of ChatGPT for bug fixing among professional software developers, based on the Unified Theory of Acceptance and Use of Technology (UTAUT) theory. To accomplish this, we conducted 50 semi-structured interviews with professional software developers and other stakeholders. Our findings indicate that the performance expectancy and effort expectancy of professional software developers, as well as social influence, facilitating conditions, data security, and trust are the key factors of adoption. These findings suggest that understanding these factors can be critical in promoting the adoption and use of ChatGPT in the software development industry.

The lab exercises that follow will give us an opportunity to practice what we have learned. We should complete the labs by referring to the book chapters when we are unsure about how to do something, but more importantly we should look at the previous code we have written. The code we have written should be an invaluable source of working code, and it is important not to "reinvent the wheel." Use the code - copy, paste, and amend it if required. Reuse the code – that is what the professional developer would do and is expected to do. Professional software developers are expected to create applications as fast and accurately as possible, and reusing existing code is one technique they apply, so why should we be any different?

Eclipse is a powerful integrated development environment (IDE) for Java1 targeted at professional software developers. However, Eclipse is poorly suited for use in introductory computing education because the complexity of its interface and the associated computing environment can overwhelm beginners. In contrast, DrJava is a friendly, highly interactive IDE targeted at teaching Java to beginners. DrJava has a simple interface consisting of a Definitions pane for entering and editing program text and an Interactions pane for evaluating arbitrary Java statements and expressions given the program in the Definitions pane. This interface frees students from the complication of defining main methods for their programs and encourages them to explore the Java language by conducting simple experiments.We have developed a plug-in for Eclipse, based largely on the existing DrJava code base, that provides an Interactions pane to Eclipse with precisely the same capabilities as the Interactions pane in DrJava, along with a simplified user interface. With this plug-in, Eclipse becomes a suitable vehicle for teaching introductory programming, enabling instructional programs to use the same IDE for all levels of the programming curriculum. In addition, it provides professional developers with a convenient mechanism for interactively evaluating arbitrary program text during program development --- a common feature of programming interfaces for functional languages like Scheme and ML.

Background: In the contemporary ‘knowledge-driven’ European society, the quality and relevance of Continuing Professional Development (CPD) for teachers and Physical Education teachers (PE-CPD) has come under scrutiny. National contexts within Europe vary considerably, however, so there is a need to gain analytical insights into PE-CPD structures and practices in these contexts. The Greek PE-CPD context has been under-researched in contrast to other countries. Purpose: To report data from a study on PE-CPD undertaken in Greece. The study analysed national PE-CPD policy within a wider European framework, and sought the insights of teachers and CPD providers on the nature and quality of existing provision and suggested improvements that could better support teachers' learning. Participants and setting: A qualitative and descriptive research design was selected and the study was conducted in three overlapping phases. In phase one, nine PE teachers were identified as in-depth case studies in order to gain a detailed understanding of their career-long CPD experiences; in phase two, these data were used to design in-depth CPD profile questionnaires that were distributed to 70 PE teachers working in both primary and secondary schools (returned by 58); and in phase three, six CPD stakeholders (e.g. school advisor, university tutors) were interviewed in order to understand how the study participants' experiences were shaped by key stakeholders and the broader Greek policy context. Research design: The study design took account of Borko's suggestion that an understanding of the professional development process must be based on a thorough analysis of all elements of a professional development system (e.g. policy, teachers and CPD providers). Data analysis: Interview data were analysed using a constructivist version of ‘grounded’ theory in combination with thematic analysis. Findings: Data showed that there was a strong sense of teacher frustration because of inadequate and limited structured support. The majority of the research participants also claimed that PE-CPD opportunities were narrow in scope, limiting these PE teachers' ability to address their pressing questions and to meet the philosophical expectations underpinning education and physical education in the Greek system. There was also a shared understanding that PE teachers were treated as ‘passive learners’, a key factor that shaped their ability to learn and change their practices. An innovative PE-CPD programme was identified illustrating, however, the diverse nature of provision. The CPD stakeholders' accounts revealed that, at the time of the research, the local PE-CPD system could be in a transition phase. Conclusion: The findings from this study suggest that if the goal is to create knowledge-driven, evidence-based teaching professionals, PE-CPD implementation must be regularly monitored and evaluated with a clear focus on building teachers' capacity for career-long learning.

Software developers typically use multiple large screens in their office setup. However, they often work away from the office where such a setup is not available, instead only working with a laptop computer and drastically reduced screen real estate. We explore how developers can be better supported in ad-hoc scenarios, for example when they work in a cafe, an airport, or at a client's site. We present insights into current work practices and challenges when working away from the usual office desk sourced from a survey of professional software developers. Based on these insights, we introduce an IDE that makes use of additional personal devices, such as a phone or a tablet. Parts of the IDE can be offloaded to these mobile devices, for example the application that is being developed, a debugging console or navigational elements. A qualitative evaluation with professional software developers showed that they appreciate the increased screen real estate.

Training for pre-service and in-service teachers that is delivered through distance education methods solves various problems of traditional professional development. These problems include issues such as providing a consistent message, training large numbers of personnel, and overcoming scheduling and funding problems. As with other forms of instruction, professional development training materials should be subjected to a level of evaluation that increases the likelihood of successful implementation. However, it is unclear how this need for evaluation of professional development software is being met. Commercial software companies have been found to eschew evaluation of their products and classroom teachers can be expected to conduct only limited software evaluations of the software. This article contends that educational researchers are well positioned to conduct comprehensive evaluations of the professional development software they create. This purpose of this review of the literature is to (a) consolidate the database of literature with regard to professional development software, (b) examine the degree to which the software described in the literature has been comprehensively evaluated, and (c) provide suggestions for future research.

Past studies show that developers who navigate code in a structural manner complete tasks faster and more correctly than those whose behavior is more opportunistic. The goal of this work is to move professional developers towards more effective program comprehension and maintenance habits by providing an approach that fosters structural code navigation. To this end, we created a Visual Studio plugin called Prodet that integrates an always-on navigable visualization of the most contextually relevant portions of the call graph. We evaluated the effectiveness of our approach by deploying it in a six week field study with professional software developers. The study results show a statistically significant increase in developers' use of structural navigation after installing Prodet. The results also show that developers continuously used the filtered and navigable call graph over the three week period in which it was deployed in production. These results indicate the maturity and value of our approach to increase developers' effectiveness in a practical and professional environment.

Unit testing is an established practice in professional software development. However, in high-performance computing (HPC) with its scientific applications, it is not widely applied. Besides general problems regarding testing of scientific software, for many HPC applications the effort of creating small test cases with a consistent set of test data is high.We have created a tool called FortranTestGenerator, that significantly reduces the effort of creating unit tests for subroutines of an existing Fortran application. It is based on Capture & Replay (C&R), that is, it extracts data while running the original application and uses the extracted data as test input data. The tool automatically generates code for capturing the input data and a basic test driver which can be extended by the developer to an appropriate unit test. A static source code analysis is conducted, to reduce the number of captured variables. Code is generated based on flexibly customizable templates. Thus, both the capturing process and the unit tests can easily be integrated into an existing software ecosystem.Since most HPC applications use message passing for parallel processing, we also present an approach to extend our C&R model to MPI communication. This allows extraction of unit tests from massively parallel applications that can be run with a single process.

No abstract available.

PROMPT [1] is an educational initiative in cooperation with several academic parties and leading industrial companies and organizations. Together, the parties offer advanced level courses in software engineering in a web-based format, tailored to fit professional engineers and software developers who need to be able to combine full-time work and studies. The long-term goal of PROMPT is to guarantee the supply of advanced software competencies and innovativeness in industry. The courses are free of charge within Europe, cover typically 7.5 university credits and are run over a whole semester, at a pace of 25% of full-time. All courses are developed in close cooperation with the Swedish industry and trade organizations.

End-user software engineering (EUSE) is a research area that aims to invent new kinds of technologies that collaborate with end users to improve the quality of their software. The practice that EUSE research aims to support is end users using new tools and methods to improve the quality of the software that they and other end users have created. There is a need for this outcome because research shows both that the number of end users creating their own software greatly exceeds the number of professional software developers, and that the software they create is riddled with errors. In this paper, we describe the present state of EUSE, and challenges in moving forward toward a bright future. We show how the future of EUSE may become over-siloed, restricting future researchers' vision of what can be achieved. We then show that focusing on the in-the-moment intents of end-user developers can be used to derive a number of promising directions forward for EUSE researchers, and how theories can help us further de-silo future EUSE research. Finally, we discuss how overcoming challenges for the future of end-user software engineering may also bring direct benefits to the future of "classic" software engineering.