[pypy-svn] r23397 - pypy/extradoc/sprintinfo/louvain-la-neuve-2006

nico at codespeak.net nico at codespeak.net
Thu Feb 16 12:36:55 CET 2006

Author: nico
Date: Thu Feb 16 12:36:53 2006
New Revision: 23397

info regarding the logic sprint in louvain-la-neuve

Added: pypy/extradoc/sprintinfo/louvain-la-neuve-2006/people.txt
--- (empty file)
+++ pypy/extradoc/sprintinfo/louvain-la-neuve-2006/people.txt	Thu Feb 16 12:36:53 2006
@@ -0,0 +1,51 @@
+People coming to the Louvain-la-Neuve Logic sprint 2006
+People who have a ``?`` in their arrive/depart or accomodation
+column are known to be coming but there are no details 
+available yet from them. 
+    Name              Arrive/Depart     Accomodation 
+Ludovic Aubry        ?              ?
+Aurélien Campéas     ?              ?          
+Nicolas Chauvat      ?              ?
+Adrien Di Mascio     ?              ?          
+Sylvain Thénault     ?              ?
+Anders Lehmann       ?              ?
+Samuele Pedroni      ?              ?
+Carl Friedrich Bolz  ?              ?
+People on the following list were present at previous sprints: 
+       Name          Arrive/Depart  Accomodation 
+Niklaus Haldimann    
+Brian Dorsey         
+Jan Balster          
+Wanja Saatkamp       
+Christian Tismer     
+Michael Hudson       
+Armin Rigo           
+Anders Chrigstroem   
+Beatrice Duering     
+Holger Krekel        
+Eric van Riet Paap   
+Gerald Klix          
+Stephan Diehl        
+Jacob Hallen         
+Holger Krekel        
+Richard Emslie       
+Andrew Thompson	     
+Laura Creighton      
+Lene Wagner          
+Johan Hahn           
+Amaury Forgeot d'Arc 
+Valentino Volonghi   
+Boris Feigin	     
+Bert Freudenberg     

Added: pypy/extradoc/sprintinfo/louvain-la-neuve-2006/pypy-oz-agenda.txt
--- (empty file)
+++ pypy/extradoc/sprintinfo/louvain-la-neuve-2006/pypy-oz-agenda.txt	Thu Feb 16 12:36:53 2006
@@ -0,0 +1,187 @@
+PyPy/Oz meeting Agenda
+ * sprint participants
+ * Peter Van Roy (UCL)  Oz author (one of).
+ * Grégoire Dooms (UCL) Oz contributor.
+ * Roel Wuyts (ULB)     PyPy reviewer.
+and maybe:
+ * Alastair Burt (DFKI)   PyPy coordinator.
+ * Raphael Collet (UCL)   Oz contributor.
+ * Kevin Glynn (UCL)      Oz contributor.
+ * Michael Leuschel (HHU) interest in Prolog+Python
+even better:
+ * others ?
+To be summarized.
+Excerpts from e-mails:
+ I can think of a few topics for discussion (non exhaustive):
+- your ongoing work on  implementing a constraint store in pypy
+- transparent distributed computing
+- garbage collection
+- constraint programming: constraint propagation, modeling, search and
+computation spaces.
+- logic variables and unification
+- lazy computations
+- dataflow concurrency (through logic variables or future/promise)
+I could give a presentation about Soul, or, more specifically, about
+the language integration of Soul.
+Soul is a Prolog implemented in Smalltalk that allows object-oriented
+(Smalltalk) code to be executed during logic reasoning. The key
+aspect of this symbiosis is what we call the up/down mechanism, which
+was previously used by other members of the lab where I did my Ph.D.
+(Programming Technology Lab, of the Vrije Universiteit Brussel) for
+the prototype-based language Agora (that featured symbiosys with C++,
+Java and Smalltalk). In the case of Soul, however, the symbiosis is
+between languages of different paradigms. The up/down scheme is
+similar to what is used in the object space in PyPy. So lots of
+things are touching.
+Note that the integration of Soul with Smalltalk is different than
+what happens in Oz, since I explicitly wanted to have two languages
+in symbiosis (e.g. I did not want to change Smalltalk).
+- Mozart design philosophy vs. Python design philosophy
+- How a little bit of formal semantics can help a lot.  The Mozart
+philosophy is based on having
+ *two* things at all times: an efficient implementation and a simple
+formal semantics.  This makes
+ for an interesting balancing act, but the result is worth it I think.
+- Concurrent programming: lightweight concurrency and support for
+asynchronous messages are
+ really very important if you want to "future-proof" Python.  Monitors
+are terrible; transactions
+ are nice if you can support them in the language.
+- Distributed computing: A single bullet does not do it justice by a
+long shot.  There are lots
+ of issues: degree of transparency, language design, distributed
+algorithms, fault tolerance,
+ openness, security.
+There are slides on much of this, but I can present a lot just by
+talking and writing on a
+whiteboard and answering your questions (helped by Raph and Kevin and
+the others in
+our group).  That will let you direct the discussion.
+In my opinion:
+>* Presenting PyPy is needed.
+>* Presenting our ongoing work about adding logic programming to Python
+>  is needed.
+>* Our goal is to add new programming approaches/paradigms to Python
+>  and we would have a lot to learn from your experience with Oz. What
+>  is possible and how far can we go with the current langage
+>  definition? How to design/enhance Python with logic and keep a
+>  consistent langage?
+>Among the above topics cited by Gregoire, everything is of interest
+>and several are already researched:
+>* PyPy will have a framework for experimenting with GC
+>* PyPy has lazy computation through a Thunk ObjectSpace (pypy slang)
+>* PyPy has some concurrency inherited from Stackless Python
+>* PyPy plans to do some transparent distribution (end of 2006)
+It might be worthwhile to complete this with the current state of our
+plans to "inject" some parts of Oz into PyPy. When this session will
+happen, I expect that we will have a working prototype, written in full
+Python, that covers the following :
+- a constraint store (kind of first-class environment holding up
+variables and constraints) which knows how to bind and unify variables,
+and how to check satisfiability of constraints
+- dataflow variables (with method on them that give (Pyhton) thread
+access the wait-til-bound semantics, multiple albeit monotonic binding
+of compatible/unifiable values) and streams
+- computation space (embeds/extends a constraint store, provides the
+operators defined in CTM)
+- sample search strategies & distributors
+- sample problems exercizing the prototype
+This is the subset of Oz we believe covers logic and constraint
+programming. Other aspects of Oz, while important and fascinating, will
+not be considered in our implementation attempt at this stage.
+The prototype will be, when completed, the basis of a port of these Oz
+features to PyPy. How it will be integrated, implementation-wise,
+remains unknown to us; to decide what feature will be allowed to "leak"
+from one world to the other depends on a clear understanding of how Oz
+itself manages the relation between stateful programming and the
+declarative parts.
+Peter's answer:
+Ok, I see: you are focusing on constraint programming.  This is
+absolutely fine.
+There are three levels you can go here, as I see it:
+- Just add lightweight concurrency and dataflow variables.  This
+provides many
+ interesting idioms already -- see, e.g., the paper on Flow Java which
+adds this
+ to Java by changing the compiler & VM slightly (see
+- Add WaitNeeded to the first level.  This adds lazy evaluation in a
+very nice way.
+ The combination of dataflow concurrency and lazy evaluation is very
+powerful; it goes
+ beyond what a language with a tighter evaluation strategy can express
+(such as Haskell
+ with its nonstrict strategy).
+- Add computation spaces to the first level.  This gives a full-fledged
+ constraint logic language.  It goes much beyond Prolog in that it has
+a first-class top
+ level and lazy versions of bagof (even without lazy evaluation in the
+language; with
+ lazy evaluation it just becomes more concise).
+Note that lightweight concurrency is a prerequisite to constraint
+programming: each
+operational version of a constraint (what we call a "propagator")
+executes in its own
+thread, and in big constraint problems there can easily be tens of
+thousands of these.
+On the other hand, since Oz/Mozart contains
+interesting security features as well, it might also be interesting to do a
+bit of work/talking with the Oz people in this direction.

Added: pypy/extradoc/sprintinfo/louvain-la-neuve-2006/sprint-announcement.txt
--- (empty file)
+++ pypy/extradoc/sprintinfo/louvain-la-neuve-2006/sprint-announcement.txt	Thu Feb 16 12:36:53 2006
@@ -0,0 +1,105 @@
+Louvain-la-Neuve Logic Sprint: Monday March 6th - Friday March 10th 2006 
+Where PyPy meets Oz !
+Monday and Tuesday to work on PyPy (WP10: logic programming).
+Wednesday and Thursday to meet with the people behind Oz.
+Friday to work on PyPy.
+Goals and topics of the sprint 
+While attendees of the sprint are of course welcome to work on what
+they wish, we offer these ideas:
+  - Experiment with the constraint store and dataflow variables added
+    as a library to PyPy.
+  - Investigate lazy evaluation and concurrency in Python using
+    coroutines and stackless features.
+  - Discuss possible syntactical integration of the new logic-related 
+    features
+  - Come to a shared understanding of what can and cannot be imported
+    from Oz
+  - more if possible...
+PyPy/Oz meeting Agenda
+See `PyPy/Oz Agenda`_.
+.. _`PyPy/Oz Agenda`: http://codespeak.net/pypy/extradoc/sprintinfo/louvain-la-neuve-2006/pypy-oz-agenda.txt
+The sprint will be held at
+Département d'Ingénierie Informatique (INFO),
+place St Barbe 2,
+1348 Louvain-la-Neuve
+Exact times 
+The sprint will be held from Monday March 6th noon to Friday March 10th 
+If you know that you definitely want to attend our sprint, please
+subscribe to the `PyPy sprint mailing list`_, introduce yourself and
+post a note that you want to come.  Feel free to ask any questions or
+make suggestions there!
+There is a separate `Logic Sprint people`_ page tracking who is already
+planning to come.  If you have commit rights on codespeak then you can
+modify yourself a checkout of
+  http://codespeak.net/svn/pypy/extradoc/sprintinfo/louvain-la-neuve-2006/people.txt
+.. _`PyPy sprint mailing list`: http://codespeak.net/mailman/listinfo/pypy-sprint
+.. _`Logic Sprint people`: http://codespeak.net/pypy/extradoc/sprintinfo/louvain-la-neuve-2006/people.txt
+For accomodation on site or nearby:
+If you choose "Le Relais", you will be at 12 minutes walk to the
+department (and 2 minutes from the train station).
+With the hotel "Mercure", it is a 20-30 minutes walk.
+you can find a pdf map of louvain-la-neuve at
+The Relai is in D6, the Mercure in B-C4 and the Dept. in E8.
+If you choose to stay in Brussels, it takes around 50 minutes to get
+here by train.
+Train schedules are available at:
+Bus schedules are at:
+Grégoire Dooms asks:
+With respect to internet connectivity, is wavelan ok or do
+you need wired access. What traffic/ports should be opened? I have to
+make arrangements with the network management team so it would be best
+to have this info asap.
\ No newline at end of file

More information about the Pypy-commit mailing list