scispace - formally typeset
Search or ask a question
Author

Marko van Eekelen

Bio: Marko van Eekelen is an academic researcher from Open University. The author has contributed to research in topics: Functional programming & Semantics (computer science). The author has an hindex of 20, co-authored 123 publications receiving 1554 citations. Previous affiliations of Marko van Eekelen include Cologne University of Applied Sciences & Radboud University Nijmegen.


Papers
More filters
Book
01 Jul 1993
TL;DR: This book illustrates the techniques of functional programming in Miranda and Clean, and focuses on the computational model of Graph Rewriting Systems for both sequential and parallel machines.
Abstract: From the Publisher: The descriptive power and semantic elegance of modern functional languages make it possible to develop correct programs relatively quickly. Efficient implementations of functional languages, employing graph rewriting techniques, have only recently become available. This book illustrates the techniques of functional programming in Miranda and Clean, and focuses on the computational model of Graph Rewriting Systems for both sequential and parallel machines. Highlights of the book include a clear tutorial guide to functional programming in Miranda and Clean, in-depth coverage of implementation on both sequential and parallel machines, and unique focus on Graph Rewriting Systems as a computational model. The book will be equally valuable for students taking courses in functional programming, and for programmers or systems designers who are keen to explore state-of-the-art programming and implementation techniques. The Concurrent Clean System, which is available from the authors, offers the opportunity to write both sequential and parallel applications (including window-based systems) in a pure, lazy functional language.

273 citations

Book ChapterDOI
14 Sep 1987
TL;DR: A sequential implementation of Clean on a conventional machine is described and its performance is compared with other systems to show that Clean can be efficiently implemented.
Abstract: Clean is an experimental language for specifying functional computations in terms of graph rewriting. It is based on an extension of Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a, possibly cyclic, directed graph, called the data graph and graph rewrite rules which specify how this data graph may be rewritten. Clean is designed to provide a firm base for functional programming. In particular, Clean is suitable as an intermediate language between functional languages and (parallel) target machine architectures. A sequential implementation of Clean on a conventional machine is described and its performance is compared with other systems. The results show that Clean can be efficiently implemented.

154 citations

10 Jun 1991
TL;DR: The quality of the code generated by the Clean compiler has been greatly improved such that it is one of the best code generators for a lazy functional language.
Abstract: Concurrent Clean is an experimental, lazy, higher-order parallel functional programming language based on term graph rewriting. An important diierence with other languages is that in Clean graphs are manipulated and not terms. This can be used by the programmer to control communication and sharing of computation. Cyclic structures can be deened. Concurrent Clean furthermore allows to control the (parallel) order of evaluation to make eecient evaluation possible. With help of sequential annotations the default lazy evaluation can be locally changed into eager evaluation. The language enables the deenition of partially strict data structures which make a whole new class of algorithms feasible in a functional language. A powerful and fast strictness analyser is incorporated in the system. The quality of the code generated by the Clean compiler has been greatly improved such that it is one of the best code generators for a lazy functional language. Two very powerful parallel annotations enable the programmer to deene concurrent functional programs with arbitrary process topologies. Concurrent Clean is set up in such a way that the eeciency achieved for the sequential case can largely be maintained for a parallel implementation on loosely coupled parallel machine architectures.

95 citations

Proceedings ArticleDOI
16 May 2015
TL;DR: A system-level metric based on an industry benchmark is proposed and investigated, showing that the measurements are considered useful, and that systems using outdated dependencies are four times as likely to have security issues as opposed to systems that are up-to-date.
Abstract: Modern software systems often make use of third-party components to speed-up development and reduce maintenance costs. In return, developers need to update to new releases of these dependencies to avoid, for example, security and compatibility risks. In practice, prioritizing these updates is difficult because the use of outdated dependencies is often opaque. In this paper we aim to make this concept more transparent by introducing metrics to quantify the use of recent versions of dependencies, i.e. The system's "dependency freshness". We propose and investigate a system-level metric based on an industry benchmark. We validate the usefulness of the metric using interviews, analyze the variance of the metric through time, and investigate the relationship between outdated dependencies and security vulnerabilities. The results show that the measurements are considered useful, and that systems using outdated dependencies four times as likely to have security issues as opposed to systems that are up-to-date.

80 citations

Book ChapterDOI
24 Sep 2001
TL;DR: This paper presents a small example proof built in SPARKLE and it will be shown that building this proof is easy and requires little effort.
Abstract: SPARKLE is a new theorem prover written in and specialized for the functional programming language CLEAN. It is mainly intended to be used by programmers for proving properties of parts of programs, combining programming and reasoning into one process. It can also be used by logicians interested in proving properties of larger programs.Two features of SPARKLE are in particular helpful for programmers. Firstly, SPARKLE is integrated in CLEAN and has a semantics based on lazy graph-rewriting. This allows reasoning to take place on the program itself, rather than on a translation that uses different concepts. Secondly, Sparkle supports automated reasoning. Trivial goals will automatically be discarded and suggestions will be given on more difficult goals.This paper presents a small example proof built in SPARKLE. It will be shown that building this proof is easy and requires little effort.

56 citations


Cited by
More filters
01 Jan 1978
TL;DR: This ebook is the first authorized digital version of Kernighan and Ritchie's 1988 classic, The C Programming Language (2nd Ed.), and is a "must-have" reference for every serious programmer's digital library.
Abstract: This ebook is the first authorized digital version of Kernighan and Ritchie's 1988 classic, The C Programming Language (2nd Ed.). One of the best-selling programming books published in the last fifty years, "K&R" has been called everything from the "bible" to "a landmark in computer science" and it has influenced generations of programmers. Available now for all leading ebook platforms, this concise and beautifully written text is a "must-have" reference for every serious programmers digital library. As modestly described by the authors in the Preface to the First Edition, this "is not an introductory programming manual; it assumes some familiarity with basic programming concepts like variables, assignment statements, loops, and functions. Nonetheless, a novice programmer should be able to read along and pick up the language, although access to a more knowledgeable colleague will help."

2,120 citations

Book
31 Jul 2013
TL;DR: The Lambda Calculus has been extended with types and used in functional programming (Haskell, Clean) and proof assistants (Coq, Isabelle, HOL), used in designing and verifying IT products and mathematical proofs.
Abstract: This handbook with exercises reveals in formalisms, hitherto mainly used for hardware and software design and verification, unexpected mathematical beauty. The lambda calculus forms a prototype universal programming language, which in its untyped version is related to Lisp, and was treated in the first author's classic The Lambda Calculus (1984). The formalism has since been extended with types and used in functional programming (Haskell, Clean) and proof assistants (Coq, Isabelle, HOL), used in designing and verifying IT products and mathematical proofs. In this book, the authors focus on three classes of typing for lambda terms: simple types, recursive types and intersection types. It is in these three formalisms of terms and types that the unexpected mathematical beauty is revealed. The treatment is authoritative and comprehensive, complemented by an exhaustive bibliography, and numerous exercises are provided to deepen the readers' understanding and increase their confidence using types.

927 citations

Journal ArticleDOI
TL;DR: A comprehensive review of the gamification research is provided and a comprehensive discussion is provided on future agenda for the growing vein of literature on gamification and gameful systems within the information system science field.

729 citations