Structure editors have been available for many decades, and for multiple programming languages. Historically, they have been recommended for teaching new programmers. Currently, they are recommended by advocates of Model Driven Development. However, they are not widely used, except for the special case of graphical structure editors commonly referred to as "block-based editors" such as Scratch. Although structure editors were first introduced for procedural languages, and they could be used for any type of language, current structure editors target object-oriented languages, almost exclusively, and build in many assumptions related to object orientation. The notable exception, Hazel, targets a functional language, exploits the strong typing typical of functional languages and emphasizes the use of typed holes. This thesis introduces ElmSr, a structure editor developed for teaching the Elm programming language to novice programmers. As with most structure editors, ElmSr allows the developer to directly edit the Abstract Syntax Tree, without the intermediary of a compiler. As with Hazel, ElmSr's AST is typed, and transformations preserve types. Also typical of tree editors written in functional languages, ElmSr uses a zipper data structure to encode both the tree and a cursor position, making for efficient tree edits. Like other structure editors, ElmSr is designed to make common tasks simple and efficient. In our case, common tasks match the steps students are taught in the "Algebraic Thinking" curriculum developed at McMaster University. Some steps are common to almost all programming, such as arithmetic expression entry and modification (which has been previously identified as a weak point for structure editors). Other steps, like definition integration, and support for function calls and control structures are specific to our curriculum. This aspect of usability was evaluated by comparing the number of keystrokes necessary for a benchmark task, using ElmSr, using VS Code following our structured development approach, and using VS Code solely for text entry. ElmSr was much more efficient than VS Code for structured editing, and still more efficient than linear code entry. / Thesis / Master of Science (MSc)

2022 / Many properties of programs can be expressed through quantities such as power consumption, memory usage, execution time, the number of function calls, etc. Controlling these quantities can improve program reliability, security, privacy, usability, etc. For instance, the performance in terms of the execution time of two pieces of code for the same task can be used to decide which one to use. Providing tight bounds on these quantities is useful to improve software design for different potential applications. In this dissertation, I will focus on several different quantitative properties of programs that can be used to improve programs’ performance, along different axes. The first domain is relational cost analysis, which aims to provide tight bounds on the difference of the costs of evaluating two programs. The cost here is abstract, can be execution time, reduction step or number of functions calls, etc. Relational cost analysis earned people's attention for its application in program optimization and side-channel attack detection. Most of the related works have focused on pure functional programs. However, these reasoning principles may not be directly applied to situations where the program uses some effect, for example, destructive updates. To increase the expressiveness, we propose a type and effect system Arel to enable precise relational cost analysis over high-order functional programs, with mutable arrays, an important imperative feature. It can be regarded as the first step toward relational cost analysis for functional imperative programs with mutable state. Additionally, relational type and effect systems such as Arel suffer from the lack of methodology of implementation. To fill this gap, we propose a bidirectional type checking methodology to algorithmize these systems. Another quantity is the adaptivity in adaptive data analysis, where the queries asked by data analysts may depend on the results of previous queries. If we represent the interactions with a data analyst as a program, we can find some chain of queries so that every query may rely on the previous query in the chain. The adaptivity of this program is defined to be the length of the longest chain of queries. Reasoning about adaptivity helps to choose the appropriate statistical technique to use to control the generalization error of the data analysis. We propose a program analysis algorithm to statically estimate adaptivity.

The C Navigational System (CNS) is a proposed programming environment for the C programming language. The introduction covers the major influences of programming environments and the components of a programming environment. The system is designed to support the design, coding and maintenance phases of software development. CNS provides multiple views to both the source and documentation for a programming project. User-defined and system-defined links allow the source and documentation to be hierarchically searched. CNS also creates a history list and function interface for each function in a module. The final chapter compares CNS and several other programming environments (Microscope, Rn, Cedar, PECAN, and Marvel).

This thesis presents TransLucid, a low-level, purely declarative, intensional programming language. Built on a simple algebra and with just a small number of primitives, TransLucid programs define arbitrary dimensional infinite data structures, which are then queried to produce results. The formal foundations of TransLucid come from the work in intensional logic by Montague and Scott. The background chapters give a history of intensional logic and its predecessors in the Western world, as well as a history of intensional programming and Lucid, the first intensional programming language. The semantics of TransLucid are fully specified in the form of operational semantics. Three levels of semantics are given, in increasing order of efficiency, with the sequential warehouse semantics, the most efficient, being presented together with a proof that any expression will be evaluated by only examining relevant dimensions in the current context. The language is then extended in three important ways, by adding versioned identifiers, (declarative) side-effects and timestamped equations and demands. Adding versioned identifiers to TransLucid enriches the expressiveness of the language and allows the encoding of a variety of programming paradigms, ranging from manipulating large data-cubes to pattern-matching. Adding side-effects supports one of the main reasons for TransLucid: namely, to provide a target language, together with a methodology, for translating the main programming paradigms, thus creating a uniform end platform that can be the focus for optimisation and program verification. A translation of imperative programs into TransLucid is given. Timestamped equations and demands enable TransLucid to become a language for synchronous programming in real-time systems, as well as allowing runtime updates to a program's equations. The language TransLucid represents a decisive advance in declarative programming. It has applications in many fields of computer science and opens up exciting new avenues of research.

In the vision of Ambient Intelligence, people are assisted in their everyday activities through the proactive, opportunistic support of non-intrusive computing devices offering intuitive interaction modalities. The usefulness and quality of delivered services can be improved considerably if the devices are able to adapt their behaviour according to sensed changes in their surrounding environment, both at the physical and logical levels. This interplay between context-awareness and dynamic software adaptability is key to the construction of applications that are smart with respect to user needs. Unfortunately, most current applications do not reach this level of adaptability, due to a lack of appropriate programming technology. Most applications exhibit fixed functionality and seldom do they sense their environment and adapt their services in a context-aware fashion. Many chances of delivering improved services to users and network peers are thus missed. This dissertation presents a programming model to ease the construction of applications that can react to changes in their execution context by adapting their behaviour dynamically. The starting point of our research is the development of novel language abstractions and the adaptation of existing abstractions to render context-aware, self-adaptable applications easier to develop. We demonstrate that a simple yet powerful computation model readily provides the needed support, leading to straightforward application code that is not concerned with context adaptation, behaviour that can be adapted dynamically to different contexts in a non-intrusive fashion, and context-aware applications with software architectures that are not biased towards context adaptation ---rather, they can be designed freely according to their domain. The proposed computation model is realised through the Ambience programming language, and its underlying open implementation, the Ambient Object System. A small-step operational semantics describes it formally. Much in the vein of prototype-based programming, the model has been designed with simplicity and concreteness in mind. It is highly dynamic, featuring dynamic (multiple) dispatch, dynamic inheritance, dynamic typing, and dynamic method scoping. Application logic adaptation is enabled by means of an intuitive, first-class reification of context that is straightforwardly connected to dynamic behaviour selection. We describe needed management techniques for such context, and a few programming guidelines on how to develop context-aware applications using our approach. The approach is validated by showing its application in a number of scenarios inspired on Ambient Intelligence.

This study examined the integration of Small Basic as a new technology in computer courses of elementary schools in Turkey and investigated the perceptions of students and teachers of elementary school about the use of Small Basic in their computer courses in terms of its effects on their perceived motivation, perceived usefulness and perceived ease of use. Also, information from teachers about advantages and disadvantages of this technology, and the suggestions of teachers about the use of this technology and the content was gathered. A case study was conducted in the form of an action research / that is, this study used components of case study by action research. The data were collected from 4th and 5th grade students of Plevene Elementary School by using a questionnaire. Also, interviews were conducted with the teachers. Descriptive statistics, frequency distributions and descriptive analysis methods were used to analyze the results. The findings of the study showed that Small Basic is accepted by students and all teachers as a new technology. Also, students and teachers stated that using this technology affected students&#039 / perceived motivation towards computer courses positively. Moreover, the students and the teachers perceived that Small Basic is a useful and easy to use technology. Moreover, it was stated that the students and the teachers are satisfied with advantages of the use of this new technology in their learning environment.

This thesis presents TransLucid, a low-level, purely declarative, intensional programming language. Built on a simple algebra and with just a small number of primitives, TransLucid programs define arbitrary dimensional infinite data structures, which are then queried to produce results. The formal foundations of TransLucid come from the work in intensional logic by Montague and Scott. The background chapters give a history of intensional logic and its predecessors in the Western world, as well as a history of intensional programming and Lucid, the first intensional programming language. The semantics of TransLucid are fully specified in the form of operational semantics. Three levels of semantics are given, in increasing order of efficiency, with the sequential warehouse semantics, the most efficient, being presented together with a proof that any expression will be evaluated by only examining relevant dimensions in the current context. The language is then extended in three important ways, by adding versioned identifiers, (declarative) side-effects and timestamped equations and demands. Adding versioned identifiers to TransLucid enriches the expressiveness of the language and allows the encoding of a variety of programming paradigms, ranging from manipulating large data-cubes to pattern-matching. Adding side-effects supports one of the main reasons for TransLucid: namely, to provide a target language, together with a methodology, for translating the main programming paradigms, thus creating a uniform end platform that can be the focus for optimisation and program verification. A translation of imperative programs into TransLucid is given. Timestamped equations and demands enable TransLucid to become a language for synchronous programming in real-time systems, as well as allowing runtime updates to a program's equations. The language TransLucid represents a decisive advance in declarative programming. It has applications in many fields of computer science and opens up exciting new avenues of research.

Abstract The removal of overlying waste rock in open pit mines to dumps is conventionally undertaken by draglines or by trucks and shovels, or by a combination of these. Waste rock dumps are the largest remnant structures of open cut mining operations and can absorb a large proportion of the mine operating costs. If the dumps are not properly developed they can be excessively expensive and can become a major safety risk and environmental hazard. There are many examples worldwide where poor design and construction of waste rock dumps have resulted in failures causing considerable loss of life and widespread damage, or have resulted in erosion and seepage that have led to severe environmental pollution. The proper design and scheduling of waste rock dumps and haul routes can significantly reduce costs, minimise the possibility of failures, and avoid harming the environment. This Thesis is limited to the consideration of trucks and shovels for waste rock haulage in open cut mining operations. It describes the development and application of a waste rock dump scheduling model using the Operations Research technique of Mixed-Integer Linear Programming, implemented in the mathematical modelling language AMPL. The model focuses on minimising the haulage cost for each block of waste rock taken from the open pit and placed in the dump. Allowance is made for the selective placement of benign and reactive waste rock, based on an open pit block model that delineates benign and reactive waste rock. The formulation requires input data including the xyz-coordinates of the block model for the open pit, information on whether the waste rock blocks are benign or reactive, the proposed time scheduling of waste rock haulage from the open pit, unit haulage costs, and the geometry of the waste rock dump, including the delineation of the zones that are benign and those that are reactive. The model was successfully tested by using both simple test data and actual mine site data. The application of the model to a simple case confirmed that it produces results that meet the Objective Function in producing an optimal haulage time and cost, and meets the various Constraints imposed. This model for scheduling the removal of waste rock from open cut mining operations with trucks and shovels will require further research and testing and, because the results are generated in a numerical format, there will also be a need to convert them to a graphical format to facilitate their interpretation. Ultimately, it will have the potential to provide a relatively low-cost scheduling tool that meets operators’ economic, safety and environmental goals.

We present a general semantic account of Gifford-style type-and-effect systems. These type systems provide lightweight static analyses annotating program phrases with the sets of possible computational effects they may cause, such as memory access and modification, exception raising, and non-deterministic choice. The analyses are used, for example, to justify the program transformations typically used in optimising compilers, such as code reordering and inlining. Despite their existence for over two decades, there is no prior comprehensive theory of type-and-effect systems accounting for their syntax and semantics, and justifying their use in effect-dependent program transformation. We achieve this generality by recourse to the theory of algebraic effects, a development of Moggi’s monadic theory of computational effects that emphasises the operations causing the effects at hand and their equational theory. The key observation is that annotation effects can be identified with the effect operations. Our first main contribution is the uniform construction of semantic models for typeand- effect analysis by a process we call conservative restriction. Our construction requires an algebraic model of the unannotated programming language and a relevant notion of predicate. It then generates a model for Gifford-style type-and-effect analysis. This uniform construction subsumes existing ad-hoc models for type-and-effect systems, and is applicable in all cases in which the semantics can be given via enriched Lawvere theories. Our second main contribution is a demonstration that our theory accounts for the various aspects of Gifford-style effect systems. We begin with a version of Levy’s Callby- push-value that includes algebraic effects. We add effect annotations, and design a general type-and-effect system for such call-by-push-value variants. The annotated language can be thought of as an intermediate representation used for program optimisation. We relate the unannotated semantics to the conservative restriction semantics, and establish the soundness of program transformations based on this effect analysis. We develop and classify a range of validated transformations, generalising many existing ones and adding some new ones. We also give modularly-checkable sufficient conditions for the validity of these optimisations. In the final part of this thesis, we demonstrate our theory by analysing a simple example language involving global state with multiple regions, exceptions, and nondeterminism. We give decision procedures for the applicability of the various effect-dependent transformations, and establish their soundness and completeness.

The subject of this investigation is a specific set of parsers known as LR parsers. Of primary interest is a LR parsing method developed by DeRemer which specifies a translation method which can be defined by a Deterministic Push-Down Automation (DPDA). The method of investigation was to apply DeRemer's parsing technique to a specific language known as THIS Programming Language (TPL). The syntax of TPL was redefined as state diagrams and these state diagrams were, in turn, encoded into two tables--a State-Action table and a Transition table. The tables were then incorporated into a PL/l adaptation of DeRemer's algorithm and tested against various TPL statements.