Henrik Nilsson

Dr. Henrik Nilsson


Research Focus & Metrics

Academic Career Length

33Years (1994-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
3 October 2002
Verified
Conference Paper
Open access
PDF file
HNHenrik Nilsson
Henrik Nilsson
ACAntony Courtney
Antony Courtney
JPJohn Peterson
John Peterson
Functional Reactive Programming (FRP) extends a host programming language with a notion of time flow. Arrowized FRP (AFRP) is a version of FRP embedded in Haskell based on the arrow combinators. AFRP is a powerful synchronous dataflow programming language with hybrid modeling capabilities, combining advanced synchronous dataflow features with the higher-order lazy functional abstractions of Haskell. In this paper, we describe the AFRP programming style and our Haskell-based implementation. Of particular interest are the AFRP combinators that support dynamic collections and continuation-based switching. We show how these combinators can be used to express systems with an evolving structure that are difficult to model in more traditional dataflow languages.

1 January 2003 in Lecture Notes in Computer Science
Verified
Book Chapter
Closed access
PDF file
PHPaul Hudak
Paul Hudak
ACAntony Courtney
Antony Courtney
HNHenrik Nilsson
Henrik Nilsson
JPJohn Peterson
John Peterson

28 August 2003
Verified
Conference Paper
Open access
PDF file
ACAntony Courtney
Antony Courtney
HNHenrik Nilsson
Henrik Nilsson
JPJohn Peterson
John Peterson
Simulated worlds are a common (and highly lucrative) application domain that stretches from detailed simulation of physical systems to elaborate video game fantasies. We believe that Functional Reactive Programming (FRP) provides just the right level of functionality to develop simulated worlds in a concise, clear and modular way. We demonstrate the use of FRP in this domain by presenting an implementation of the classic "Space Invaders" game in Yampa, our most recent Haskell-embedded incarnation of FRP.

1 April 1997 in Automated Software Engineering
Verified
Journal Article
Closed access
PDF file
HNHenrik Nilsson
Henrik Nilsson
JSJan Sparud
Jan Sparud

1 April 1994 in Journal of Functional Programming
Verified
Journal Article
Closed access
PDF file
HNHenrik Nilsson
Henrik Nilsson
PFPeter Fritzson
Peter Fritzson
Lazy functional languages have non-strict semantics and are purely declarative, i.e. they support the notion of referential transparency and are devoid of side-effects. Traditional debugging techniques are, however, not suited for lazy functional languages, since computations generally do not take place in the order one might expect. Since algorithmic debugging allows the user to concentrate on the declarative aspects of program semantics, and will semi-automatically find functions containing bugs, we propose to use this technique for debugging lazy functional programs. Because of the non-strict semantics of lazy functional languages, arguments to functions are in general partially evaluated expressions. The user is, however, usually more concerned with the values that these expressions represent. We address this problem by providing the user with a strictified view of the execution trace whenever possible. In this paper, we present an algorithmic debugger for a lazy functional language based on strictification and some experience in using it. A number of problems with the current implementation of the debugger (e.g. too large trace size and too many questions asked) are also discussed and some techniques for overcoming these problems, at least partially, are suggested. The key techniques are immediate strictification and piecemeal tracing .

1 January 2001 in Journal of Functional Programming
Verified
Journal Article
Closed access
PDF file
HNHenrik Nilsson
Henrik Nilsson
This article describes the implementation of a debugger for lazy functional languages like Haskell. The key idea is to construct a declarative trace which hides the operational details of lazy evaluation. However, to avoid excessive memory consumption, the trace is constructed one piece at a time, as needed during a debugging session, by automatic re-execution of the program being debugged. The article gives a fairly detailed account of both the underlying ideas and of our implementation, and also presents performance figures which demonstrate the feasibility of the approach.