"uuid","repository link","title","author","contributor","publication year","abstract","subject topic","language","publication type","publisher","isbn","issn","patent","patent status","bibliographic note","access restriction","embargo date","faculty","department","research group","programme","project","coordinates"
"uuid:fb0cc4b7-a67b-474b-9570-96eb054a39ec","http://resolver.tudelft.nl/uuid:fb0cc4b7-a67b-474b-9570-96eb054a39ec","WebDSL: Linguistic Abstractions for Web Programming","Groenewegen, D.M. (TU Delft Programming Languages)","van Deursen, A. (promotor); Erdweg, S.T. (promotor); Delft University of Technology (degree granting institution)","2023","Information systems store and organize data, and manage business processes concerned with that data. Information systems aim to support operations, management and decision-making in organizations. Web applications are ideal for implementing information systems. Although existing web frameworks provide abstractions for creating web applications, there are three major issues with current web frameworks. Insufficient or leaky abstraction: web programming concerns are not sufficiently covered or abstractions contain accidental complexity. Lack of static verification: application faults are not removed during development. Security flaws: web application security issues are not sufficiently addressed in the framework, web programmers are exposed to many possible security faults.
How can the benefits of web frameworks be provided for web programming while avoiding the major issues of abstraction, static verification, and security? We propose a domain-specific language (DSL) solution. The challenge is to design a language that provides abstractions for all kinds of web programming tasks with the web framework issues in mind. We designed multiple sublanguages to address web programming concerns, and integrated them to form the WebDSL web programming language. WebDSL incorporates better abstraction for web programming concepts, has static checks on the application code with accurate error reporting, and automatically addresses security concerns in the code generation and runtime.
The primary concerns in web programming are user interfaces and data handling. Which features do we need from a user interface language? These features include both the rendering of data persisted in the database, as well as providing input-handling components to enter new data and update existing data. Additionally, data invariants need to be enforced by the system. How can a DSL provide these features in an integrated way? These are language-design challenges that are investigated in this dissertation. The user interface sublanguage of WebDSL contains several unique improvements compared to existing approaches: form submits that are safe from hidden data tampering; prevention of input identifier mismatch in action handlers; safe composition of input templates; automatic enforcement of Cross-Site Request Forgery protection; expressive data validation; and partial page updates without explicit JavaScript or DOM manipulation.
Access control is essential for the security and integrity of interactive web applications. Existing solutions for access control often consist of libraries or generic implementations of fixed policies. These rarely have clear interfacing capabilities, and they require manual extension and integration with the application code, which is error-prone. WebDSL provides a declarative access control sublanguage, which is entirely integrated with other language components and automatically weaves checks into the application code. Errors related to inconsistent application of access control checks are avoided. The access control language shows that various policies can be expressed with simple constraints, allowing concise and transparent mechanisms to be constructed.
Our work on abstractions for web programming resulted in several scientific and software contributions: The design and implementation of a linguistically integrated domain-specific language for web programming that combines abstractions for web programming concerns covering transparent persistence, user interfaces, data validation, access control, and internal site search. Sublanguages for the various concerns are integrated through static verification to prevent inconsistencies, with immediate feedback in the integrated development environment (IDE) and error messages in terms of domain concepts. WebDSL is the largest programming language created with the Stratego program transformation language and the Spoofax language workbench, in which the DSL compiler and IDE have been iteratively developed. This iterative development is a recurring pattern of discovering new abstractions, domain-specific language abstraction, and reimplementation using new core abstractions tailored to the language. To validate WebDSL, we have created several real-world applications in the domain of research and education for external clients.
In our research we aim to create solutions for problems in web engineering and language engineering by developing concepts, methods, techniques, and tools. We aim to create more than just prototypes by continuing maintenance and development beyond the proof of concept. For over 10 years, we have developed WebDSL, and created and operated practical applications for external clients. For example, EvaTool is a course evaluation application that supports processes for analyzing student feedback by lecturers and other staff. WebLab is an online learning management system with a focus on programming education (students complete programming assignments in the browser), with support for lab work and digital exams, used in dozens of courses at TU Delft. Conf Researchr is a domain-specific content management system for creating and hosting integrated websites for conferences with multiple co-located events, used by all ACM SIGPLAN and SIGSOFT conferences. MyStudyPlanning is an application for composition of individual study plans by students and verification of those plans by the exam board, used by multiple faculties at TU Delft.","Programming Languages; Programming Language Design; Domain-Specific Languages; Web information systems; compilers; Information Systems; Access control; Data validation; User Interfaces; Persistence; Object-Relational Mapping; practical impact","en","doctoral thesis","","978-94-6419-976-5","","","","Prof.dr. E. Visser (Delft University of Technology) was the original promotor and supervisor of this research until his untimely passing on April 5th, 2022.","","","","","Programming Languages","","",""
"uuid:c2ad7239-2ab8-478e-b3f8-cb31bd91edf3","http://resolver.tudelft.nl/uuid:c2ad7239-2ab8-478e-b3f8-cb31bd91edf3","Language Agnostic Code Exploration Services","Dönszelmann, Jonathan (TU Delft Electrical Engineering, Mathematics and Computer Science)","Langendoen, K.G. (mentor); Cockx, J.G.H. (graduation committee); Groenewegen, D.M. (graduation committee); Pelsmaeker, D.A.A. (graduation committee); Delft University of Technology (degree granting institution)","2023","Programmers spend significantly more time trying to comprehend existing code than writing new code. They gain an understanding of the code by navigating the code base in an IDE, by reading documentation online, and by browsing code repositories on websites such as GitHub. To create rich experiences for programming languages across those various media is a large effort for developers of programming languages. This effort might be worthwhile for popular languages, but for new or experimental languages the required effort is often too large. Solutions to reduce this effort of implementing an IDE exist,such as LSP, but to reduce the effort in other places outside IDEs, we introduce the Codex metadata format, which separates language-specific generation of code metadata from its language-agnostic presentation. To demonstrate this approach by implementing four language-specific metadata generators (based on LSP, CTAGS, TextMate and Elaine) and two language-agnostic presentations (PDF documents and a code viewer websites) of code and metadata. To demonstrate different kinds of code metadata, we implemented four code exploration services: syntax colouring, code navigation, structure outline, and diagnostic messages. We show that with the Codex metadata format, we can decouple the metadata generators from the presentations.","editor services; Programming Languages; code exploration; language agnostic","en","master thesis","","","","","","https://github.com/jdonszelmann/codex","","","","","","Computer Science","",""
"uuid:f6c38be6-853f-499b-aa4e-cfa2ce219bf5","http://resolver.tudelft.nl/uuid:f6c38be6-853f-499b-aa4e-cfa2ce219bf5","Elaine: Elaborations of Higher-Order Effects as First-Class Language Feature","Diepraam, Terts (TU Delft Electrical Engineering, Mathematics and Computer Science)","van der Rest, C.R. (mentor); Poulsen, C.B. (graduation committee); Spaan, M.T.J. (graduation committee); Delft University of Technology (degree granting institution)","2023","Algebraic effects and handlers have become a popular abstraction for effectful computation, with implementations even in mainstream programming languages, such as OCaml. The operations of an algebraic effect define the syntax of the effect, while handlers define the semantics. This provides modularity, because we can choose which handler to apply to a computation. However, we cannot write handlers for many higher-order operations; operations that take effectful computations as parameters. Such higher-order operations can therefore not enjoy this modularity. Hefty algebras provide an additional layer of abstraction in the form of elaborations to make implementations of higher-order operations modular as well. Several languages, such as Koka, natively support algebraic effects and handlers. However, until now, no languages have been created with native support for higher-order effects. In this thesis, we introduce Elaine, a language featuring both handlers for algebraic effects and elaborations for higher-order effects. Additionally, we introduce implicit elaboration resolution; a type-directed procedure which infers the appropriate elaborations from context. We conjecture that hefty algebras are the semantics for Elaine. We provide a specification for Elaine, including its syntax definition, typing judgments and reduction semantics. This specification is implemented in a publicly available prototype which can type check and evaluate the set of example programs included with this thesis.","algebraic effects; hefty algebras; programming language","en","master thesis","","","","","","","","","","","","Computer Science","",""
"uuid:5eb7fd17-c187-440f-b700-ebd123cab533","http://resolver.tudelft.nl/uuid:5eb7fd17-c187-440f-b700-ebd123cab533","Maybe a List would be better?: Correct by construction Maybe to List refactorings in a Haskell-like language","Padilla Cancio, José (TU Delft Electrical Engineering, Mathematics and Computer Science)","Cockx, J.G.H. (mentor); Miljak, L. (mentor); Langendoen, K.G. (graduation committee); Delft University of Technology (degree granting institution)","2023","This paper concerns itself with correct by construction refactoring of Maybe values to List values in a Haskell-like language (HLL) as a case study on data-oriented refactorings. Our language makes use of intrinsically-typed syntax and de Bruijn indices for variables. Operational semantics are defined using big step semantics. We define a refactoring function which intrinsically verifies its well-typedness due to our intrinsically-typed syntax. The semantic validity of this refactoring is given by a separate proof. We use Agda, a functional language and theorem prover, to define and prove these properties. Techniques and concepts used in our refactoring and proof generalize well to other data-oriented refactorings.","Programming Languages; Functional Programming; Formal Verification; Agda; Correct by construction; Refactoring","en","bachelor thesis","","","","","","","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:4260f3fb-f0dd-4a1c-8097-58855609ba41","http://resolver.tudelft.nl/uuid:4260f3fb-f0dd-4a1c-8097-58855609ba41","Bringing Formal Verification into Widespread Programming Language Ecosystems","Juhošová, Sára (TU Delft Electrical Engineering, Mathematics and Computer Science; TU Delft Programming Languages)","Cockx, J.G.H. (mentor); Lofi, C. (graduation committee); Escot, L.F.B. (graduation committee); Delft University of Technology (degree granting institution)","2023","Formal verification is a powerful tool for ensuring program correctness but is often hard to learn to use and has not yet spread into the commercial world. This thesis focuses on finding an easy-to-use solution to make formal verification available in popular programming language ecosystems. We propose a solution where users can write code in an interactive theorem prover and then transpile it into a more popular programming language. We use Agda2HS as a case study to determine what challenges users find in using such a tool, improve selected features, and then conduct a user study to evaluate the usability. We find that detailed documentation, support for commonly-used features in the target programming language, features that facilitate verification, integration of the tool into the target ecosystem, and user studies are necessary for the accessibility of such a tool.","formal verification; theorem proving; programming language ecosystems; transpilation; usability","en","master thesis","","","","","","https://github.com/sarajuhosova/agda2hs-user-study/ The GitHub repository containing the programming assignments used during the user study. https://github.com/agda/agda2hs Repository link The GitHub repository containing source code for Agda2HS - a tool that was investigated and improved as part of this thesis.","","","","","","Computer Science","",""
"uuid:43d4ce8e-378c-4942-bd03-6c7f3ba8387a","http://resolver.tudelft.nl/uuid:43d4ce8e-378c-4942-bd03-6c7f3ba8387a","Literature survey of type inference algorithms for statically typed languages","Jakovonis, Saulius (TU Delft Electrical Engineering, Mathematics and Computer Science)","Cockx, J.G.H. (mentor); Liesnikov, B. (mentor); Panichella, A. (graduation committee); Delft University of Technology (degree granting institution)","2023","The success of dynamically typed languages such as Python has resulted in an increased interest in supporting type inference in statically typed lan- guages. Type inference refers to automatic type detection based on surrounding context and allows retaining the type safety (and other advantages) of static types, while matching the ease of use of dy- namically typed languages. Unfortunately, imple- menting type inference can be tricky. Researchers have been proposing various methods for type in- ference ever since the 1970s, however there is no single solution that works for all languages. This paper presents and analyses the proposed methods together with motivations, intuitions, use-cases and examples from practice with the aim of helping new programming language developers understand type inference principles and choose the right technique for their needs.","Type Inference; Algorithms; Statically Typed; Type Checking; Programming Languages","en","bachelor thesis","","","","","","","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:16b1f178-c8da-4f5c-af41-f48e6d322c63","http://resolver.tudelft.nl/uuid:16b1f178-c8da-4f5c-af41-f48e6d322c63","Literature survey on implementation techniques for type systems: Exploring name binding techniques","Kocakaya, Hasan (TU Delft Electrical Engineering, Mathematics and Computer Science)","Cockx, J.G.H. (mentor); Liesnikov, B. (mentor); Panichella, A. (graduation committee); Delft University of Technology (degree granting institution)","2023","Names are essential for structuring and reason-ing about programs. However, the implementation of names differs across many programming lan-guages. There is an bundance of choice between various implementation techniques with regards to name-binding techniques. As such, when design-ing a programming language it is not clear which technique one should choose. This paper attempts to give an exhaustive overview of the various tech-niques that exist, compares them on properties such as alpha-equivalence, ease of implementation and enforcing well-scopedness. Furthermore, the pos-sibility of a one-fits-all solution is explored.","Name-binding; Programming languages; Type systems","en","bachelor thesis","","","","","","","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:02d6b2aa-59d2-4716-b5b2-f0d643fbc908","http://resolver.tudelft.nl/uuid:02d6b2aa-59d2-4716-b5b2-f0d643fbc908","Exploring the Effects of the Hedy User Interface on the Development of CS Interest in Girls","de Wit, S. (TU Delft Web Information Systems); Hermans, Felienne (Vrije Universiteit Amsterdam); Specht, M.M. (TU Delft Web Information Systems); Aivaloglou, E.A. (TU Delft Web Information Systems)","","2023","Women are underrepresented in Computer Science (CS). Closing the gender gap in CS benefits the economy, gender equality and society. However, girls have low CS interest while interest energizes learning and guides career trajectories. We explore the effects of the user interface of Hedy, a graduate language which teaches the syntax of Python, on the development of CS interest in girls.","gender; programming language; user interface; interest","en","poster","","","","","","","","","","","Web Information Systems","","",""
"uuid:769d3d81-8a84-4f59-80a6-2d237aa878a4","http://resolver.tudelft.nl/uuid:769d3d81-8a84-4f59-80a6-2d237aa878a4","Recommender Systems for DevOps","Maddila, C.S. (TU Delft Software Engineering)","van Deursen, A. (promotor); Nagappan, Nachiappan (promotor); Gousios, G. (promotor); Delft University of Technology (degree granting institution)","2022","The software development life cycle (SDLC) for a developer has increased in complexity and scale. With the advent of DevOps processes, the gap between development and operations teams reduced significantly. Developers are now expected to perform different roles from coding to operational support in the new model of software development. This shift demands the evolution and improvement of software development practices and deliver products at a faster pace than organizations using traditional software development and infrastructure management processes. As a consequence, the demand for more intelligent and context sensitive DevOps tools and services that help developers increase their efficiency is increasing. A lot of research went into developing recommenders for DevOps, by leveraging the advancements made by the recommender system community. However, a lot of existing tools still work in ‘silos’ and does not take into account a holistic view of DevOps processes and the data generated at phase of the DevOps lifecycle while making recommendations.
By contrast, in this thesis, we propose a unified framework to develop recommenders for DevOps: perform data collection, building the models, deploying them, and evaluating the effectiveness of such recommenders in large-scale cloud development environments quickly and efficiently. We study the effect of such recommenders on the DevOps processes by performing empirical research and mixed method approaches (qualitative and quantitative analyses) on each of the deployed recommenders to better understand the productivity gains and the impact created by them.
Our results show that developers benefit greatly from smart recommenders such as Nudge, ConE, Orca, and MyNalanda. We also show, through rigorous experiments, technical action research methods, and empirical analyses that these recommenders provide as much as 65% gains in terms of change progression and 73% accuracy for root causing the service incidents automatically. We also conduct large scale surveys and interviews to support our empirical analysis and quantitative results. Our unified data framework and the platform we developed for building these recommenders is generic enough and encourages reusability of vital functions of such recommenders systems, such as data collection, model training, inference, deployment, and evaluation.","DevOps; Recommender Systems; Artificial Intelligence; Machine learning (ML); Software Engineering; Programming Languages","en","doctoral thesis","","","","","","","","","","","Software Engineering","","",""
"uuid:0ace357b-d07a-40a0-9167-6d8e775f5ba0","http://resolver.tudelft.nl/uuid:0ace357b-d07a-40a0-9167-6d8e775f5ba0","Geofront: Directly accessible GIS tools using a web-based visual programming language","Feenstra, Jos (TU Delft Architecture and the Built Environment; TU Delft Urban Data Science)","Vitalis, S. (graduation committee); Arroyo Ohori, G.A.K. (mentor); Agugiaro, G. (graduation committee); Delft University of Technology (degree granting institution)","2022","In the field of Geographical Information Science (GIS), geodata transformation and analysis tools often take the shape of software libraries written in system level programming languages.
However, the societal impact of these tools is often limited, as most end users only access these libraries via indirect means: Through bindings in other languages, through plugin in applications, or both.
Additionally, the tools end users end up with are often not composable, and may contain other hurdles like installation or configuration.
The goal of this study is to make core GIS libraries more directly available and composable to end users.
This study presents and prototypes a novel method, centered around a visual programming language to host the functionalities of GIS libraries from within an application, and in a composable manner.
Additionally, the visual language is used to connect these libraries to a user-definable Graphical User Interface (GUI).
This prototype is implemented as a static web application, so that these libraries are directly accessible to end users without installation.
GIS libraries are compiled to WebAssembly, making the library usable in any language, including
this web based visual language by using a ’no boilerplate’ plugin system.
Finally, both scalability to handle sizable datasets, and a rich GUI (3D viewers, file inputs, sliders), are primary design considerations and assessment criteria.
The results show that this specific web based VPL appears to be a feasible method for providing direct access to some native GIS libraries, and does offer a unique set of features not found in comparable visual languages.
The significance of this method, compared to other web based geometry VPLs, lies in the fact that it offers a lenient plugin system, in combination with a range of different GUI nodes, certain ""dataflow VPL"" properties, and a proposed zero cost abstraction runtime.
All of these features combined lead to a VPL which is able to directly connect GUI components with native GIS libraries, all while remaining scalable in principle.
On a practical level, more work remains to proof this feasibility.
The methodology developed by this study is only theoretically accessible and composable, based on achieved features.
User testing is required to confirm if this method indeed improves workflows, and actually saves time and energy of developers and end users.
Moreover, the prototypical software implementation used is limited and not production ready. Both the fact that the ’no boilerplate’ plugin system cannot be used with C / C++ GIS libraries, and that backend execution is not possible yet, must be improved upon in future work.
Despite this, visual programing, distribution using WebAssembly, and Rust based geocomputation, all proved to be valuable directions of future GIS research.","Visual Programming Language; GIS web tool; WebAssembly; Cloud Computing; GIS; Grasshopper; FME","en","master thesis","","","","","","https://thegeofront.github.io/ A link to Geofront: the software implementation of the method prescribed by the Thesis https://github.com/thegeofront Repository of all software written as part of this study","","","","","","Geomatics","",""
"uuid:8653ab24-a782-41f0-aefc-6b1c8d9a37d5","http://resolver.tudelft.nl/uuid:8653ab24-a782-41f0-aefc-6b1c8d9a37d5","Dynamix: A Domain-Specific Language for Dynamic Semantics","Molendijk, Thijs (TU Delft Electrical Engineering, Mathematics and Computer Science; TU Delft Programming Languages)","Visser, Eelco (mentor); Poulsen, C.B. (mentor); van Deursen, A. (graduation committee); Tolmach, A. (graduation committee); Delft University of Technology (degree granting institution)","2022","The dynamic semantics of a programming language formally describe the runtime behavior of any given program. In this thesis, we present Dynamix, a meta-language for dynamic semantics. By writing a specification for a language in Dynamix, a compiler for the language can be derived automatically.
Dynamix specifications compile source programs to the Tim intermediate representation, a language-agnostic target IR designed to be able to be efficiently interpreted or compiled. Dynamix and Tim make use of the continuation-passing style to abstract over control flow, giving language developers fine-grained access to control flow primitives in their specification. A novel abstraction in Dynamix allows the construction of these CPS terms without the traditional friction involved. Dynamix is fully typed and integrated within the Spoofax language workbench. This allows language developers to interact directly with other parts of the workbench, including automatic type signature generation and the ability to query the results of static analysis.
Through case studies for miniStratego and ChocoPy with exceptions, we show that Dynamix is capable of succinctly representing a wide range of source language features and paradigms. Current performance is acceptable, with the foundations for a future efficient compiler for the Tim IR already in place.","Programming Languages; Spoofax; Domain Specific Languages; Dynamic semantics; Dynamix","en","master thesis","","","","","","","","","","","","Computer Science","",""
"uuid:5ca6e6f3-1242-4b86-8307-4ac4f4489951","http://resolver.tudelft.nl/uuid:5ca6e6f3-1242-4b86-8307-4ac4f4489951","Mechanizing Hoare Style Proof Outlines for Imperative Programs in Agda","de Haas, Olav (TU Delft Electrical Engineering, Mathematics and Computer Science)","van Deursen, A. (graduation committee); Krebbers, R.J. (graduation committee); Cockx, J.G.H. (graduation committee); Rouvoet, A.J. (mentor); Delft University of Technology (degree granting institution)","2022","Formal verification of imperative programs can be carried out on paper by annotating programs to obtain an outline of a proof in the style of Hoare. This process has been mechanized by the introduction of Separation Logic and computer assisted verification tools. However, the tools fail to achieve the readability and convenience of manual paper proof outlines. This is a pity, because getting ideas and proofs across is essential for scientific research. I introduce a mechanization for proof outlines of imperative programs to interactively write human readable outlines in the dependently typed programming language and proof assistant Agda. I achieve this by introducing practical syntax and proof automation to write concise proof outlines for a simple imperative programming language based on λ-calculus. The proposed solution results in proof outlines that combine the readability of paper proof outlines and the precision of mechanization.
This paper discusses the applicability of this new paradigm to static code analysis programs.
Different code analyzers often have many similar, if not identical pieces of code which could be abstracted away.
This abstraction does not come natural to the programming paradigm of Functional Programming but are quite natural within EHOP.
The current programming languages do not yet seem up to the task of rapid generalization of code and elimination of duplicate pieces of code.
However, the concepts present in EHOP will almost certainly be able to eliminate much of this code reduction once the languages have matured further.
The implicit passing of functionality will also allow for clearer code with less unnecessary visual clutter.","effect handler oriented programming; Static Code Analysis; Programming Languages","en","bachelor thesis","","","","","","","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:817d36d2-1e30-47ef-91c7-e29b94a9632d","http://resolver.tudelft.nl/uuid:817d36d2-1e30-47ef-91c7-e29b94a9632d","Applicability of Effect Handler Oriented Programming (EHOP) for Text-Based Game Development","Todorov, Ivan (TU Delft Electrical Engineering, Mathematics and Computer Science)","Poulsen, C.B. (mentor); van der Rest, C.R. (mentor); Reinders, J.S. (mentor); Bohmer, Wendelin (graduation committee); Delft University of Technology (degree granting institution)","2022","Effect handler oriented programming (EHOP) is a recently proposed programming paradigm, which aims to provide a separation of concerns by isolating the handling of side-effects from the main application logic. Nowadays, as the core concepts behind EHOP are being added to more and more programming languages, it is evident that EHOP is slowly but steadily growing in popularity. Therefore, it is important to explore the applicability of EHOP for different areas of software development. However, so far, very little research has been conducted on this topic and, thus, barely any possible application domains of EHOP have been investigated. This study focuses on a potential field of application of EHOP, which has not been covered by previous research, namely - text-based game development, and aims to determine the extent to which the usage of EHOP for text-based game development affects the modularity, readability and maintainability of the source code. This goal will be achieved by performing both a qualitative as well as a quantitative analysis of the source code of a text-based game, written in Koka - a state-of-the-art programming language, which supports EHOP. The results show that there are substantial benefits to using EHOP for text-based game development. It significantly improves the modularity, readability and maintainability of the source code at the cost of very little to no performance.","Programming Languages; Effect Handler Oriented Programming; Koka","en","bachelor thesis","","","","","","https://github.com/ivanstodorov/chess-game-koka This is a link to the GitHub repository, which contains all of the source code, that was used, while writing this Bachelor thesis.","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:ffea061f-d832-4d54-9726-8389cd4bf42a","http://resolver.tudelft.nl/uuid:ffea061f-d832-4d54-9726-8389cd4bf42a","Programming With Effects: Improving the quality of code in IO intensive applications through effect handlers","Streef, Sam (TU Delft Electrical Engineering, Mathematics and Computer Science)","Poulsen, C.B. (mentor); van der Rest, C.R. (mentor); Reinders, J.S. (mentor); Bohmer, Wendelin (graduation committee); Delft University of Technology (degree granting institution)","2022","Effect handler orient programming (EHOP) is a recently proposed programming paradigm that aims to provide a high-level abstraction in code. Using this paradigm, programmers are able to define operations as an effect, which are implemented by an effect handler. Functions can then use effects, allowing the effect operations to be used in this function. Depending on the effect handler that handles the effect, an effect can have different functionality. In this research, EHOP is compared to the traditional functional programming paradigm on readability, maintainability, modularity and performance for IO intensive applications. The comparison is carried out by two programming experiments that each apply one of the programming paradigms to create an HTTP server. The comparison of these programs show that EHOP improves the readability, maintainability and modularity but decreases the performance in response time and memory. The conclusion of this case study is therefore that EHOP affects IO intensive applications in a negative manner due to its performance overhead.","Programming Languages; Effects; Functional Programming","en","bachelor thesis","","","","","","","","","","","","Computer Science and Engineering","CSE3000 Research Project",""
"uuid:0302aff0-f8dc-432b-add0-0008371b7c62","http://resolver.tudelft.nl/uuid:0302aff0-f8dc-432b-add0-0008371b7c62","Static type checking without downcast operator","Mooij, A.J. (TU Delft Programming Languages; DIANA FEA)","","2022","In the last couple of years several dynamically-typed, object-oriented programming languages have been equipped with optional static type checkers. This typically requires these languages to be extended with a downcast operator, which is a common operator in statically-typed languages but not in dynamically-typed languages. Our objective is to investigate an approach for static type checking of object-oriented languages that does not require such an additional downcast operator. We systematically weaken the rules for static type checking to avoid reporting errors that can be resolved using downcast operators. This leads to an approach similar to quasi-static typing that enables to make type annotations stricter in a gradual way. These static type checking rules can be applied to dynamically-typed languages by interpreting the dynamic type as the top of the subtype relation. Based on these ideas we have implemented a static type checker for the dynamically-typed, object-oriented language POOSL without introducing a downcast operator. Practical experiences with this type checker indicate that it is useful for early validation.","Early validation; Object-oriented languages; Programming languages; Static type checking","en","journal article","","","","","","","","","","","Programming Languages","","",""
"uuid:da19e3b2-6b62-4a5b-8b8e-d30220b77fd5","http://resolver.tudelft.nl/uuid:da19e3b2-6b62-4a5b-8b8e-d30220b77fd5","Towards the Continuous Automated Testing of Building Design","Pejić, Saša Pejić (TU Delft Civil Engineering & Geosciences)","Schipper, H.R. (graduation committee); Pasterkamp, S. (mentor); van Nederveen, G.A. (mentor); Coenders, Jeroen (mentor); Delft University of Technology (degree granting institution)","2021","In recent years the AEC industry has started implementing more new technologies. Still, the adoption process is slow. One of the crucial steps during the building designing is a justification of design according to previously defined requirements. That process is still manual to a large extent, therefore unnecessarily time-consuming and prone to errors. The need for automation of requirements compliance checking has been rising in recent years, and the science community presented various approaches for automation. Still, most of the proposed methods has similar problems: using a black-box approach, require that the designer is highly skilled in programming, focusing on only geometric requirements and not covering whole process of compliance checking. Therefore, there is a need for a new approach that can solve all these problems. The rise in popularity of parametric design and tools like Grasshopper opens the possibility to overcome some of the current limitations. Also, the possibility of using requirements management software to have the process fully organized supports the belief in automating compliance checking. The fundamental objective of this project is to explore the possibilities of automating the requirements verification for a building design by using requirements management software to systematically structure the requirements and Grasshopper to generate the rules, which afterwards can be verified. To achieve this objective, the project was divided into three main parts. First, the conceptual framework for automated code checking is developed. Afterwards, the system architecture of the prototype tool was explored, and instructions for scripting the tool were given. Finally, after the tool was scripted, it was tested on a real building model.
From the literature review the two main types of requirements are found, the functional and performance requirement. Since the functional requirements are qualitative and cannot be quantified, that category is not suitable for checking with the approach proposed in this project. Therefore, the focus was on performance requirements. The central part of the project is the creation of a framework for automated compliance checking. The five steps are defined and these are:
1.) Requirements defining and logical structuring into RMS
2.) Interpretation of requirements
3.) Building model preparation
4.) Checking phase
5.) Reporting phase
After the theoretical basis is set, the modelling of the tool is elaborated. Firstly, the requirements for the tool are set. Afterwards, the system architecture is explored, and finally, instructions for scripting the tool are developed.
After the prototype tool is scripted, it is tested on a real building model, and it shows clear advantages compared to other approaches or manual work, still, it also has some disadvantages.
Test of the tool proved that the Visual programming language environment is a great platform for developing a white-box approach for automated compliance checking. Also, testing on the real-world building model shows that a five-step approach for automated testing of building design works and can be used. Lastly, the test shows that the proposed system architecture and instructions for scripting the tool can result in a well-operating tool.
Finally, recommendations for future research are given.
The author has been involved in the development of several meta-languages for semantic specification, including action semantics and modular variants of structural operational semantics (MSOS, I-MSOS). This led to the PLanCompS project, and to the design of its meta-language, CBS, for component-based semantics. CBS comes together with an extensible library of reusable components called ‘funcons’, corresponding to fundamental programming constructs. The main aim of CBS is to optimise co-evolution and reuse of specifications during language development, and to make specification of language semantics almost as straightforward as context-free syntax specification.
The paper discusses the engineering of a selection of previous meta-languages, assessing how well they support co-evolution and reuse. It then gives an introduction to CBS, and illustrates significant features. It also considers whether other current meta-languages might also be used to define an extensible library of funcons for use in component-based semantics.","Semantics of programming languages; Meta-languages; Modularity","en","journal article","","","","","","","","2020-07-30","","","Programming Languages","","",""
"uuid:0ccc1f8f-1809-4450-bbc9-0ac7289781f0","http://resolver.tudelft.nl/uuid:0ccc1f8f-1809-4450-bbc9-0ac7289781f0","Executable component-based semantics","Binsbergen, L. Thomas van (University of London); Mosses, P.D. (TU Delft Programming Languages; Swansea University); Sculthorpe, Neil (Nottingham Trent University)","","2019","The potential benefits of formal semantics are well known. However, a substantial amount of work is required to produce a complete and accurate formal semantics for a major language; and when the language evolves, large-scale revision of the semantics may be needed to reflect the changes. The investment of effort needed to produce an initial definition, and subsequently to revise it, has discouraged language developers from using formal semantics. Consequently, many major programming languages (and most domain-specific languages) do not yet have formal semantic definitions. To improve the practicality of formal semantic definitions, the PLanCompS project has developed a component-based approach. In this approach, the semantics of a language is defined by translating its constructs (compositionally) to combinations of so-called fundamental constructs, or ‘funcons’. Each funcon is defined using a modular variant of Structural Operational Semantics, and forms a language-independent component that can be reused in definitions of different languages. A substantial library of funcons has been developed and tested in several case studies. Crucially, the definition of each funcon is fixed, and does not need changing when new funcons are added to the library. For specifying component-based semantics, we have designed and implemented a meta-language called CBS. It includes specification of abstract syntax, of its translation to funcons, and of the funcons themselves. Development of CBS specifications is supported by an integrated development environment. The accuracy of a language definition can be tested by executing the specified translation on programs written in the defined language, and then executing the resulting funcon terms using an interpreter generated from the CBS definitions of the funcons. This paper gives an introduction to CBS, illustrates its use, and presents the various tools involved in our implementation of CBS.","programming languages; formal semantics; reuse; components; tool support","en","journal article","","","","","","","","2020-01-07","","","Programming Languages","","",""
"uuid:76808a1e-b735-4b0c-b1ca-37b76c75608f","http://resolver.tudelft.nl/uuid:76808a1e-b735-4b0c-b1ca-37b76c75608f","Towards Language Parametric Web-Based Development Environments","Maas, Olaf (TU Delft Electrical Engineering, Mathematics and Computer Science; TU Delft Software Technology)","Visser, Eelco (mentor); Mosses, Peter (graduation committee); Rellermeyer, Jan (mentor); Delft University of Technology (degree granting institution)","2018","Language Workbenches are instruments developers use to create new domain-specific languages. They provide tools to rapidly develop, test and deploy new languages. Currently, workbenches support deployment in desktop-based integrated development environments. Setting up these environments can be a hurdle for the often non-technical users of these languages. Web-Based IDEs could be a solution in this case, but workbenches are currently not able to deploy languages in these environments.
This work presents the first step towards language workbenches in Web IDEs by creating a language parametric runtime for the browser which serves as a back-end for Spoofax. Combined with an editor, this runtime is the basis for the generation of entirely client-side language playgrounds based on Spoofax specifications. For parsing, this runtime has similar performance characteristics as the existing Spoofax implementation. Code execution in this runtime can be used in environments where performance is not critical.","DynSem; SGLR; Spoofax; programming language; code editor","en","master thesis","","","","","","","","","","","","Computer Science","",""
"uuid:3eedbb63-29ea-4671-a016-4c037eec94cd","http://resolver.tudelft.nl/uuid:3eedbb63-29ea-4671-a016-4c037eec94cd","AlanLight: sound, functionally correct, bounded acyclic data flow modeling","Kunst, GJ (TU Delft Electrical Engineering, Mathematics and Computer Science; TU Delft Software Technology)","Harkes, Daco (mentor); Schraverus, C. (mentor); Visser, Eelco (graduation committee); Spaan, Matthijs (graduation committee); Delft University of Technology (degree granting institution)","2018","For programs controlling industrial processes, it is of vital importance that they produce results conform their functional specification. Furthermore, it is important that their running times are bounded, and that we can predict corresponding worst-case scenarios. Programs written in general purpose programming languages can crash or produce erroneous output. Data modeling and query languages are typically more restrictive. However, they either do not guarantee soundness (where values are of a predefined indivisible type) or functional correctness (including deterministic output). Alternatively, they have unbounded or unpredictable worst-case running times, or have limited expressiveness.
We present AlanLight, a data modeling language for expressing complex recursive calculations, while guaranteeing soundness, functional correctness, and polynomial time complexity in the size of user data. To achieve this, we use complex referential integrity constraints and an elegant, formally defined analysis over constraint and calculation definitions in AlanLight programs. Furthermore, we give a formal specification of the dynamic semantics of AlanLight, implying its guarantees, and demonstrating support for on-demand minimal effort calculation.
Goal: Measure the energy consumption and run-time performance of commonly used programming tasks implemented in different programming languages and executed on a variety of platforms to help developers to choose appropriate implementation platforms.
Method: Obtain measurements to calculate the Energy Delay Product, a weighted function that takes into account a task’s energy consumption and run-time performance. We perform our tests by calculating the Energy Delay Product of 25 programming tasks, found in the Rosetta Code Repository, which are implemented in 14 programming languages and run on three different computer platforms, a server, a laptop, and an embedded system.
Results: Compiled programming languages are outperforming the interpreted ones for most, but not for all tasks. C, C#, and JavaScript are on average the best performing compiled, semi-compiled, and interpreted programming languages for the Energy Delay Product, and Rust appears to be well-placed for i/o-intensive operations, such as file handling. We also find that a good behaviour, energywise, can be the result of clever optimizations and design choices in seemingly unexpected programming languages.","Programming Languages; Energy-Delay-Product; Energy-Efficiency","en","conference paper","Association for Computing Machinery (ACM)","","","","","Accepted author manuscript","","","","","Software Engineering","","",""
"uuid:1dfbb52d-761b-4cb5-9414-d858f8ab2573","http://resolver.tudelft.nl/uuid:1dfbb52d-761b-4cb5-9414-d858f8ab2573","A Domain Specific Language for Computation-in-Memory","Hogervorst, T.A.","Hamdioui, S. (mentor)","2017","The memory-wall problem is a big challenge that classical Von Neumann-based computer systems face. This problem is caused by the increasing performance gap between the main memory and the central processing unit. The novel Computation-in-Memory (CiM) architecture can solve the memory wall problem by using emerging memristor technology to perform both data storage and computation. The CiM architecture’s distinguishing component is a large two-dimensional crossbar on which large amounts of data can be stored, and on which many operations can be executed in parallel. When used as an accelerator to execute massively parallel applications, the CiM architecture can provide significant performance improvements over classical computer systems. However, the implementation of applications on the crossbar of the CiM architecture requires new algorithm specification and compilation techniques, as spatial information about a program is required to obtain an optimal implementation of that program. In this thesis, we introduce a domain-specific language to describe computational patterns and their spatial characteristics. We also design a compiler that is able to transform these patterns into the crossbar implementations of those patterns. We verify both the functional and spatial correctness of the systems generated for the crossbar by describing several distinctly different algorithms in the language, and comparing the compilation results to our expectations. This way, we both show the ability of our language to describe a wide array of applications, and we show that the compiler of the language works correctly.","Computation-in-Memory; Memristor; Programming Language; Skeleton; Compilation; Placement; Routing","en","master thesis","","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Quantum Engineering","","Computer Engineering","CE-MS-2017-01",""
"uuid:bab45902-284f-4f6b-9362-be5b3df7ff20","http://resolver.tudelft.nl/uuid:bab45902-284f-4f6b-9362-be5b3df7ff20","A scalable infrastructure for teaching concepts of programming languages in Scala with WebLab: An experience report","Van Der Lippe, Tim (Student TU Delft); Smith, Thomas (Student TU Delft); Pelsmaeker, Daniël (Student TU Delft); Visser, Eelco (TU Delft Programming Languages)","","2016","In this paper, we report on our experience in teaching a course on concepts of programming languages at TU Delft based on Krishnamurthi's PAPL book with the definitional interpreter approach using Scala as meta-language and using the WebLab learning management system. In particular, we discuss our experience with encoding of definitional interpreters in Scala using case classes, pattern matching, and recursive functions; offering this material in the web-based learning management system WebLab; automated grading and feedback of interpreter submissions using unit tests; testing tests to force students to formulate tests, instead of just implementing interpreters; generation of tests based on a reference implementation to reduce the effort of producing unit tests; and the construction of a product line of interpreters in order to maximize reuse and consistency between reference implementations.","Concepts of programming languages; Definitional interpreters; Scala; Teaching; Testing; WebLab","en","conference paper","Association for Computing Machinery (ACM)","","","","","","","","","","Programming Languages","","",""
"uuid:5df1d39f-adff-4c15-a8dd-81e82e7f0c48","http://resolver.tudelft.nl/uuid:5df1d39f-adff-4c15-a8dd-81e82e7f0c48","Polaris: Providing context aware navigation in spreadsheets","Jansen, B. (TU Delft Software Engineering)","","2016","Spreadsheets are a successful example of an end-user programming language, and the spreadsheet paradigm shares several characteristics like composition, selection, and repetition with programming languages. There are compelling reasons that spreadsheets are code. For most programming languages, developers are supported by powerful IDEs. However, spreadsheets are missing such an IDE. In our current work we are researching how spreadsheet users could be supported by an IDE for spreadsheets and what kind of functionality should be included? As a preliminary result of this research, we introduce in this showpiece: Polaris, an excel Add-in that provides users with context-aware navigation in spreadsheets.","programming environments; programming languages; spreadsheet programs; ubiquitous computing; context aware navigation; spreadsheets; end-programming language; integrated development environments; IDE; Polaris; Navigation; Switches; Computer languages; Software engineering; Visualization; Standards organizations","en","conference paper","","","","","","","","","","","Software Engineering","","",""
"uuid:8174a80b-b048-47df-b4a6-9e48d83bae96","http://resolver.tudelft.nl/uuid:8174a80b-b048-47df-b4a6-9e48d83bae96","MetaC - Embedded Software specific extensions for the C programming language","Stolwijk, A.C.","Langendoen, K.G. (mentor)","2016","Embedded Software appears in a variaty of systems and products. The software for these systems have special requirements. Firstly, embedded software needs to be very robust as it is usually deeply tucked away and not very visible to the user. Secondly, embedded systems have dedicated hardware the software has to work on, and finally embedded systems can have real-time contraints. The C programming language is the most popular programming language for these kinds of systems and meets the requirements. Two disadvantages of C are that it is hard to create higher-level abstractions to solve the problem at hand of the programmer, and it is easier to create bugs compared to more modern languages. To solve these disadvantages we propose the MetaC language, which extends the C language with domain specific extensions tailored for embedded systems. The MetaC compiler compiles MetaC code, including the C language and the extensions, to C code. What extensions can be designed to be helpful for embedded software developers? MetaC implements the C language and adds the following extensions: 1) A bit-fields extension for declaring a bit-fields layout with names and use those names to manipulate the bits instead of using logical operators. 2) State machines to encode the state behavior of a system with new syntax and semantics. That makes it possible to generate state machine diagrams. 3) A concurrency extension for communication between concurrent processes with channels using CSP-style semantics. The extension can generate a model for the PAT model checker. 4) An error handling extension adding error handling constructs that are missing in the C language. Functions can return a new type that indicates the function can return an error. The type system forces programmers to handle the errors of those functions. The MetaC compiler is implemented using the Spoofax Language Workbench, which also provides an Integrated Development Environment (IDE) with common IDE features. The design goals are to implement the extensions in a modular way, to allow separate development of extensions, and to integrate into C as much as possible to give a C feel to the extensions. A BaseC module implements the C compiler while separate modules implement the extensions. The modules are composed into the final MetaC compiler. What are problems implementing MetaC with Spoofax? To reach the design goals several issues had to be solved implementing MetaC with Spoofax. These issues include determining the precedence of new expression operators, composition of scoping rules for new language constructs, and reusing existing name binding rules for new extensions.","Spoofax; C programming language; extensions; domain specific languages; embedded software","en","master thesis","","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Embedded Software","","","",""
"uuid:7a555c92-ee75-4e64-b58b-d8f09662f412","http://resolver.tudelft.nl/uuid:7a555c92-ee75-4e64-b58b-d8f09662f412","A Constraint-based Approach to Name Binding and Type Checking using Scope Graphs","Van Antwerpen, H.","Visser, E. (mentor)","2016","Recently scope graphs were introduced as a formalism to specify the name binding structure of a program and do name resolution independent of the abstract syntax tree of a program. In this thesis we show how to use a constraint language based on scope graphs to do static analysis of programs. We do this by extracting constraints from a program, that specify name binding and typing. We treat binding and typing as separate building blocks, but our approach allows language constructs – such as access of record fields – where name and type resolution are mutually dependent. By using scope graphs for name resolution, our approach supports a wide range of name binding patterns that are not easily supported in existing constraint-based approaches. We present a formal semantics for our constraint language, as well as a solver algorithm, for which we discuss soundness, termination and completeness of the solver. We evaluate our approach by expressing the static semantics of PCF and Featherweight Java with our constraints, and we implemented the solver algorithm, as well as static analysis for both languages, in the Spoofax language workbench.","Programming Languages; Static Program Analysis; Type Checking; Name Resolution; Constraint Solving","en","master thesis","","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Computer Science","","Software Technology","",""
"uuid:2512f403-521a-47af-8fba-bc433509e2ca","http://resolver.tudelft.nl/uuid:2512f403-521a-47af-8fba-bc433509e2ca","DynSem: A DSL for Dynamic Semantics Specification","Vergu, V.; Neron, P.; Visser, E.","","2015","The formal definition the semantics of a programming language and its implementation are typically separately defined, with the risk of divergence such that properties of the formal semantics are not properties of the implementation. In this paper, we present DynSem, a domain-specific language for the specification of the dynamic semantics of programming languages that aims at supporting both formal reasoning and efficient interpretation. DynSem supports the specification of the operational semantics of a language by means of statically typed conditional term reduction rules. DynSem supports concise specification of reduction rules by providing implicit build and match coercions based on reduction arrows and implicit term constructors. DynSem supports modular specification by adopting implicit propagation of semantic components from I-MSOS, which allows omitting propagation of components such as environments and stores from rules that do not affect those. DynSem supports the declaration of native operators for delegation of aspects of the semantics to an external definition or implementation. DynSem supports the definition of auxiliary meta-functions, which can be expressed using regular reduction rules and are subject to semantic component propagation. DynSem specifications are executable through automatic generation of a Java-based AST interpreter.","programming languages; dynamic semantics; reduction semantics; semantics engineering; IDE; interpreters; modularity","en","report","Delft University of Technology, Software Engineering Research Group","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Software Technology","","","",""
"uuid:945e15a0-faaa-48c7-8178-694c16be36f1","http://resolver.tudelft.nl/uuid:945e15a0-faaa-48c7-8178-694c16be36f1","Dynsem: A DSL for dynamic semantics specification","Vergu, V.A. (TU Delft Programming Languages); Neron, P.J.M. (TU Delft Software Engineering); Visser, Eelco (TU Delft Programming Languages)","","2015","The formal semantics of a programming language and its implementation are typically separately defined, with the risk of divergence such that properties of the formal semantics are not properties of the implementation. In this paper, we present DynSem, a domain-specific language for the specification of the dynamic semantics of programming languages that aims at supporting both formal reasoning and efficient interpretation. DynSem supports the specification of the operational semantics of a language by means of statically typed conditional term reduction rules. DynSem supports concise specification of reduction rules by providing implicit build and match coercions based on reduction arrows and implicit term constructors. DynSem supports modular specification by adopting implicit propagation of semantic components from I-MSOS, which allows omitting propagation of components such as environments and stores from rules that do not affect those. DynSem supports the declaration of native operators for delegation of aspects of the semantics to an external definition or implementation. DynSem supports the definition of auxiliary meta-functions, which can be expressed using regular reduction rules and are subject to semantic component propagation. DynSem specifications are executable through automatic generation of a Java-based AST interpreter.","Dynamic semantics; IDE; Interpreters; Modularity; Programming languages; Reduction semantics; Semantics engineering","en","conference paper","Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing","","","","","","","","","","Programming Languages","","",""
"uuid:193830dc-4166-49a9-86da-b06f910b5425","http://resolver.tudelft.nl/uuid:193830dc-4166-49a9-86da-b06f910b5425","Understanding software through linguistic abstraction","Visser, Eelco (TU Delft Programming Languages; TU Delft Software Technology)","","2015","In this essay, I argue that linguistic abstraction should be used systematically as a tool to capture our emerging understanding of domains of computation. Moreover, to enable that systematic application, we need to capture our understanding of the domain of linguistic abstraction itself in higher-level meta languages. The argument is illustrated with examples from the SDF, Stratego, Spoofax, and WebDSL projects in which I explore these ideas.","Domain-specific languages; Linguistic abstraction; Programming languages; Software understanding","en","journal article","","","","","","Accepted Author Manuscript","","2017-01-01","","Software Technology","Programming Languages","","",""
"uuid:e558e01e-443c-4cc7-9fed-9ccf0313e971","http://resolver.tudelft.nl/uuid:e558e01e-443c-4cc7-9fed-9ccf0313e971","Relations in Role-Based Data Modeling and Navigation","Harkes, D.C.","Visser, E. (mentor)","2014","Object-oriented programming languages support concise navigation of relations represented by references. However, relations are not first-class citizens and bidirectional navigation is not supported. The relational paradigm provides first-class relations, but with bidirectional navigation through verbose queries. We present a systematic analysis of approaches to modeling and navigating relations. By unifying and generalizing the features of these approaches, we developed the design of a data modeling language that features first-class relations, n-ary relations, native multiplicities, bidirectional relations and concise navigation. The language static and dynamic semantics are formally specified and the language is implemented in the Spoofax language workbench. Evaluation of this implementation shows the language is concise and has good usability but lacks expressiveness.","relations; data modeling; data navigation; programming language; multiplicities","en","master thesis","","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Computer Science","","Software Technology","",""
"uuid:cd24a630-2669-44cd-87a3-3df150ae73a9","http://resolver.tudelft.nl/uuid:cd24a630-2669-44cd-87a3-3df150ae73a9","Understanding software through linguistic abstraction","Visser, E.","","2013","Preprint submitted to ""Science of Computer Programming"", Elsevier, http://dx.doi.org/10.1016/j.scico.2013.12.001 In this essay, I argue that linguistic abstraction should be used systematically as a tool to capture our emerging understanding of domains of computation. Moreover, to enable that systematic application, we need to capture our understanding of the domain of linguistic abstraction itself in higher-level meta languages. The argument is illustrated with examples from the SDF, Stratego, Spoofax, and WebDSL projects in which I explore these ideas.","linguistic abstraction; programming languages; domain-specific languages; software understanding","en","report","Delft University of Technology, Software Engineering Research Group","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Software Computer Technology","","","",""
"uuid:c4826844-77f6-4ee4-8b62-799fdbf12ee5","http://resolver.tudelft.nl/uuid:c4826844-77f6-4ee4-8b62-799fdbf12ee5","A Qualitative Comparative Study between Posh and GOAL for Programming UT2004 Bots","Korstanje, M.P.","Jonker, C.M. (mentor); Hindriks, K.V. (mentor); Zaidman, A. (mentor)","2013","A variety of agent programming languages have been proposed in the literature but only few comparative studies have been performed to evaluate the strengths and weaknesses of these languages. In order to gain a better understanding of the programming features and the use of these features by programmers it is imperative to perform studies on various programming tasks in these languages. Such studies advance our knowledge of the benefits of using agent-oriented languages and may contribute positively to the evolution of these languages. As a first step we perform an analysis of the submissions to the Multi-Agent Programming Contest. We look at common patterns, structures and methodologies used. Additionally a functional categorization is made to identify common structures in the agent program. We discover that participants favor modular abstractions and simple decision structures. Iterative methodologies seem to perform better. Based on these findings we provide a set of recommendations that agent programming languages should follow. We also use these findings to design the study which is the primary focus of this thesis. In this study we compare the performance of programmers on tasks that use the agent programming frameworks GOAL and POSH. The aim of the study was to investigate any differences in usability of the frameworks as well as differences between novice and more advanced programmers using either framework. The results suggest that there is no significant difference for the given tasks between both frameworks. We did find that general programming experience seems to be a relatively big advantage when using a (new) programming language. Analysis of the assignment and the observations made about the use of the frameworks, however, suggest that the experimental design can be adapted in such a way that differences in usability of the frameworks can be established.","agents; GOAL; POSH; agent programming; agent programming languages","en","master thesis","","","","","","","","2013-09-11","Electrical Engineering, Mathematics and Computer Science","Interactive Inteligence","","Computer Science","",""
"uuid:d649654d-3be2-4f68-93a6-77d252e95ba2","http://resolver.tudelft.nl/uuid:d649654d-3be2-4f68-93a6-77d252e95ba2","Encapsulating Software Platform Logic by Aspect-Oriented Programming: A Case Study in Using Aspects for Language Portability","Kats, L.C.; Visser, E.","","2010","Software platforms such as the Java Virtual Machine or the CLR .NET virtual machine have their own ecosystem of a core programming language or instruction set, libraries, and developer community. Programming languages can target multiple software platforms to increase interoperability or to boost performance. Introducing a new compiler backend for a language is the first step towards targeting a new platform, translating the language to the platform’s language or instruction set. Programs written in modern languages generally make extensive use of APIs, based on the runtime system of the software platform, introducing additional portability concerns. They may use APIs that are implemented by platform-specific libraries. Libraries may perform platform-specific operations, make direct native calls, or make assumptions about performance characteristics of operations or about the file system. This paper proposes to use aspect weaving to invasively adapt programs and libraries to address such portability concerns, and identifies four classes of aspects for this purpose. We evaluate this approach through a case study where we retarget the Stratego program transformation language towards the Java Virtual Machine Preprint accepted for publication in Proceedings of the Tenth IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2010), Timisoara (Romania), 12-13 Sept. 2010","programming languages; compilers; aspect-oriented programming; Stratego; Spoofax; Java","en","report","Delft University of Technology, Software Engineering Research Group","","","","","","","","Electrical Engineering, Mathematics and Computer Science","Software Technology","","","",""
"uuid:25d88441-7ecb-4327-9271-19fc76fb0a61","http://resolver.tudelft.nl/uuid:25d88441-7ecb-4327-9271-19fc76fb0a61","Model checking GOAL agents","Jongmans, S.S.T.Q.","Hindriks, K.V. (mentor); Van Riemsdijk, M.B. (mentor)","2010","This thesis presents a novel approach to model checking of agent programs written in an agent programming language. The language we consider is GOAL. The novelty of the approach is that we implement model checking algorithms from scratch on top of the standard language interpreter. In contrast, in the literature on agent program verification, agents are translated to the input language of an existing model checker, after which this verification tool is used as usual for actual model checking. We present an implementation, and show that our approach performs substantially better in terms of resource consumption than existing model checkers for GOAL. Moreover, our approach allows for more expressive property specification languages and has benefits from a software engineering point of view: the implementation of a language interpreter is gained for free. Both conceptually and on the implementation level, our approach is generic and can be applied to other agent programming languages as well. Additionally, we investigate state space reduction techniques tailored to GOAL, namely property-based slicing and partial order reduction, to further optimise our model checker's performance. To this end, we develop a static source code analysis method for GOAL agents. Case studies with both techniques show that substantial reductions can be gained when certain conditions are met.","model checking; GOAL; agents; formal verification; agent programming language","en","master thesis","","","","","","","","2010-08-28","Electrical Engineering, Mathematics and Computer Science","Mediamatics","","Man-Machine Interaction Group","",""
"uuid:d8dbfde0-756e-4868-a1d7-b51207a62bee","http://resolver.tudelft.nl/uuid:d8dbfde0-756e-4868-a1d7-b51207a62bee","Verifikatie van de Fortran implementatie van het RRSQRT-filter","Boogaard, H.F.P. van den","","1996","","ijking; calibration; programmeertalen; programming languages; wiskundige filters; mathematical filters; stromingsmodellen; flow models","nl","report","Deltares (WL)","","","","","","","","","","","","",""
"uuid:8abdfd1c-ba45-4c72-918b-5be7b26914df","http://resolver.tudelft.nl/uuid:8abdfd1c-ba45-4c72-918b-5be7b26914df","An efficient data structure and algorithm for VLSI artwork verification","Fokkema, J.T.; Van Leuken, T.G.R.","","1983","","circuit-layout-CAD complete-computer-programs data-structures large-scale-integration program-listing circuit-layout-CAD data-structure algorithm- VLSI- polygon- vertical-line line-segments stateruler- programming-language-C UNIX-operating-system VAX-11-7","en","conference paper","IEEE Comput. Soc. Press, Silver Spring, MD, USA","","","","","","","","","","","","",""