- Haskell - Haskell.org

IFM2007 Final call for contributions
by Jeremy.Gibbons＠comlab.ox.ac.uk 24 Jan '07

24 Jan '07

---------------------------------------------------------------------- IFM 2007 Sixth International Conference on Integrated Formal Methods 2nd - 6th July 2007, Oxford, UK http://www.ifm2007.org Final Call for Contributions Contributions to the technical programme of IFM 2007, including papers for the special session on Unifying Theories of Programming, and proposals for workshops and tutorials, are invited. The deadline for submission has been extended to 5th February 2007. See the calls at http://www.ifm2007.org Papers should not exceed 20 pages in length, and should be prepared in accordance with the publisher's guidelines; style files and templates are available at http://www.ifm2007.org/LNCS.html Both .doc and .pdf formats are acceptable. Electronic submission is possible via the conference website. Authors will be notified on or before March 15th. ----------------------------------------------------------------------

1 0

O'Haskell -> Tk
by Peter Padawitz 23 Jan '07

23 Jan '07

Does anybody know O'Haskell or Timber and its interface Tk.hs to Tcl/Tk (see here <http://fldit-www.cs.uni-dortmund.de/%7Epeter/tk.html>)? I have the following problem: Tk.hs <http://fldit-www.cs.uni-dortmund.de/%7Epeter/Tk.hs> contains a record (structure) /Canvas/ with selectors line :: [(Int,Int)] -> [LineOpt] -> Request Line polygon :: [(Int,Int)] -> [PolygonOpt] -> Request Polygon that are compiled into synonymous Tk widgets for lines and polygons, respectively. Unfortunately, Tk.hs crashes if the point list parameter of line or polygon contains more than 100 points. Why??? Of course, one may split a point list into smaller ones that are compiled correctly. But this may not produce the same picture, for instance, if the entire list represents a polygon to be filled or a line to be smoothened. Peter

1 0

ANN: polyparse-1.00
by Malcolm Wallace 23 Jan '07

23 Jan '07

polyparse-1.00 -------------- Announcing: http://www.cs.york.ac.uk/fp/polyparse PolyParse is a collection of parser combinator libraries in Haskell. They were all previously distributed as part of HaXml, but are now split out to make them more widely available. You are likely to use only one of the included modules at any one time - they are generally alternatives to each other, as well as an alternative to other widely-used parser libraries available elsewhere. * Text.Parse. The Text.Read class from Haskell'98 is widely recognised to have many problems. It is inefficient. If a read fails, there is no indication of why. Worst of all, a read failure crashes your whole program! Text.Parse is a proposed replacement for the Read class. It defines a new class, Parse, with methods that return an explicit notification of errors, through the Either type. It also defines a number of useful helper functions to enable the construction of parsers for textual representations of Haskell data structures, e.g. named fields. Unsurprisingly, Text.Parse is really just a specialisation of the Poly combinators for String input, and the entire Poly API is also re-exported. The DrIFT tool can derive instances of the Parse class for you automatically. (Use the syntax {-! derive : Parse !-}) * Text.ParserCombinators.HuttonMeijer. The most venerable of all monadic parser combinator libraries, this version dates from 1996. Originally distributed with Gofer, then Hugs, as ParseLib. It uses the idea of "failure as a list of successes" to give multiple possible parses through backtracking. (But in practice, almost nobody wants any parse except the first complete one.) * Text.ParserCombinators.HuttonMeijerWallace. The Hutton/Meijer combinators, extended to take an arbitrary token type as input (not just characters), plus a running state (e.g. to collect a symbol table, or macros), plus some facilities for simple error-reporting. * Text.ParserCombinators.Poly. The name Poly comes from the arbitrary token type. Thus, you can write your own lexer if you wish, rather than needing to encode lexical analysis within the parser itself. This is a fresh set of combinators, improving on the HuttonMeijer variety by keeping only a single success, not a list of them. This is more space-efficient, whilst still permitting backtracking. Error-handling is also much improved: there are essentially two kinds of failure, soft and hard. Soft failure just means that the current parse did not work out, but another parse might be OK. Hard failure means that no parse will succeed, because we have already passed a point of commitment. Thus you can give far more accurate error messages to the user, including multi-layered locations. * Text.ParserCombinators.PolyState is just like Poly, except it adds an arbitrary running state parameter. * Text.ParserCombinators.PolyLazy is just like Poly, except it does not return explicit failures. Instead, an exception is raised. Thus, it can return a partial parse result, before a full parse is complete. The word partial indicates that, having committed to return some outer data constructor, we might later discover some parse error further inside, so the value will be partial, as in incomplete: containing bottom. However, if you are confident that the input is error-free, then you will gain hugely in space-efficiency - essentially you can stream-process your parsed data-structure within very small constant space. This is especially useful for large structures like e.g. XML trees. * Text.ParserCombinators.PolyStateLazy combines PolyState and PolyLazy. All the Poly* variations share the same basic API, so it is easy to switch from one set to another, when you discover you need an extra facility, just by changing a single import. Regards, Malcolm

1 0

Re: Even higher-order abstract syntax: typeclasses vs GADT
by oleg＠pobox.com 23 Jan '07

23 Jan '07

Benjamin Franksen wrote: > I would be interested whether you can not only /check/ well-typedness, > but also /establish/ it, i.e. is it possible to have the input to the > type-checker be an /untyped/ representation (such as obtained by > parsing a program in text form) and the output be a typed one (or else > a type error)? The original problem was to embed a domain-specific term language in Haskell and get the Haskell typechecker to flag meaningless terms when compiling code files. You, as I understand it, would like to do the same for terms read, at run-time, from files or received from (remote) sources. Right? Well, it seems that's where staging/TH can be useful. Rather then writing badfoo = Fix id in the source code, we can write badfoo = $(read_the_Foo_term "from-file") The typechecking will be performed by TH. It seems we have discussed that before: http://www.haskell.org/pipermail/haskell-cafe/2006-November/019193.html That article contains the complete working example. I think Alice developers can say quite a bit about this problem of type-safe pickling and especially unpickling. Perhaps we should move to Cafe?

1 0

Even higher-order abstract syntax: typeclasses vs GADT
by oleg＠pobox.com 22 Jan '07

22 Jan '07

We show the typeclass implementation of the example used to make the case for GADTs. We demonstrate the higher-order abstract-syntax-based embedding of a language in Haskell and implement static and dynamic semantics of the language. The interpreter of the language is tagless and statically assured: Only well-typed terms may be evaluated, and the evaluation of those does not get stuck. We use no tags and *no* run-time pattern-matching, therefore, the `eval' function has no possibility of raising a run-time error. Our language is _non_-strongly normalizing and non-structurally inductive due to the presence of Fix; yet the typechecking is decidable and our typeclass programs always terminate. The running example has been used as an argument for generalized recursive data types (one of the variants of GADTs). This message is meant to clarify the expressiveness of GADTs with respect to typeclasses. Our implementation is also aimed at the sometimes exuberant enthusiasm for GADTs. In positive contribution, we demonstrate the _automatic_ promotion of a value-level higher-order abstract syntax (HOAS) term to the type-level. The small-lambda HOAS becomes the big-Lambda HOAS and can be operated by the typechecker. We demonstrate the typechecking of our term language by abstract interpretation. The latter is performed by the Haskell typechecker itself, following straightforward declarative rules expressed via instance declarations. The code works in GHC and Hugs. This message has been inspired by the paper `Guarded recursive datatype constructors' by Hongwei Xi, Chiyan Chen and Gang Chen (POPL2003) to be called `the GRDT paper' below. The particular inspiration comes from a comment by Meng Wang on Haskell-Cafe (Jan 13, 2007). GADTs are often motivated by a tagless interpreter. When we embed a language in Haskell, the corresponding data types may admit meaningless terms like an application of a number to a pair. If we get the Haskell typechecker to reject such terms, we gain the (static) type checking for our object language. Furthermore, the evaluator for the language no longer has to deal with ill-formed terms and report run-time `type' errors. There is no longer any need in `dynamic typing' and in maintaining and checking type tags. The paper `Wobbly types: type inference for generalised algebraic data types' by Peyton-Jones, Washburn, and Weirich used the embedding of a first-order language to motivate GADTs. That example is _trivially_ implemented in Haskell without GADTs, with simple typeclasses. http://pobox.com/~oleg/ftp/Haskell/GADT-interpreter.hs Far more interesting is the embedding of a higher-order language, described in the GRDT paper. The first challenge is representing higher-order syntax at the type level. More demanding is dealing with the fixpoint operator of the GRDT example. The HOAS fixpoint destroys the structural induction principle. If we fully expose the structure of our terms at the type level, how can we write divergent terms? Do we need (equi-)recursive types? Mainly, would the Haskell typechecker itself diverge when processing such terms? Who would have thought that divergent terms can be so interesting. The examples in the code include several terms whose run-time evaluation does diverge, yet the typechecking of those terms terminates. The termination of our typechecker is easy to see as each step eliminates one term constructor. The key to the terminating typechecking is abstract interpretation, which permits the introduction and the elimination of assumptions/hypothesis. The full code is available at http://pobox.com/~oleg/ftp/Haskell/GADT-HOAS.hs The syntax of our language is as follows. We took the first-order language described previously and added higher-order terms and the fixpoint. The resulting language is a little bit larger than that introduced in the GRDT paper. > newtype Lit a = Lit a -- aka, Lift in GRDT > newtype Inc a = Inc a > newtype IsZ a = IsZ a > newtype If a b c = If (a,b,c) > newtype Fst a = Fst a > newtype Snd a = Snd a > newtype Pair a b = Pair (a,b) > > newtype Lam f t = Lam f -- t is the type of the bound arg > newtype App a b = App (a,b) > newtype Fix f t = Fix f -- ditto > > newtype AbsValue t = AbsValue t The Lam and Fix terms with binders contain in their type the type of the bound variable. The GRDT paper imposes the same type annotation requirement. That type, however, can be inferred in many cases. The term `AbsValue' is used for typechecking of functions by abstract interpretation. Here is a sample higher-order term in our language, with latent non-termination > t5f = Lam $ \p -> If( IsZ p, (Pair (p,Inc p)), (Pair (p,Fix id)) ) The body of Lam is the ordinary Haskell function. We define the static semantics by > class Of a t | a -> t asserting that the term 'a' has the type 't'. The type-checking rules, defined by the instances of `Of' are straightforward: > instance Of (Lit t) t > instance Of a Int => Of (Inc a) Int More interesting is the typechecking of functions and fixpoints: the Hyp introduction and elimination rules. > instance (Apply f (AbsValue t1) y, Of y t2) => Of (Lam f t1) (t1->t2) > instance (Apply f (AbsValue t) y, Of y t) => Of (Fix f t) t > instance Of (AbsValue t) t -- Hyp elimination rule The Lam rules says that the function mapping the term `x' to the term 'y' has the type t1->t2, if the function maps the term AbsValue t1 to the term that has the type t2. In other words, if the body of the function has the type t2 _assuming_ the argument has the type t1. The AbsValue makes the typechecking of the HOAS Fix terminating. If we define > teval :: Of e t => e -> t -- static evaluator > teval = undefined -- all computation is static > et5f1 = teval $ t5f we can see the type inferred for t5f > *HOASL> :t et5f1 > et5f1 :: Int -> (Int, Int) We define the dynamic semantics as the big-step evaluator > class Eval a t | a->t where eval:: a -> t Most of the instances are straightforward: > instance Of (Lit a) a => Eval (Lit a) a where > eval (Lit i) = i > instance Eval t Int => Eval (Inc t) Int where > eval (Inc t) = eval t + 1 Again, more interesting is the evaluation of higher-order terms > instance (Eval a (t1->t2), Eval b t1) => Eval (App a b) t2 where > eval (App (a,b)) = (eval a) (eval b) > > instance (Apply f (Lit t1) b, Eval b t2) => Eval (Lam f t1) (t1->t2) where > eval (Lam f) = \x -> eval (apply f (Lit x)) > > instance (Apply f (Lit t) y, Eval y t) => Eval (Fix f t) t where > eval (Fix f) = fix (\x -> eval $ apply f (Lit x)) We can now evaluate the term and its applications > et5f1 = teval $ t5f > et5f2 = eval $ t5f > et5f3 = eval $ App (t5f, Lit (0::Int)) -- yields (0,1) > et5f4t= teval $ App (t5f, Lit (1::Int)) -- typechecking terminates > et5f4 = eval $ App (t5f, Lit (1::Int)) -- evaluation diverges! The full code contains a more meaningful example of using Fix, to add two numbers using recursion with accumulation. That example too is potentially diverging on some inputs.

4 4

WTO Principle
by Rishiyur Nikhil 22 Jan '07

22 Jan '07

Re. Haskell Digest, Vol 41, Issue 3, Quotes of the Week: > * Eric: The Haskell [code] contains no redundancy. In fact, in all > the [Haskell] code I've written, in both production and play, each > idea is expressed once and only once. It is the Zen ideal of > perfect code. And thats never happened to me before. You may also be interested in the following: "The real key to good programming is the Write Things Once or WTO principle: any violation of this principle means a replication that makes the program harder to understand and to maintain, and yields a potential source of bugs: modifying a copy without modifying the other ones." Gerard Berry, in The Esterel v5 Language Primer, June 5, 2000 Nikhil ---------------------------------------------------------------- Rishiyur S. Nikhil, Ph.D.,CTO Email: nikhil(a)bluespec.com Bluespec, Inc. http://www.bluespec.com 14 Spring St. Tel: +1.781.250.2203 Waltham, MA 02451, USA Cell: +1.617.359.0747

1 0

Midlands Graduate School 2007
by Graham Hutton 22 Jan '07

22 Jan '07

+--------------------------------------------------------------------+ *** REGISTRATION NOW OPEN *** Midlands Graduate School in the Foundations of Computing Science MGS 2007 16-20 April 2007 University of Nottingham, UK The Midlands Graduate School (MGS) in the Foundations of Computing Science was established in 1999, and organises an annual Spring School on the mathematical foundations of computing. It is primarily aimed at PhD students, but everyone is welcome to attend, including computer scientists, mathematicians, and participants from outside of the UK. PROGRAMME The programme will consist of ten short courses given over a period of five days. The speakers are as follows: Roy Crole Operational Semantics Neil Ghani Category Theory Paul Levy Typed Lambda Calculus Thorsten Altenkirch Dependently Typed Programming Roland Backhouse Algorithmic Problem Solving Martin Escardo Domain Theory and Denotational Semantics Achim Jung Stone Duality Henrik Nilsson Advanced Functional Programming Colin Stirling Concurrency Theory Steve Vickers Topology and Logic LOCATION The school will be held on the Jubilee Campus of the University of Nottingham, which has won many awards for its design and environmental features. Nottingham is centrally located in the UK, and is easily reachable by road, rail and air (Nottingham East Midlands Airport.) REGISTRATION The deadline for registration is 1 March 2007, and the registration fee is 350 UK pounds, including accommodation. We also hope to have a number of free places for UK-based PhD students. The number of places is limited, so early registration is advised. FURTHER DETAILS Google search - MGS 2007 Web page - http://www.cs.nott.ac.uk/~nhn/MGS2007/ +--------------------------------------------------------------------+ This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Hyperlinking source code formatter?
by Conal Elliott 20 Jan '07

20 Jan '07

I'd like to turn source code (mine and others') into a fully hyperlinked form, in which every name reference links to the name's definition. Syntax-coloring would be great also. I see Programmatica. Is it in use, supported, and reasonably easy to install and use? Are there other options? Thanks, - Conal

1 0

Final Call for Papers: TFP 2007, New York, USA
by TFP 2007 20 Jan '07

20 Jan '07

CALL FOR PAPERS Trends in Functional Programming 2007 New York, USA April 2-4, 2007 http://cs.shu.edu/tfp2007/ NEW: Abstract submission is now opened! Link: http://cs.shu.edu/tfp2007/submissions.html NEW: Invited Talk: John McCarthy, Standford University The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming languages, focusing on providing a broad view of current and future trends in Functional Programming. It aspires to be a lively environment for presenting the latest research results through acceptance by extended abstracts. A formal post-symposium refereeing process then selects the best articles presented at the symposium for publication in a high-profile volume. TFP 2007 is co-hosted by Seton Hall University and The City College of New York (CCNY) and will be held in New York, USA, April 2-4, 2007 at the CCNY campus. SCOPE OF THE SYMPOSIUM The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles leading-edge, previously unpublished research work Position Articles on what new trends should or should not be Project Articles descriptions of recently started new projects Evaluation Articles what lessons can be drawn from a finished project Overview Articles summarizing work with respect to a trendy subject Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Articles on the following subject areas are particularly welcomed: o Dependently Typed Functional Programming o Validation and Verification of Functional Programs o Debugging for Functional Languages o Functional Programming and Security o Functional Programming and Mobility o Functional Programming to Animate/Prototype/Implement Systems from Formal or Semi-Formal Specifications o Functional Languages for Telecommunications Applications o Functional Languages for Embedded Systems o Functional Programming Applied to Global Computing o Functional GRIDs o Functional Programming Ideas in Imperative or Object-Oriented Settings (and the converse) o Interoperability with Imperative Programming Languages o Novel Memory Management Techniques o Parallel/Concurrent Functional Languages o Program Transformation Techniques o Empirical Performance Studies o Abstract/Virtual Machines and Compilers for Functional Languages o New Implementation Strategies o any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2007 program chair, Marco T. Morazan, at tfp2007(a)shu.edu. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of articles for presentation at the symposium is based on the review of extended abstracts (6 to 10 pages in length) by the program committee. Accepted abstracts are to be completed to full papers before the symposium for publication in the draft proceedings and on-line. Further details can be found at the TFP 2007 website. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the draft symposium proceedings, we intend to continue the TFP tradition of publishing a high-quality subset of contributions in the Intellect series on Trends in Functional Programming. IMPORTANT DATES Abstract Submission: February 1, 2007 Notification of Acceptance: February 20, 2007 Registration Deadline: March 2, 2007 Camera Ready Full Paper Due: March 9, 2007 TFP Symposium: April 2-4, 2007 PROGRAMME COMMITTEE John Clements California Polytechnic State University, USA Marko van Eekelen Radboud Universiteit Nijmegen, The Netherlands Benjamin Goldberg New York University, USA Kevin Hammond University of St. Andrews, UK Patricia Johann Rutgers University, USA Hans-Wolfgang Loidl Ludwig-Maximilians Universität München, Germany Rita Loogen Philipps-Universität Marburg, Germany Greg Michaelson Heriot-Watt University, UK Marco T. Morazán (Chair) Seton Hall University, USA Henrik Nilsson University of Nottingham, UK Chris Okasaki United States Military Academy at West Point, USA Rex Page University of Oklahoma, USA Ricardo Pena Universidad Complutense de Madrid, Spain Benjamin C. Pierce University of Pennsylvania, USA John Reppy University of Chicago, USA Ulrik P. Schultz University of Southern Denmark, Denmark Clara Segura Universidad Complutense de Madrid, Spain Jocelyn Sérot Université Blaise Pascal, France Zhong Shao Yale University, USA Olin Shivers Georgia Institute of Technology, USA Phil Trinder Heriot-Watt University, UK David Walker Princeton University, USA ORGANIZATION Symposium Chair: Henrik Nilsson, University of Nottingham, UK Programme Chair: Marco T. Morazan, Seton Hall University, USA Treasurer: Greg Michaelson, Heriot-Watt University, UK Local Arrangements: Marco T. Morazan, Seton Hall University, USA ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

Final Call for Papers: TFP 2007, New York, USA
by TFP 2007 19 Jan '07

19 Jan '07

Dear Colleagues, The abstract submission deadline, February 1, is quickly approaching. We hope to see you at TFP 2007 in New York. NEW: Abstract submission is now open! Link: http://cs.shu.edu/tfp2007/submissions.html NEW: Invited Talk: John McCarthy, Standford University CALL FOR PAPERS Trends in Functional Programming 2007 New York, USA April 2-4, 2007 http://cs.shu.edu/tfp2007/ The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming languages, focusing on providing a broad view of current and future trends in Functional Programming. It aspires to be a lively environment for presenting the latest research results through acceptance by extended abstracts. A formal post-symposium refereeing process then selects the best articles presented at the symposium for publication in a high-profile volume. TFP 2007 is co-hosted by Seton Hall University and The City College of New York (CCNY) and will be held in New York, USA, April 2-4, 2007 at the CCNY campus. SCOPE OF THE SYMPOSIUM The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles leading-edge, previously unpublished research work Position Articles on what new trends should or should not be Project Articles descriptions of recently started new projects Evaluation Articles what lessons can be drawn from a finished project Overview Articles summarizing work with respect to a trendy subject Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Articles on the following subject areas are particularly welcomed: o Dependently Typed Functional Programming o Validation and Verification of Functional Programs o Debugging for Functional Languages o Functional Programming and Security o Functional Programming and Mobility o Functional Programming to Animate/Prototype/Implement Systems from Formal or Semi-Formal Specifications o Functional Languages for Telecommunications Applications o Functional Languages for Embedded Systems o Functional Programming Applied to Global Computing o Functional GRIDs o Functional Programming Ideas in Imperative or Object-Oriented Settings (and the converse) o Interoperability with Imperative Programming Languages o Novel Memory Management Techniques o Parallel/Concurrent Functional Languages o Program Transformation Techniques o Empirical Performance Studies o Abstract/Virtual Machines and Compilers for Functional Languages o New Implementation Strategies o any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2007 program chair, Marco T. Morazan, at tfp2007(a)shu.edu. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of articles for presentation at the symposium is based on the review of extended abstracts (6 to 10 pages in length) by the program committee. Accepted abstracts are to be completed to full papers before the symposium for publication in the draft proceedings and on-line. Further details can be found at the TFP 2007 website. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the draft symposium proceedings, we intend to continue the TFP tradition of publishing a high-quality subset of contributions in the Intellect series on Trends in Functional Programming. IMPORTANT DATES Abstract Submission: February 1, 2007 Notification of Acceptance: February 20, 2007 Registration Deadline: March 2, 2007 Camera Ready Full Paper Due: March 9, 2007 TFP Symposium: April 2-4, 2007 PROGRAMME COMMITTEE John Clements California Polytechnic State University, USA Marko van Eekelen Radboud Universiteit Nijmegen, The Netherlands Benjamin Goldberg New York University, USA Kevin Hammond University of St. Andrews, UK Patricia Johann Rutgers University, USA Hans-Wolfgang Loidl Ludwig-Maximilians Universität München, Germany Rita Loogen Philipps-Universität Marburg, Germany Greg Michaelson Heriot-Watt University, UK Marco T. Morazán (Chair) Seton Hall University, USA Henrik Nilsson University of Nottingham, UK Chris Okasaki United States Military Academy at West Point, USA Rex Page University of Oklahoma, USA Ricardo Pena Universidad Complutense de Madrid, Spain Benjamin C. Pierce University of Pennsylvania, USA John Reppy University of Chicago, USA Ulrik P. Schultz University of Southern Denmark, Denmark Clara Segura Universidad Complutense de Madrid, Spain Jocelyn Sérot Université Blaise Pascal, France Zhong Shao Yale University, USA Olin Shivers Georgia Institute of Technology, USA Phil Trinder Heriot-Watt University, UK David Walker Princeton University, USA ORGANIZATION Symposium Chair: Henrik Nilsson, University of Nottingham, UK Programme Chair: Marco T. Morazan, Seton Hall University, USA Treasurer: Greg Michaelson, Heriot-Watt University, UK Local Arrangements: Marco T. Morazan, Seton Hall University, USA ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0