Thesis (M.S.)--Rochester Institute of Technology, 1990. / Includes bibliographical references (leaves 70-71).

Context Writing and working with regular expressions could be a slow and tedious task,which is mainly because of its syntax, but also because there exist several different dialectswhich easily could cause confusion. Even though regular expression has been widely used forparsing and programming language design, they are now frequently used for input validationand seen in common applications such as text editors. Objectives The main objectives of our thesis are to determine whether or not a regularexpression language that is more like the surrounding programming language would increaseusability, readability, and maintainability. We will then investigate further into what kind ofimpact this would have regarding e.g, development speed, and what benefits and liabilities amore modernized syntax could introduce. Methods Two different methods were used to answer our research questions, exploratory in-terviews, and experiments. The data from the experiments were collected by screen recordingand a program in the environment we provided to the participant. Results.By doing interviews with developers that use traditional regular expressions on aregular basis, their stories confirm that its syntax is confusing even for developers with alot of experience. Our results from the experiment indicate that a language more like thesurrounding language increases both the overall ease of use and development speed. Conclusions From this research, we can conclude that a regular expression language thatis more like the surrounding programming language does increase usability, readability, andmaintainability. We could clearly see that it had a positive effect on the development speed aswell. Keywords — regular expressions, programming language design, readability

The task of implementing a programming language is a task that entails a great deal of work. Yet much of this work is similar for different programming languages: most languages require, e.g., parsing, name resolution, type-checking, and optimization. When implementing domain-specific languages (DSLs) the reimplementation of these largely similar tasks seems especially redundant. A number of approaches exist to alleviate this issue, including embedded DSLs, macro-rewriting systems, and more general systems intended for language implementation. However, these tend to have at least one of the following limitations: They present a leaky abstraction, e.g., error messages do not refer to the DSL but rather some other programming language, namely the one used to implement the DSL. They limit the flexibility of the DSL, either to the constructs present in another language, or merely to the syntax of some other language. They see an entire language as the unit of composition. Complete languages are extended with other complete language extensions. Instead, this thesis introduces the concept of a syntax construction, which represents a smaller unit of composition. A syntax construction defines a single language feature, e.g., an if-statement, an anonymous function, or addition. Each syntax construction specifies its own syntax, binding semantics, and runtime semantics, independent of the rest of the language. The runtime semantics are defined using a translation into another target language, similarly to macros. These translations can then be checked to ensure that they preserve binding semantics and introduce no binding errors. This checking ensures that binding errors can be presented in terms of code the programmer wrote, rather than generated code in some underlying language. During evaluation several limitations are encountered. Removing or minimizing these limitations appears possible, but is left for future work / Att implementera ett programmeringsspråk är ett mycket arbetstungt åtagande. Detta trots att mycket av det som behöver göras inte skiljer sig särskilt mycket mellan olika språk, de flesta behöver exempelvis parsning, namnupplösning, typcheckning och optimering. För ett domänspecifikt programmeringsspråk (DSL) är denna upprepning ännu mer tydlig. Det finns ett antal olika metoder för att hantera detta, exempelvis embeddade DSLer, macro-system, och mer generella system för programspråksimplementation. Dessa tenderar dock att ha en eller flera av följande begränsningar: De abstraktioner som introduceras "läcker", felmeddelanden kan exempelvis referera till abstraktioner i ett annat programmeringsspråk, nämligen det som användes för att implementera DSLet. DSLet som implementeras blir begränsat, antingen till vad som finns i implementationsspråket, eller till implementationsspråkets syntax. Ett DSL ses som den minsta hela beståndsdelen i systemet. Om delar av språket ska återanvändas eller inkluderas i ett annat måste hela språket följa med. Denna avhandling introducerar istället syntaxkonstruktioner som minsta beståndsdel. En syntaxkonstruktion representerar en enskild del av ett språk, exempelvis en if-sats, en anonym funktion, eller addition. Varje syntaxkonstruktion definierar sin egen syntax, bindningssemantik och exekveringssemantik, utan referenser till språket som helhet. Exekveringssemantiken liknar en macro, den uttrycks som en översättning till ett implementationsspråk. Tack vare att bindningssemantiken är specifierad kan vi sedan kontrollera översättningen så att den inte kan introducera bindningsfel. Detta medför att felmeddelanden kan referera enbart till kod som programmeraren faktiskt skrev, istället för genererad kod i implementationsspråket. Evalueringen påvisar flera begränsningar med systemet. Begränsningarna tycks lösbara, men detta arbete lämnas till framtiden.

As an extension to the ongoing Coconut (COde COnstructing User Tool) project at McMaster University, we present a Scala library for constructing type-safe domain-specific languages that uses Coconut’s hypergraph-based representation of code (code graphs) as the intermediate representation. Our library automatically produces strongly typed, deeply embedded DSLs given only a minimal specification of the DSL’s value types and primitives. We make extensive use of path-dependent types and implicit argument lookup to construct a type-safe interface on-the-fly, rather than requiring DSL designers to explicitly create a type-safe interface. In this thesis we present our library and demonstrate its utility as both a general-purpose DSL framework and as a suitable platform for continued research on the Coconut project. By giving practical examples of the library in use, we demonstrate both its general utility, and the striking swiftness with which new DSLs may be constructed, especially compared to the previously laborious Haskell DSLs of Coconut. / Thesis / Master of Science (MSc)

No description available.

<p> The Haskell programming language uses type classes to deal with overloading. Functions are overloaded by defining some types to be instances of a class. A meaningful instance should satisfy the invariants of the class.</p> <p> In this thesis we present one method to validate the type instances of classes informally, and another one to verify them in a formal way.</p> <p> The first method uses QuickCheck, which is an automatic testing tool for Haskell programs. We introduce how to specify the properties of type classes in QuickCheck by some examples, and I also present testing for Haskell standard types and classes.</p> <p> The second method I adopted uses the theorem prover Isabelle/HOL. To facilitate the usage of Isabelle/HOL for Haskell programmers, I define a set of translation rules from Haskell programs to Isabelle/HOL, and design a simple automatic translating tool based on those rules. Logical differences between Haskell and Isabelle/HOL need to be considered in the translation. For example Isabelle/HOL is not suitable to describe the semantics of lazy evaluation and of Haskell functions that are non-terminating. I also prove some type instances to illustrate how the properties are verified in Isabelle/HOL.</p> / Thesis / Master of Applied Science (MASc)

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)

Software testing is a necessary and integral part of the software quality process. It is estimated that inadequate testing infrastructure cost the US economy between $22.2 and $59.5 billion. We present Sulu, a programming language designed with automated unit testing specifically in mind, as a demonstration of how software testing may be more integrated and automated into the software development process. Sulu's runtime and tools support automated testing from end to end; automating the generation, execution, and evaluation of test suites using both code coverage and mutation analysis. Sulu is also designed to fully integrate automatically generated tests with manually written test suites. Sulu's tools incorporate pluggable test case generators, which enables the software developer to employ different test case generation algorithms. To show the effectiveness of this integrated approach, we designed an experiment to evaluate a family of test suites generated using one test case generation algorithm, which exhaustively enumerates every sequence of method calls within a certain bound. The results show over 80\% code coverage and high mutation coverage for the most comprehensive test suite generated. / Ph. D.

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).