Programming Language Theory Research Articles

Pengaruh Bahasa Pemrograman Scratch Terhadap Peningkatan Hasil Belajar Informatika Siswa di SD Islam Al-Azhar 32 Padang

This research is motivated by the implementation of Informatics learning at SD Islam Al-Azhar 32 Padang. The theory and practice of programming languages ​​is included in the Informatics material but is not implemented so that the ability to recognize and understand programming languages ​​in children has not yet emerged. Apart from that, the Informatics learning outcomes of students who have not yet reached the KKM are 70. This research aims to determine the effect of the scratch programming language in improving the Informatics learning outcomes of class IV students at Al-Azhar 32 Islamic Elementary School in Padang. This type of research is quantitative research. This quantitative research uses experimental methods. As for several types of experimental methods, researchers used Quasi Experiments. Then, the research design pattern used in this research uses the non-equivalent group design. The non-equivalent group design is a design that requires the existence of an experimental and control group. This is because the determination of the hypothesis is based on the results of the observations of the two groups. Determination of experimental and control groups is not random. These two groups will later be tested using the same instruments and analyzing which treatment is more optimal

Graphical Arduino IDE system with wiring layout and flowchart functions for physical computing education

AbstractArduino, a widely used tool for physical computing, is favored for its affordability and easy availability. However, a drawback for beginners is the requirement of prior knowledge of C programming language and circuit theory for effectively utilizing Arduino. In this research, we address this issue by developing a Graphical Arduino IDE system that allows users to control Arduino without the need for prior knowledge of C language and circuit theory. Users can create node graph‐based scripts in the Wiring Tab of the Graphical Arduino IDE and develop flowchart‐based scripts in the Algorithm Tab. The scripts created in the Wiring Tab serve as guidelines for wiring, thus preventing users from making wiring mistakes. Additionally, users without knowledge of C language can control Arduino by creating flowchart‐based scripts in the Algorithm Tab. The finalized scripts are converted into Arduino code and uploaded to the Arduino board using the built‐in Code Upload feature. Finally, a paired t test was conducted between the Graphical Arduino IDE and Scratch for Arduino, confirming that the Graphical Arduino IDE required fewer user inputs.

Witnessability of Undecidable Problems

Many problems in programming language theory and formal methods are undecidable, so they cannot be solved precisely. Practical techniques for dealing with undecidable problems are often based on decidable approximations. Undecidability implies that those approximations are always imprecise. Typically, practitioners use heuristics and ad hoc reasoning to identify imprecision issues and improve approximations, but there is a lack of computability-theoretic foundations about whether those efforts can succeed. This paper shows a surprising interplay between undecidability and decidable approximations: there exists a class of undecidable problems, such that it is computable to transform any decidable approximation to a witness input demonstrating its imprecision. We call those undecidable problems witnessable problems . For example, if a program property P is witnessable, then there exists a computable function f P , such that f P takes as input the code of any program analyzer targeting P and produces an input program w on which the program analyzer is imprecise. An even more surprising fact is that the class of witnessable problems includes almost all undecidable problems in programming language theory and formal methods. Specifically, we prove the diagonal halting problem K is witnessable, and the class of witnessable problems is closed under complements and many-one reductions. In particular, all “non-trivial semantic properties of programs” mentioned in Rice’s theorem are witnessable. We also explicitly construct a problem in the non-witnessable (and undecidable) class and show that both classes have cardinality 2 ℵ 0 . Our results offer a new perspective on the understanding of undecidability: for witnessable problems, although it is impossible to solve them precisely, it is always possible to improve any decidable approximation to make it closer to the precise solution. This fact formally demonstrates that research efforts on such approximations are promising and shows there exist universal ways to identify precision issues of program analyzers, program verifiers, SMT solvers, etc., because their essences are decidable approximations of witnessable problems.

Development and Application of a Software Tool to Support the Teaching of Formal Languages

The purpose of the article is to present the results of a study on the possibility of using a deductive approach in the study of programming languages (from the theory of formal languages to specific programming languages) and the development of a training system for implementing this approach. The issue of training specialists in the field of information technology is still relevant, and the variety of programming languages is so great that it is not always possible to guess which of them will be in demand in professional activities. According to the authors, the application of this approach will allow you to see common elements and find syntactic differences in programming languages, and therefore simplify and speed up their development. The article analyzes the methods of teaching programming, substantiates the relevance of learning formal languages by future IT specialists, formulates the requirements for a software tool to support learning formal languages, describes its implementation. Materials and methods. Theory of formal languages, syntax and semantics of programming languages, lexical analysis, analysis of various sources of information on the subject under study, systematization of the collected data, technologies for designing, implementing and testing software products, experimental research. Results. A methodology for learning programming languages through formal languages is proposed. A software training system has been created that allows you to link the theory of formal languages with high-level languages through appropriate examples. The algorithm of checking the correctness of the task execution by means of syntactic analysis of the program entered by the student and imitation of its execution is developed and implemented in the specified system. Experiments have shown the feasibility of the approach and the performance of the software product. Currently, the developed system is used at Vologda State University when teaching the disciplines “Theory of programming languages and translation methods” and “Theory of automata and formal languages”. Conclusion. The results of the study show the acceptability of the proposed approach and the expediency of using the developed program when learning programming languages.

The history of Standard ML

The ML family of strict functional languages, which includes F#, OCaml, and Standard ML, evolved from the Meta Language of the LCF theorem proving system developed by Robin Milner and his research group at the University of Edinburgh in the 1970s. This paper focuses on the history of Standard ML, which plays a central role in this family of languages, as it was the first to include the complete set of features that we now associate with the name “ML” (i.e., polymorphic type inference, datatypes with pattern matching, modules, exceptions, and mutable state). Standard ML, and the ML family of languages, have had enormous influence on the world of programming language design and theory. ML is the foremost exemplar of a functional programming language with strict evaluation (call-by-value) and static typing. The use of parametric polymorphism in its type system, together with the automatic inference of such types, has influenced a wide variety of modern languages (where polymorphism is often referred to as generics ). It has popularized the idea of datatypes with associated case analysis by pattern matching. The module system of Standard ML extends the notion of type-level parameterization to large-scale programming with the notion of parametric modules, or functors . Standard ML also set a precedent by being a language whose design included a formal definition with an associated metatheory of mathematical proofs (such as soundness of the type system). A formal definition was one of the explicit goals from the beginning of the project. While some previous languages had rigorous definitions, these definitions were not integral to the design process, and the formal part was limited to the language syntax and possibly dynamic semantics or static semantics, but not both. The paper covers the early history of ML, the subsequent efforts to define a standard ML language, and the development of its major features and its formal definition. We also review the impact that the language had on programming-language research.

Interactive Teaching of Programming Language Theory with a Proof Assistant

Teaching of programming language theory has a long track record at ELTE Faculty of Informatics. Traditionally, formal semantics and type systems of programming languages, similarly to other theory-oriented subjects, were taught with the pen and paper method. However, modern proof assistants call for replacing this old-fashioned way of teaching with novel and interactive methods that bring deeper understanding, provide better learning experience and build technical skills in applying formal methods. The authors have launched practice classes for two programming language theory subjects and carefully developed course material based on executable and verifiable definitions formalised in the Coq proof assistant. In this paper, we share our experiences regarding the design and implementation of the new material, we outline the pros and cons of using a proof assistant in the courses, and we describe how the presented method may be adapted to other courses.

Programming language foundations in Agda

• PLFA is an online textbook, available at plfa.inf.ed.ac.uk . • The proofs for a textbook on programming languages can be written in Agda, without a separate scripting language. • Constructive proofs of preservation and progress give rise to a prototype evaluator. • Using raw terms with a separate typing relation is far less perspicuous than using inherently-typed terms. • An online final examination with access to a proof assistant can lead to flawless student performance. One of the leading textbooks for formal methods is Software Foundations (SF), written by Benjamin Pierce in collaboration with others, and based on Coq. After five years using SF in the classroom, we came to the conclusion that Coq is not the best vehicle for this purpose, as too much of the course needs to focus on learning tactics for proof derivation, to the cost of learning programming language theory. Accordingly, we have written a new textbook, Programming Language Foundations in Agda (PLFA). PLFA covers much of the same ground as SF, although it is not a slavish imitation. What did we learn from writing PLFA? First, that it is possible. One might expect that without proof tactics that the proofs become too long, but in fact proofs in PLFA are about the same length as those in SF. Proofs in Coq require an interactive environment to be understood, while proofs in Agda can be read on the page. Second, that constructive proofs of preservation and progress give immediate rise to a prototype evaluator. This fact is obvious in retrospect but it is not exploited in SF (which instead provides a separate normalise tactic) nor can we find it in the literature. Third, that using extrinsically-typed terms is far less perspicuous than using intrinsically-typed terms. SF uses the former presentation, while PLFA presents both; the former uses about 1.6 as many lines of Agda code as the latter, roughly the golden ratio. The textbook is written as a literate Agda script, and can be found here: http://plfa.inf.ed.ac.uk

PλωNK: functional probabilistic NetKAT

This work presents PλωNK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient. The formalisation of PλωNK is challenging for two reasons: Firstly, network programming induces multiple side effects (in particular, parallelism and probabilistic choice) which need to be carefully controlled in a functional setting. Our system uses an explicit syntax for thunks and sequencing which makes the interplay of these effects explicit. Secondly, measure theory, the standard domain for formalisations of (continuous) probablistic languages, does not admit higher-order functions. We address this by leveraging ω-Quasi Borel Spaces (ωQBSes), a recent advancement in the domain theory of probabilistic programming languages. We believe that our work is not only useful for bringing abstraction to PNK, but that—as part of our contribution—we have developed the meta-theory for a probabilistic language that combines advanced features like higher-order functions, iteration and parallelism, which may inform similar meta-theoretic efforts.

How to prove decidability of equational theories with second-order computation analyser SOL

Abstract We present a general methodology of proving the decidability of equational theory of programming language concepts in the framework of second-order algebraic theories. We propose a Haskell-based analysis tool, i.e. Second-Order Laboratory, which assists the proofs of confluence and strong normalisation of computation rules derived from second-order algebraic theories. To cover various examples in programming language theory, we combine and extend both syntactical and semantical results of the second-order computation in a non-trivial manner. We demonstrate how to prove decidability of various algebraic theories in the literature. It includes the equational theories of monad and λ-calculi, Plotkin and Power’s theory of states and bits, and Stark’s theory of π-calculus. We also demonstrate how this methodology can solve the coherence of monoidal categories.

Silver Bullet Talks With Kathleen Fisher [Interview

Kathleen Fisher is a professor in and chair of the Tufts Department of Computer Science. Previously, Dr. Fisher was a program manager at DARPA, where she started and managed High-Assurance Cyber Military Systems (HACMS) and Probabilistic Programming for Advancing Machine Learning (PPAML). She also has been a faculty member at Stanford University and a principal member of the technical staff at ATaT Labs Research. Kathleen's research focuses on advancing the theory and practice of programming languages. Recently, she's been exploring synergies between machine learning and programming languages with an emphasis on building more secure systems.

Making containers lazy with Docker and CernVM-FS

Containerization technology is becoming more and more popular because it provides an efficient way to improve deployment flexibility by packaging up code into software micro-environments. Yet, containerization has limitations and one of the main ones is the fact that entire container images need to be transferred before they can be used. Container images can be seen as software stacks and High Energy Physics has long solved the distribution problem for large software stacks with CernVM-FS. CernVM-FS provides a global, shared software area, where clients only load the small subset of binaries that are accessed for any given compute job.In this paper, we propose a solution to the problem of efficient image distribution using CernVM-FS for storage and transport of container images. We chose to implement our solution for the Docker platform, due to its popularity and widespread use. To minimize the impact on existing workflows our implementation comes as a Docker plugin, meaning that users will continue to pull, run, modify, and store Docker images using standard Docker tools.We introduce the concept of a thin image, whose contents are served on demand from CernVM-FS repositories. Such behavior closely reassembles the lazy evaluation strategy in programming language theory. Our measurements confirm that the time before a task starts executing depends only on the size of the files actually used, minimizing the cold start-up time in all cases.

A customised automata algorithm and toolkit for language learning and application

Automata are abstract computing machines. They play a basic role in computability theory and programming language theory. More recently in data analytics, data automata have become a formal way to represent pipelines and workflows. However, in researches involved with automata, there are still situations where redundant work and ununified standards occur. In order to solve that problem, we propose a new toolkit: CAT, which provides a simple and unified framework for automaton construction and customisation. We adopted both structural and behavioural analysis in order to design the body structure. Several calculus algorithms are implemented according to the theoretical accomplishments and designed as overloaded operators. To test the correctness and performance of this toolkit, several bare automata were constructed and compared with 'GREP' in Ubuntu Linux. The result showed that CAT has realised most of the design purposes and presents a more illustrative way for writing codes of automata construction and calculation.

A customised automata algorithm and toolkit for language learning and application

Automata are abstract computing machines. They play a basic role in computability theory and programming language theory. More recently in data analytics, data automata have become a formal way to represent pipelines and workflows. However, in researches involved with automata, there are still situations where redundant work and ununified standards occur. In order to solve that problem, we propose a new toolkit: CAT, which provides a simple and unified framework for automaton construction and customisation. We adopted both structural and behavioural analysis in order to design the body structure. Several calculus algorithms are implemented according to the theoretical accomplishments and designed as overloaded operators. To test the correctness and performance of this toolkit, several bare automata were constructed and compared with 'GREP' in Ubuntu Linux. The result showed that CAT has realised most of the design purposes and presents a more illustrative way for writing codes of automata construction and calculation.

How to prove your calculus is decidable: practical applications of second-order algebraic theories and computation

We present a general methodology of proving the decidability of equational theory of programming language concepts in the framework of second-order algebraic theories. We propose a Haskell-based analysis tool SOL, Second-Order Laboratory, which assists the proofs of confluence and strong normalisation of computation rules derived from second-order algebraic theories. To cover various examples in programming language theory, we combine and extend both syntactical and semantical results of second-order computation in a non-trivial manner. We demonstrate how to prove decidability of various algebraic theories in the literature. It includes the equational theories of monad and lambda-calculi, Plotkin and Power's theory of states, and Stark's theory of pi-calculus.

Redexes are stable in the λ-calculus

In the theory of sequential programming languages, Berry's stability property is an important step claiming that values have unique origins in their calculations. It has been shown that Bohm trees are stable in the λ-calculus, meaning that there is a unique minimum prefix of any lambda term which computes its Bohm tree. Moreover this property is also true for finite prefixes of Bohm trees. The proof relies on Curry's standardization theorem as initially pointed out by Plotkin in his famous articleLCF considered as a programming language. In this paper we will show that the stability property also holds for redexes. Namely for any redex family, there is a unique minimum calculation and a unique redex which computes this family. This property was already known in the study of optimal reductions, but we stress here on stability and want to show that stability is inside the basic objects of calculations. The proof will be based on nice commutations between residuals and creations of new redexes. Our tool for proving this property will be the labelled lambda calculus used in the study of optimal reductions.

Confluence for classical logic through the distinction between values and computations

We apply an idea originated in the theory of programming languages - monadic meta-language with a distinction between values and computations - in the design of a calculus of cut-elimination for classical logic. The cut-elimination calculus we obtain comprehends the call-by-name and call-by-value fragments of Curien-Herbelin's lambda-bar-mu-mu-tilde-calculus without losing confluence, and is based on a distinction of "modes" in the proof expressions and "mode" annotations in types. Modes resemble colors and polarities, but are quite different: we give meaning to them in terms of a monadic meta-language where the distinction between values and computations is fully explored. This meta-language is a refinement of the classical monadic language previously introduced by the authors, and is also developed in the paper.

Voevodsky’s Univalence Axiom in Homotopy Type Theory

In this short note we give a glimpse of homotopy type theory, a new field of mathematics at the intersection of algebraic topology and mathematical logic, and we explain Vladimir Voevodsky’s univalent interpretation of it. This interpretation has given rise to the univalent foundations program, which is the topic of the current special year at the Institute for Advanced Study. The Institute for Advanced Study in Princeton is hosting a special program during the academic year 2012-2013 on a new research theme that is based on recently discovered connections between homotopy theory, a branch of algebraic topology, and type theory, a branch of mathematical logic and theoretical computer science. In this brief paper our goal is to take a glance at these developments. For those readers who would like to learn more about them, we recommend a number of references throughout. Type theory was invented by Bertrand Russell [20], but it was first developed as a rigorous formal system by Alonzo Church [3, 4, 5]. It now has numerous applications in computer science, especially in the theory of programming languages [19]. Per Martin-Lof [15, 11, 13, 14], among others, developed a generalization of Church’s system which is now usually called dependent, constructive, or simply Martin-Lof type theory; this is the system that we consider here. It was originally intended as a rigorous framework for constructive mathematics. In type theory objects are classified using a primitive notion of type, similar to the data-types used in programming languages. And as in programming languages, these elaborately structured types can be used to express detailed specifications of the objects classified, giving rise to principles of reasoning about them. To take a simple example, the objects of a product type A × B are known to be of the form 〈a, b〉, and so one automatically knows how to form them and how to decompose them. This aspect of type

Introduction to the theory of programming languages

Introduction to the theory of programming languages

Towards Modular Development of Typed Unification Grammars

Development of large-scale grammars for natural languages is a complicated endeavor: Grammars are developed collaboratively by teams of linguists, computational linguists, and computer scientists, in a process very similar to the development of large-scale software. Grammars are written in grammatical formalisms that resemble very-high-level programming languages, and are thus very similar to computer programs. Yet grammar engineering is still in its infancy: Few grammar development environments support sophisticated modularized grammar development, in the form of distribution of the grammar development effort, combination of sub-grammars, separate compilation and automatic linkage, information encapsulation, and so forth. This work provides preliminary foundations for modular construction of (typed) unification grammars for natural languages. Much of the information in such formalisms is encoded by the type signature, and we subsequently address the problem through the distribution of the signature among the different modules. We define signature modules and provide operators of module combination. Modules may specify only partial information about the components of the signature and may communicate through parameters, similarly to function calls in programming languages. Our definitions are inspired by methods and techniques of programming language theory and software engineering and are motivated by the actual needs of grammar developers, obtained through a careful examination of existing grammars. We show that our definitions meet these needs by conforming to a detailed set of desiderata. We demonstrate the utility of our definitions by providing a modular design of the HPSG grammar of Pollard and Sag.

Lambda, the ultimate TA

Ambitious experiments using proof assistants for programming language research and teaching are all the rage. In this talk, I'll report on one now underway at the University of Pennsylvania and several other sites: a one-semester graduate course in the theory of programming languages presented entirely - every lecture, every homework assignment - in Coq. I'll try to give a sense of what the course is like for both instructors and students, describe some of the most interesting challenges in developing it, and explain why I now believe such machine-assisted courses are the way of the future.