- Haskell - Haskell.org

modern language design, stone age tools
by Fergus Henderson 23 Jun '04

23 Jun '04

\begin{gripe} Seeing as Haskell is apparently such a popular language these days, I don't suppose a working debugger would be too much to ask for, would it? Or even just a decent call stack trace when a program terminates with an exception? In case you're wondering, yes I have already tried using Hat and Buddha. But I'm trying to debug a real application, not a toy one, and neither Hat nor Buddha support enough of Haskell. Buddha doesn't even come close, as far as I can tell, and Hat lacks support for library modules such as Data.Word. I've also tried using ghc's profiling to get stack traces, but that doesn't work very well either. Firstly, the stack traces that you get only include function names, not line numbers. Secondly, the stack traces are often incomplete, for reasons that I don't fully understand. One likely cause is tail call optimization. (Is there any option to switch off tail call optimization? I didn't see any such option in the ghc man page.) Thirdly, profiling seems to be incompatible with the use of ghci; there doesn't seem to be any easy way to build a workspace so that you can get stack traces and use ghci in that workspace at the same time. And ghc is slow enough (even on a 3.2GHz Pentium 4) that recompiling the whole workspace is highly unpalettable. There's a hell of a lot of languages out there that _do_ support decent stack traces when an exception is thrown. What's the point of using a high-level functional language if it means you're stuck with poor library support and/or stone-age tools? \end{gripe} -- Fergus J. Henderson | "I have always known that the pursuit Galois Connections, Inc. | of excellence is a lethal habit" Phone: +1 503 626 6616 | -- the last words of T. S. Garp.

5 5

Re: [Haskell] modern language design, stone age tools
by MR K P SCHUPKE 23 Jun '04

23 Jun '04

>Unless, of course, you have: >1) A large program operating on a large body of data that takes a long time to debugs logs go to a file, grep and awk let you quickly find things >3) A complex library written by someone else which contains a bug or makes before calling out print a funtion trace like: function "f" called from "reified location" with arguments ... returned "value" >4) this is what assert statements are for as in: assert (x>0) function-which-assumes x>0 For large project development - the development cycle should go along these lines... 1) functional specification 2) modularise 3) design interfaces for components 4) build testbench for components 5) code components... I have missed out the iterations for simplicity. Note the testbench should be built before the module - this includes analysis for linear regions and corner cases... The testbench will log each test along with the results. Testbenches should be provided with third party components - if they are not they should be built as part of the development process. I find if you do the above and put adequate debug logging in your code the need for a separate debugger is minimal... To get slightly more technical all the debugger does is run the code with full internal visibility (all states visible) - by adding debug statements you can increase visibility to the same level. logging all these debug outputs to a file gives you the same observability as single stepping, but it is much quicker to run the program at full speed and search the file. Prining out the full program state (or scoped variables) at any point is equivalent to a breakpoint. Consider this as a suggestion of how to cope without a debugger - until you find one you like... Keean.

1 0

RE: [Haskell] modern language design, stone age tools
by Simon Marlow 23 Jun '04

23 Jun '04

On 23 June 2004 09:27, Robert Ennals wrote: > I wrote such a debugger as part of my PhD work. It is called > "hsdebug" and you can read the Haskell Workshop paper on it here: > > http://www.cambridge.intel-research.net/~rennals/hw2003.pdf > > Unfortunately, HsDebug depends on Optimistic Evaluation, and it seems > unlikely that Optimistic Evaluation will appear in a release version > of GHC (too hard to maintain, and I've gone off to work for Intel > Research). > > HsDebug is a GDB-style debugger which takes advantage of the fact that > Optimistic Evaluation makes programs evaluate in a largely-strict > evaluation order. It also uses a trick called "transient tail frames" > to allow tail calls to be visible in stack traces. > > HsDebug can debug any GHC-compilable Haskell program, including GHC > itself. We would be delighted if someone would take Robert's hsdebug and port it to the non-speculative version of the compiler. In fact, this is one of the items on the GHC Task list: http://sourceforge.net/pm/task.php?func=detailtask&project_task_id=98684 &group_id=8032&group_project_id=31802 It would make a great student project, or a summer hack for someone with lots of spare time... Cheers, Simon

2 1

(no subject)
by Alfonso 22 Jun '04

22 Jun '04

Hello dear haskellers: My name is Alfonso Meléndez I work in Computer Science in a Colombian University. Right now, I am developing an application for discrete mathematics and I need to comunicate Java with Haskell, more precisely I use Java for the interface of the application and from here I need to call several Haskell Functions. In Haskell.org there are two libraries ( Java Bridge and JNI) that communicate Haskell with Java (but not viceversa). Is there and easy and direct way to do this job? Thank you!!! Alfonso Meléndez Dirección de Proyectos Facultad de Ingeniería de Sistemas Escuela Col de Ingeniería Tels: 676266,6763888, Ext: 224, 371 Cel: (315) 8938216 ##################################################################################### This e-mail message has been scanned for Viruses and Content and cleared by NetIQ MailMarshal #####################################################################################

1 0

State Transformers and Control.Monad.ST.Lazy
by Vivian McPhail 22 Jun '04

22 Jun '04

Hi, >From the very helpful posts of John Hughes and others concerning "Monadic Loops", I've been advised to re-implement my neural net simulator using lazy state threads to avoid crashes to which recursive (and tail-recursive) monads lead. I had been using monad transformers to lift IO operations: data NeuralNet = NN { ... } data NNO a = NNO (NeuralNet -> (a,NeuralNet)) data NNT m a = NNT (NeuralNet -> m (a,NeuralNet)) following the example of a state transformer in "Functional Programming with Overloading and Higher-Order Polymorphism". I am trying to reimplement with data ST s a from Control.Monad.ST.Lazy and "Lazy Functional State Threads" however there is something I think I do not understand, that is the "s" in the ST dataype. The compiler tells me it needs to be instantiated, but I am presuming that a type such as type NNST = ST NeuralNet a is useless because there is no way (from this module) to access that state using the "update" method of the MonadState class. 1. Am I correct in thinking that I need to use a monad transformer lifting from the ST monad to incorporate my NeuralNet datatype 2. Can I merely instantiate ST as ST () a? Thanks in advance. Vivian McPhail

2 1

Call for Participation: FMCO 2004
by M.M. Bonsangue 22 Jun '04

22 Jun '04

********************* CALL FOR PARTICIPATION ******************** Third International Symposium on Formal Methods for Components and Objects (FMCO 2004) The objective of this symposium is to bring together top researchers in the area of software engineering to discuss the state-of-the-art and future applications of formal methods in the development of large component-based and object-oriented software systems. DATES 2 - 5 November 2004 PLACE Lorentz Center, Leiden University, Leiden, The Netherlands URL http://fmco.liacs.nl/fmco04.html Early registration fee applies for registration before 20/09/2004 !!! Participation is limited to about 80 people, based on a first-in first-served policy. For more information about participation and registration see the FMCO site at http://fmco.liacs.nl/fmco04.html or consult either F.S. de Boer (frb(a)cwi.nl) or M.M. Bonsangue (marcello(a)liacs.nl) PRELIMINARY PROGRAM TUESDAY 2nd, November 2004 8:45 - 9:00 Welcome 9:00 - 10:00 Keynote: Robin Milner (Cambridge University, UK) 10:00 - 10:30 Break 10:30 - 11:15 Rocco de Nicola (University of Firenze, IT) 11:15 - 12:00 Eugenio Moggi (Genova University, IT) 12:00 - 13:30 Lunch break 13:30 - 14:30 Keynote: Kim Bruce (Williams College, USA) 14:30 - 15:00 Break 15:00 - 15:45 Julian Rathke (Sussex University, UK) 15:45 - 16:00 Break 16:00 - 16:45 Martin Steffen (Kiel University, DE) 16:45 - 17:30 Marcello Bonsangue (LIACS, NL) WEDNESDAY 3rd, November 2004 9:00 - 10:00 Keynote: Tom Henzinger (University of California, Berkeley, USA) 10:00 - 10:30 Break 10:30 - 11:15 Susanne Graf (Verimag, FR) 11:15 - 12:00 Wang Yi (Uppsala University, SE) 12:00 - 13:15 Lunch break 13:15 - 14:15 Keynote: Thomas Ball (Microsoft Research at Redmond, USA) 14:15 - 14:30 Break 14:30 - 15:15 Frits Vaandrager (Nijmegen University, NL) 15:15 - 16:00 Wolfgang Weck (Oberon Microsystems, CH) 17:00 - 19:15 Social Event 19:30 - Dinner THURSDAY 4th, November 2004 9:00 - 10:00 Keynote: Kim Larsen (Aalborg University, DK) 10:00 - 10:30 Break 10:30 - 11:15 Ed Brinksma (University of Twente, NL) 11:15 - 12:00 Andreas Podelski (Max Plank Inst. for Informatics, DE) 12:00 - 13:30 Lunch break 13:30 - 14:30 Keynote: Chris Hankin (Imperial College, UK) 14:30 - 15:00 Break 15:00 - 15:45 David Naumann (Stevens Institute of Technology, USA) 15:45 - 16:30 Tobias Nipkow (Munchen University, DE) 16:30 - 16:45 Break 16:45 - 17:30 Liu Zhiming (UNU-IIST, Macao) FRIDAY 5th, November 2004 9:00 - 10:00 Keynote: Samson Abramsky (Oxford University, UK) 10:00 - 10:30 Break 10:30 - 11:15 Luca de Alfaro (UC Santa Cruz, USA) 11:15 - 12:00 Luis Barbosa (Minho University, PT) 12:00 - 13:30 Lunch break 13:30 - 14:30 Keynote: Reinhard Wilhelm (Saarland University, DE) 14:30 - 15:00 Break 15:00 - 15:45 Olaf Owe (University of Oslo, NO) 15:45 - 16:30 Pierre Cointe (Ecole des Mines de Nantes, FR) ORGANIZING COMMITTEE F.S. de Boer (CWI and Utrecht University) M.M. Bonsangue (LIACS-Leiden University) S. Graf (Verimag) W.P. de Roever (CAU)

1 0

HsDNS -- asynchronous DNS resolver
by Peter Simons 22 Jun '04

22 Jun '04

On top of the GNU adns library, I have implemented a pretty simple-to-use DNS resolver, which hides the concurrency from the user through the use of MVars. I thought, maybe someone found this useful. You can get the source code at: http://cryp.to/hsdns/ Peter

2 4

Garbage Collection & Memory Management Summer School
by Richard Jones 22 Jun '04

22 Jun '04

Please excuse this spam-style mailing. I've also attached a poster in the hope that you might it useful. Richard Jones Garbage Collection & Memory Management Summer School 20-21 July 2004, Canterbury, UK The performance of today's memory-hungry applications depends on efficient dynamic memory management, whether managed explicitly through new/delete or automatically by a garbage collector. With the increasing use of managed code, whether Java Virtual Machines or Microsoft's Common Language Runtime, the economic importance of automatic memory management has never been greater. The Summer Schoool provides participants with an opportunity to hear leading practitioners from both industry and universities. The school is directed at postgraduate research students, academics who wish to get involved in this field and industrial researchers and developers who want to apply state of the art memory management techniques to real problems. The presenters include David Bacon (IBM TJ Watson Research Center), Emery Berger (U. Massachusetts), Hans Boehm (HP), Dave Detlefs (Sun Microsystems), Rick Hudson (Intel), Richard Jones (U. Kent, Canterbury), Eliot Moss (U. Massachusetts), Ryan Sciampacone (IBM Ottawa). The registration fee for the 2 day Summer School is 130 GBP (free of VAT) and includes all workshop materials, lunches and refreshments, and the Summer School Dinner on 20th July. Bed and breakfast accommodation is also available in en-suite accommodation on campus at a rate of 30 GBP per night. For more details, see http://www.mm-net.org.uk/school/ or mail school(a)mm-net.org.uk The Summer School is organised by the UK Memory Management Network (http://www.mm-net.org.uk) We are grrateful for the kind support of the Engineering and Physical Sciences Research Council (http://www.epsrc.ac.uk)

1 0

final cfp: soft2004
by Stefano Bistarelli 21 Jun '04

21 Jun '04

============================================================================ ======= 6th International Workshop on Soft Constraints and Preferences September 27th, 2004 Toronto, Canada Held in conjunction with 10th International Conference on Principles and Practice of Constraint Programming, CP2004 http://www.sci.unich.it/~bista/organizing/soft-2004/ ============================================================================ ======== Call for Paper ============================================================================ ======== Preferences are ubiquitous in real life: most problems are over-constrained and would not be solvable if we insist that all their requirements are strictly met. Moreover, many problems are more naturally described via preference rather than hard statements. Soft constraints are the way the constraint community has extended his classical framework to deal with the conceept of preferences. However, other frameworks for expressing preferences have been proposed in the last few years in AI or related disciplines, with different features and leading to different results. For example, both qualitative and quantitative preference frameworks are being studied and used to model and solve real-life probleems. This workshop would like to bring together researchers interested in all aspects of preferences and soft constraints, such as: - theoretical frameworks - problem modeling - solving algorithms - languages - preference aggregation - preference elicitation - multi-objective or qualitative optimization - combining/integrating different frameworks and algorithms - comparative studies - real-life applications Submissions This workshop is intended to build on the experience and success of the workshops on soft constraints that have been held at CP99, CP2000, CP2001, CP2002 and CP2003, and on the AAAI 2002 workshop on preferences in AI and CP. Its aim is to provide a forum where researchers currently working in the area of preferences or soft constraints can discuss their most recent ideas and developments and think together about the most promising new directions. Therefore we encourage the presentation of work in progress or on specialized aspects of soft constraints. Papers that bridge the gap between theory and practice are especially welcome. Prospective attendees can submit a paper, which can be up to 15 pages in length. We encourage authors to submit papers electronically in postscript or pdf format. Papers should be formatted using the Lecture Notes in Computer Science (LNCS) style. Please send your submissions by email to stefano.bistarelli(a)iit.cnr.it using the subject line Soft-2004 Workshop Submission. Although no agreement is yet in place, we will consider the publication of a selection of papers presented at this workshop in a special issue of a journal or in a volume of a serie. Important Dates The proposed schedule of important dates for the workshop is as follows: Paper Submission deadline June 26th Notification of acceptance July 24th Camera-ready version deadline August 14th Workshop Date September 27th Workshop Organizers: Stefano Bistarelli (Primary Contact) Dipartimento di Scienze Università degli studi "G. D'Annunzio" di Chieti-Pescara, Italy Email: bista(a)sci.unich.it Web: http://www.sci.unich.it/~bista/ and Istituto di Informatica e Telematica C.N.R. Pisa, Italy Email: stefano.bistarelli(a)iit.cnr.it and Francesca Rossi Dipartimento di Matematica Pura ed Applicata Universita' degli Studi di Padova, Italy Email: frossi(a)math.unipd.it Web: http://www.math.unipd.it/~frossi/ Program Committee: Stefano Bistarelli (University of Pescara, Italy --- C.N.R., Pisa, Italy) Simon De Givry (Institut National de La Recherche Agronomique, Castanet Tolosan Cedex, France) Boi Faltings (EPFL, Switzerland) Carmen Gervet (IC-Parc, Imperial College, UK) Ulrich Junker (ILOG, France) Javier Larrosa (Universitat Politècnica de Catalunya, UPC, Barcelona, Spain) Jimmy H. M. Lee (The Chinese University of Hong Kong, Hong Kong) Pedro Meseguer (IIIA-CSIC, Bellaterra, Spain) Barry O'Sullivan (University College Cork, Ireland) Francesca Rossi (University of Padova, Italy) Thomas Schiex (Institut National de La Recherche Agronomique, Castanet Tolosan Cedex, France) Toby Walsh (Cork Constraints Computation Centre, Ireland)

1 0

ANNOUNCE: Chasing Bottoms
by Nils Anders Danielsson 18 Jun '04

18 Jun '04

Excerpt from the documentation at http://www.cs.chalmers.se/~nad/software/ChasingBottoms/docs/: Chasing Bottoms =============== Do you ever feel the need to test code involving bottoms (e.g. calls to the error function), or code involving infinite values? Then this library could be useful for you. It is usually easy to get a grip on bottoms by showing a value and waiting to see how much gets printed before the first exception is encountered. However, that quickly gets tiresome and is hard to automate using e.g. QuickCheck (http://www.cs.chalmers.se/~rjmh/QuickCheck/) With this library you can do the tests as simply as the following examples show. Testing explicitly for bottoms: > isBottom (head []) True > isBottom bottom True > isBottom (\_ -> bottom) False > isBottom (bottom, bottom) False Comparing finite, partial values: > ((bottom, 3) :: (Bool, Int)) ==! (bottom, 2+5-4) True > ((bottom, bottom) :: (Bool, Int)) <! (bottom, 8) True Showing partial and infinite values (\/! is join and /\! is meet): > approxShow 4 $ (True, bottom) \/! (bottom, b) "Just (True, b)" > approxShow 4 $ (True, bottom) /\! (bottom, b) "(_|_, _|_)" > approxShow 4 $ ([1..] :: [Int]) "[1, 2, 3, _" > approxShow 4 $ (cycle [bottom] :: [Bool]) "[_|_, _|_, _|_, _" Approximately comparing infinite, partial values: > approx 100 [2,4..] ==! approx 100 (filter even [1..] :: [Int]) True > approx 100 [2,4..] /=! approx 100 (filter even [bottom..] :: [Int]) True The code above relies on the fact that bottom, just as error "...", undefined and pattern match failures, yield exceptions. Sometimes we are dealing with properly non-terminating computations, such as the following example, and then it can be nice to be able to apply a timeout. > let primes = unfoldr (\(x:xs) -> Just (x, filter ((/= 0) . (`mod` x)) xs)) [2..] > timeOutMicro 100 (print $ filter ((== 1) . (`mod` 32)) primes) >>= print [97,193,257Nothing > timeOutMicro 100 (print $ take 5 $ filter ((== 1) . (`mod` 32)) primes) >>= print [97,193,257,353Nothing > timeOutMicro 100 (print $ take 5 $ filter ((== 1) . (`mod` 32)) primes) >>= print [97,193,257,353,449] Just () All the type annotations above are required. For the underlying theory and a larger example involving use of QuickCheck, see the article "Chasing Bottoms, A Case Study in Program Verification in the Presence of Partial and Infinite Values" (http://www.cs.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html) Source code: http://www.cs.chalmers.se/~nad/software/ChasingBottoms/chasing-bottoms.tar.…. /NAD

1 0