[Haskell] Last call for papers: RULE-BASED PROGRAMMING 2006
RULE'06, 7th International Workshop on Rule-Based Programming, 11th August, 2006, Seattle, USA, A Satellite Event of RTA http://www.dcs.kcl.ac.uk/events/RULE06/ IMPORTANT DATES - 14th May, 2006 Deadline for electronic submission of papers - 15th June, 2006 Notification of acceptance of papers - 30th June, 2006 Deadline for final versions of accepted papers - 11th August, 2006 Workshop INVITED SPEAKERS Joint RULE and WRS keynote speakers: - Dick Kieburtz, OHSU/OGI School of Science & Engineering - Claude Kirchner, INRIA and LORIA RULE-BASED PROGRAMMING The rule-based programming paradigm is characterized by the repeated, localized transformation of a data object such as a term, graph, proof, constraint store, etc. The transformations are described by rules which separate the description of the object to be replaced (the pattern) from the calculation of the replacement. Optionally, rules can have further conditions that restrict their applicability. The transformations are controlled by explicit or implicit strategies. The basic concepts of rule-based programming appear throughout computer science, from theoretical foundations to practical implementations. Term rewriting is used in semantics in order to describe the meaning of programming languages, as well as in the implementation of program transformation systems. Rules are used implicitly or explicitly to perform computations, e.g., in Mathematica, OBJ, ELAN, Maude or to perform deductions, e.g., by using inference rules to describe or implement a logic, theorem prover or constraint solver. Mail clients and mail servers use complex rules to help users organising their email and sorting out spam. Language implementations use bottom-up rewrite systems for code generation (as in the BURG family of tools.) Constraint-handling rules (CHRs) are used to specify and implement constraint-based algorithms and applications. Rule-based programming idioms also give rise to multi-paradigm languages like Claire. TOPICS We solicit original papers on all topics of rule-based programming, including: - Languages for rule-based programming * Expressivity, Idioms, Design patterns * Semantics, Type systems * Implementation techniques * System descriptions - Other foundations * Complexity results * Advances on rewriting logic * Advances on rewriting calculus * Static analyses of rule-based programs * Transformation of rule-based programs - Applications of rule-based programming, e.g.: * Program transformation * Software analysis and generation * System Control * Work-flow control * Knowledge engineering - Combination with other paradigms * Functional programming * Logic programming * OO programming * Language extensions * Language embeddings - System descriptions SUBMISSIONS Papers (of at most 15 pages) should be submitted electronically via the web-based submission site. http://www.easychair.org/RULE2006/ Any problems with the submission procedure should be reported to one of the PC chairs: Maribel Fernandez ([EMAIL PROTECTED]), Ralf Lämmel ([EMAIL PROTECTED]) PROCEEDINGS Accepted papers will be published in the preliminary proceedings volume, which will be available during the workshop. The final proceedings will be published in Electronic Notes in Theoretical Computer Science (ENTCS), Elsevier. PROGRAMME COMMITTEE - Mark van den Brand (TU Eindhoven, Netherlands) - Horatiu Cirstea (LORIA, France) - Pierre Deransart (INRIA Rocquencourt, France) - Michael L. Collard (Kent State University, USA) - Martin Erwig (Oregon State University, USA) - Francois Fages (INRIA Rocquencourt, France) - Maribel Fernandez (Co-Chair, King's College London, UK) - Jean-Pierre Jouannaud (LIX, Ecole Polytechnique, France) - Oleg Kiselyov (FNMOC, USA) - Ralf Lämmel (Co-Chair, Microsoft, USA) - Ugo Montanari (Universita di Pisa, Italy) - Pierre-Etienne Moreau (LORIA, France) - Tobias Nipkow (Technical University Munich, Germany) - Tom Schrijvers (K.U.Leuven, Belgium) - Martin Sulzmann (National University of Singapore, Singapore) - Victor Winter (University of Nebraska at Omaha, USA) ___ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
Re: [Haskell] Optimizing locking with MVars
On Tue, May 02, 2006 at 12:15:20PM +0400, Bulat Ziganshin wrote: > Second, i've developed my own simplified version of this procedure. > Here i should say that my library uses "MVar ()" field to hold lock > and separate immutable data field with actual data locked: > > data WithLocking h = WithLocking h !(MVar ()) This reminds me, I wonder if we should have an MVar varient that is _just_ for locking, it would have no separate take and put primitives, just a withLock, enforcing the restriction that the thread that took the lock is the same one that will return it. this would allow standard priority inversion reduction techniques to be used and could signifigantly mitigate the problem of accidentally performing a long pure evaluation while holding a lock. when another thread comes along that needs a lock, it will give its CPU time to the thread holding it so it can finish up its long computation. with MVars, you never know whether an MVar is being used for simple locking or as an inter-thread communication mechanism. John -- John Meacham - ⑆repetae.net⑆john⑈ ___ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
[Haskell] (GHC) Boot files and instance declarations
Hi all. A quick bootfiles question.
The GHC docs specify not to put instance decls in bootfiles. However,
what if i need to? For example, say I have a module A where I'm
importing a module B with the {-# SOURCE #-} pragma. Module A needs to
know that the types in module B are instances of some typeclasses
(instance declarations for which are given in module B). How would I
manage this?
Thanks in advance.
--
-David House, [EMAIL PROTECTED], http://xmouse.ithium.net
___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell
[Haskell] (2nd CFP) Workshop on Logic-based Methods in Programming Environments
[Apologies for multiple postings] --- WLPE' 06 - 2nd CALL FOR PAPERS Workshop on Logic-based Methods in Programming Environments (satellite workshop of ICLP’06) August 16, 2006 Seattle (Washington), USA http://lml.ls.fi.upm.es/~susana/Conferences/WLPE06/ --- Aim and Scope - The 16th Workshop on Logic-based methods in Programming Environments will take place in Seattle (Washington), USA, as a satellite workshop of ICLP'06, the 22th International Conference on Logic Programming. This workshop will continue the series of successful international workshops on logic programming environments held in Ohio, USA (1989), Eilat, Israel (1990), Paris, France (1991), Washington, USA (1992), Vancouver, Canada (1993), Santa Margherita Ligure, Italy (1994), Portland, USA (1995), Leuven, Belgium and Port Jefferson, USA (1997), Las Cruces, USA (1999), Paphos, Cyprus (2001), Copenhagen, Denmark (2002), Mumbai, India (2003), Saint Malo, France (2004) and Sitges, Spain (2005). The workshop aims at providing an informal meeting for the researchers working on logic-based tools for development and analysis of programs. This year we want to emphasize two aspects: on one hand we want to discuss the presentation, pragmatics and experiences of such tools; on the other one, we want to shift the traditional focus on environment tools for logic programming to logic-based environmental tools for programming in general. Specific topic areas relevant to the workshop include, but are not limited to: * tools for debugging and testing * tools for static and dynamic analysis * systems for program verification and validation * code generation from specifications * termination and non-termination analyzers * reasoners on occurs-check freeness and determinacy * profilers and performance analyzers * systems for types and modes analyzes * module systems * optimization tools. In addition to papers describing more conceptual work on environmental tools, we solicit papers describing the implementation of and experimentation with such tools. Submission guidelines - Length of papers can range from 2 to 17 pages, preferably in LNCS format. Authors are requested to submit their paper using the submission webpage at http://vampire.cs.man.ac.uk/WLPE-06/ Alternatively, authors can send a copy of their paper (in pdf or ps format) to the workshop coordinator ([EMAIL PROTECTED]). An informal proceedings will be published as a technical report of the University of Namur and distributed at the workshop. After the workshop, the proceedings will be publicly available on-line in the Computing Research Repository (CoRR). Important dates --- Submission: May 15, 2006 Notification: June 15, 2006 Camera-ready: July 10, 2006 Workshop: August 16, 2006 Workshop organizers --- Susana Muñoz-Hernández (Universidad Politécnica de Madrid, Spain) Wim Vanhoof (coordinator) (Univeristy of Namur, Belgium) Program Committee - María Alpuente (Universidad Politécnica de Valencia, Spain) Mireille Ducassé(INSA/IRISA, Rennes, France) John Gallager (Roskilde University, Denmark) María García de la Banda(Monash University, Australia) José Manuel Gómez-Pérez (ISOCO Madrid, Spain) Gopal Gupta (University of Texas at Dallas, U.S.A) Moreno Falaschi (Università di Udine, Italy) Pat Hill(University of Leeds, U.K.) Michael Leuschel(Heinrich-Heine-Universitat Düsseldorf, Germany) Fred Mesnard(Université de La Réunion, France) Susana Muñoz-Hernández (Universidad Politécnica de Madrid, Spain) Kostis Sagonas (Uppsala University, Sweden) Alexander Serebrenik(Technische Universiteit Eindhoven, The Netherlands) Zoltan Somogyi (University of Melbourne, Australia) Wim Vanhoof (University of Namur, Belgium) ___ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
[Haskell] GPCE 2006 Deadline Extension
Apologies for repeated posts. The GPCE 2006 deadline for technical paper submission has been extended to May 14. GPCE provides a venue for researchers and practitioners interested in foundational techniques for enhancing the productivity, quality and time-to-marked in software development that stems from deploying standard componentry and automating program generation. In addition to exploring cutting-edge techniques for developing generative component-based software, our goal is to foster further cross- fertilization between software engineering research community and the programming languages community. Changes: - There will be no pre-submission - Submission deadline: May 14, 2006, 23:59 Apia time (previously May 5) - Notification: June 28, 2005 For more information, check: http://www.program-transformation.org/GPCE06/ ___ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
[Haskell] Call for papers: FM-Ed'06 - Formal Methods in the Teaching Lab
Call for Papers -- Submission deadline: June 9, 2006 FORMAL METHODS IN THE TEACHING LAB Examples, Cases, Assignments and Projects Enhancing Formal Methods Education http://www.di.uminho.pt/FME-SoE/FMEd06/ A Workshop at the Formal Methods 2006 Symposium Workshop: Saturday, August 26, 2006 Symposium: August 21 - 27, 2006 McMaster University, Hamilton, Ontario, Canada I. ORGANIZATION This workshop is organized by the Formal Methods Europe Subgroup on Education. Dines Bjørner (JAIST, Japan) Eerke Boiten (University of Kent, UK) Raymond Boute (Universiteit Gent, Belgium) Andrew Butterfield (Trinity College, Dublin) John Fitzgerald (University of Newcastle upon Tyne, UK) Randolph Johnson Steve King (University of York, UK) Peter Lucas Michael Mac an Airchinnigh (Trinity College, Dublin) Dino Mandrioli (Politecnico di Milano, Italy) Andrew Martin (Oxford University, UK) José Oliveira (Universidade do Minho, Portugal) -- Convenor Kees Pronk (Technische Universiteit Delft, NL) Simão Melo de Sousa (Universidade da Beira Interior, Portugal) Wolfgang Reisig (Humboldt-Universität zu Berlin, Germany) Workshop Co-Chairs Raymond Boute Formal Methods Group, Department of Information Technology (INTEC), Ghent University, Ghent (Belgium) E-mail: [EMAIL PROTECTED] José Oliveira Departamento de Informatica Universidade do Minho, Braga, Portugal E-mail: [EMAIL PROTECTED] II. CONCEPT OF THE WORKSHOP Motivation Quoting Dines Dines Bjørner: "Formal Methods Education is currently facing a `trichotomy': - On the one hand, industries dealing with the design of complex and critical systems have an increasing need for methods that provide a certain degree of confidence in the result, and are often looking for external assistance in the area of formal methods from consulting companies and academia. - On the other hand, a growing number of university staff enjoys the intellectual challenge of research in this area and teaching formal techniques to students. - On the "third hand", an increasing number of students de-select formal methods in the curriculum, due to various causes and trends." One cause of the problem is a general mathphobic trend in society and education. Another cause is that, intellectually, Information Technology is the victim of its own success. Indeed, the rapid growth creates so many design and implementation tasks that can be done and, more importantly, are being done with negligible educational or scientific background that it is difficult to argue convincingly in favor of formal methods on the basis of immediate everyday necessities. Critical systems, of course, are a notable exception. These trends are so pervasive that the small minority of FM educators has little hope to curb them in the near future. More effective in the long term is instilling a higher degree of professionalism in the next generation. This requires in particular a directed, positive action towards motivating students. Theme This workshop solicits short papers, presentations, demonstrations and evaluations describing sharp classroom or lab experiments which have proved particularly beneficial to the students' understanding and motivation for formal methods. The emphasis is not on (new) theories or methods but on specific illustrations and exercises that can be used by colleagues in their own courses, perhaps applying their own formalisms. The main goals are: - to share knowledge and experience on the practicalities of teaching and learning formal methods; - to build a collection of interesting cases, examples, assignments and projects that FM teachers can use in educational activities. Format The workshop will be a forum-like event, with short presentations, demos and informal discussion slots. After the workshop, if the evaluation committee decides that there is a sufficient number of high-quality submissions, an agreement will be sought with Springer Lecture Notes in Computer Science about publishing a special volume, and authors will be invited to submit their contribution for refereeing. III. SUBMISSIONS Call for Contributions This workshop solicits papers, presentations, demonstrations and evaluations describing such material in detail and how it has been beneficial to the students' understanding and motivation. The emphasis should not be primarily on new theories or methods but on specific illustrations and exercises that can be used by colleag
[Haskell] Optimizing locking with MVars
Hello haskell,
Main reason of slowness of existing Handle-based I/O in GHC is locking
around each operation. it is especially bad for simple char-at-a-time
I/O where 99% of time spent on locking and unlocking.
To be exact, on my CPU, hPutChar for 100mb file requires 150 seconds,
while hGetChar for the same file is "only" 100 seconds long. it seems
that former use 3 locking operations and later 2 ones, because my own
vGetChar/vPutChar implementations both requires 52 seconds, of those
only about one second is real work and rest is just `withMVar`
expenses.
Until now, i thought that this 0.5 ms (about 1000 primitive CPU
operations) on each withMVar is pure time required to perform
takeMVar+putMVar operations. But yesterday i investigated this problem
deeper and results was amazing!
First, i just made local copy of `withMVar` and added INLINE to it:
import Control.Exception as Exception
{-# INLINE inlinedWithMVar #-}
inlinedWithMVar :: MVar a -> (a -> IO b) -> IO b
inlinedWithMVar m io =
block $ do
a <- takeMVar m
b <- Exception.catch (unblock (io a))
(\e -> do putMVar m a; throw e)
putMVar m a
return b
Second, i've developed my own simplified version of this procedure.
Here i should say that my library uses "MVar ()" field to hold lock
and separate immutable data field with actual data locked:
data WithLocking h = WithLocking h !(MVar ())
This allowed me to omit block/unblock operation and develop the
following faster analog of withMVar:
lock (WithLocking h mvar) action = do
Exception.catch (do takeMVar mvar
result <- action h
putMVar mvar ()
return res
)
(\e -> do tryPutMVar mvar (); throw e)
And as third variant i tried exception-unsafe variant of `withMVar`:
unsafeWithMVar :: MVar a -> (a -> IO b) -> IO b
unsafeWithMVar m io = do
a <- takeMVar m
b <- io a
putMVar m a
return b
And now are results:
withMVar52 seconds
inlinedWithMVar 38 seconds
lock20 seconds
unsafeWithMVar 10 seconds
So,
1) `withMVar` can be made significantly faster just by attaching
INLINE pragma to it. until GHC includes this patch, you can just make
local copy of this procedure (it's implementation is
compiler-independent) and use INLINE pragma for this local copy
2) if MVar is used only to protect some immutable data from
simultaneous access, it's use can be made significantly faster by
using above-mentioned WithLocking type constructor together with
'lock' function. I hope that this mechanism will go into future
Haskell implementations and in particular it will be used in my own
Streams library and in new DiffArray implementation (that is a part
of ArrayRef library)
3) For simple programs that don't catch exceptions anyway, this
excessive protection is just meaningless. they can use
'unsafeWithMVar' to work as fast as possible. i mean in particular
shootout-like benchmarks. it is also possible to develop fast & safe
routines by using explicit unlocking (with 'tryPutMVar') in
higher-level exception handlers
and a more general conclusion. this case is a good demonstration of
significant performance loss due to using of higher-order functions. i
think that more aggressive inlining of high-order and polymorphic
functions should significantly speed up GHC-compiled programs.
--
Best regards,
Bulat mailto:[EMAIL PROTECTED]
___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell
