- cells-devel - mailman3.common-lisp.net

[cells-devel] Release update
by Thomas F. Burdick 03 May '05

03 May '05

I'm pretty much just waiting on an answer from the OpenMCL developers telling me where we're supposed to be getting MOP functions from. For kicks, I checked Classic MCL this weekend, and it partially works. One of the unbound-cells tests failed, and I didn't feel very inspired to debug it. That does mean it got pretty far through the test suite, though. When I get the answer back from the OpenMCL developers, I'll update the candidate, and ask the couple of you who had problems with it to see if it works. Then, release :-) Here's the implementations I think Cells supports: Allegro, SBCL, LispWorks, CMUCL, OpenMCL. MCL was formerly supported and should not be very difficult to get working again. What about CLISP? Is it in the same category as MCL, or does anyone use it?

2 4

[cells-devel] Re: How cells wasted my time
by Kenny Tilton 02 May '05

02 May '05

What wasted your time was not asking on cells-devel when you had a problem. What wasted my time was taking the trouble to do open-source. Madhu wrote: >Helu, Heres some feedback on problems I encountered when learning to >use cells. > >Changing a defmodel form and evaluating it often caused the system to >stop functioning as expected. > >An example of a change is changing an :initform FORM slot to (c-in >FORM). > >An example of how the system stops functioning as expected is: rules >just dont fire. (echo output just does not happen). Accessors return >NIL instead of computed values > >lisp needs to be killed and restarted to recover. This is a >showstopper. Is there a quick way to reset the cells system and >recover? > (cell-reset) > >Another issue is after reading the doc my expectation was set at >identical behaviour from using SLOT-VALUE or an accessor. This does >not happen: For example calling the accessor produces `echo output' , >slot-value doesnt. > > slot-value is now a back door. ie, you are right, the doc is old, slot-value no longer triggers cell-ish behavior. You might do better with McCLIM. kt

1 0

[cells-devel] Re: Cells: Differences between Cells 2.0 release candidate and Cells in Cello ?
by Kenny Tilton 02 May '05

02 May '05

Frank GOENNINGER wrote: >Kenny, Thomas, > >hmm - I wonder if there are any differences between Cells versions - or >are these all the same versions? > I just checked on the Mac to confirm (it has been a while!) that we (Frank and I) were using Cells II on the Cello port to OS X. And on OS X we were just wrestling with differences between OSes and FreeGlut/MacGlut, not Cells. That said, I never finished merging the two code branches, so .... tell you what, I will do a diff and see what I can see, report back shortly.... OK, no difference. > >Thx for sorting this out. I am about to use Cells for a more advanced >system > Cool. Did you see my post a few days ago threatening to take out automatic detection of SETF cycles? These would arise normally in the classic Scoll Bar Scenario, where the cell for thumb position echos its output by SETFing the vertical offset of the text, the cell for which likewise SETFs the position of the thumb. I handled that with the "cyclicp" option, but a recent project (a 6502 assembler) required the cycling to run on a little to achieve a two-pass assemble, and in investigating i concluded, what the hell, programmers have created and fixed infinite loops for a while now and we are still here. Meanwhile, cycle detection was an ever-present drag on the system. Bad Kenny! I have disabled it in my Cells code and all seems well. Once Thomas's work is firmly in place I will CVS that down and hack out cycle detection unless someone yells. To explore your self, just locate all the *causation* references and disable the code in the two places where looping errors are thrown. I myself am firing up Cello while CliniSys works its way thru the Dilbert opus, so look for fresh paint over there as well. kt

1 0

[cells-devel] New Cells User Feedback (includes patch!)
by James Bielman 29 Apr '05

29 Apr '05

Hi, Here's a patch containing the changes I made to get Cells to compile on a current OpenMCL (just Cells, none of the GUI stuff). Also, the files in the UTILS-KT defsystem had no dependencies, so I added :serial t to compile them in the order they appear. I added a paragraph to the documentation about calling CELL-RESET after errors occur and accessors just print ".". This drove me crazy for awhile---I was restarting my Lisp image once I got in this state because I couldn't figure out what to do! What about doing something like this in MD-SLOT-VALUE (untested, and assuming I haven't completely misunderstood what's going on): (defun md-slot-value (...) (tagbody retry (when *stop* (restart-case (error "Cells is stopped due to a prior error.") (continue () :report "Return a slot value of nil." (return-from md-slot-value nil)) (reset-cells () :report "Reset cells and retry getting the slot value." (cell-reset) (go retry)))) ; rest of MD-SLOT-VALUE here ...)) Also, let me second the need for an ASDF-INSTALL'able recent version of Cells without checking out all the GUI stuff---I couldn't get the version that's up there now to work. With respect to documentation, I was thinking of adding documentation strings for exported symbols as I learn what they do---watch this space for future patches! James Index: cells/doc/01-Cell-basics.lisp =================================================================== RCS file: /project/cells/cvsroot/cell-cultures/cells/doc/01-Cell-basics.lisp,v retrieving revision 1.1 diff -u -r1.1 01-Cell-basics.lisp --- cells/doc/01-Cell-basics.lisp 26 Jun 2004 18:38:38 -0000 1.1 +++ cells/doc/01-Cell-basics.lisp 22 Apr 2005 19:34:13 -0000 @@ -319,6 +319,10 @@ c-setting-debug > ruled distance in stone may not be setf'ed 0> error is #<simple-error @ #x2123e392> +when errors like this occur, cells may enter a "stopped" state, +in which propagation does not occur and accessing model slot values +will print ".". to restart cells use the CELL-RESET function. + ;----------------------------------------------------------- aside from c?, cv, and def-c-output, another thing you will see in cello code is how complex views are constructed using Index: utils-kt/defpackage.lisp =================================================================== RCS file: /project/cells/cvsroot/cell-cultures/utils-kt/defpackage.lisp,v retrieving revision 1.7 diff -u -r1.7 defpackage.lisp --- utils-kt/defpackage.lisp 17 Nov 2004 12:32:01 -0000 1.7 +++ utils-kt/defpackage.lisp 22 Apr 2005 19:34:14 -0000 @@ -25,7 +25,7 @@ (defpackage :utils-kt (:nicknames #:ukt) (:use #:common-lisp - #-(or cormanlisp cmu sbcl) #:clos + #-(or cormanlisp cmu sbcl mcl) #:clos #+sbcl #:sb-mop #+mcl #:ccl) (:export #:utils-kt-reset Index: utils-kt/detritus.lisp =================================================================== RCS file: /project/cells/cvsroot/cell-cultures/utils-kt/detritus.lisp,v retrieving revision 1.3 diff -u -r1.3 detritus.lisp --- utils-kt/detritus.lisp 17 Nov 2004 12:32:01 -0000 1.3 +++ utils-kt/detritus.lisp 22 Apr 2005 19:34:14 -0000 @@ -36,15 +36,11 @@ ;;;(defmethod class-slot-named (class slotname) ;;; (find slotname (class-slots class) :key #'slot-definition-name)) -#+mcl -(defun class-slots (c) - (nconc (copy-list (class-class-slots c)) - (copy-list (class-instance-slots c)))) - - #-(or lispworks mcl) (defun true (it) (declare (ignore it)) t) +#-(or lispworks mcl) (defun false (it) (declare (ignore it))) + (defun xor (c1 c2) (if c1 (not c2) c2)) Index: utils-kt/utils-kt.asd =================================================================== RCS file: /project/cells/cvsroot/cell-cultures/utils-kt/utils-kt.asd,v retrieving revision 1.2 diff -u -r1.2 utils-kt.asd --- utils-kt/utils-kt.asd 5 Dec 2004 04:51:02 -0000 1.2 +++ utils-kt/utils-kt.asd 22 Apr 2005 19:34:14 -0000 @@ -16,6 +16,7 @@ :licence "MIT Style" :description "Kenny's Utilities" :long-description "Low-level utilities used by all of Kenny's projects" + :serial t :components ((:file "defpackage") (:file "debug") (:file "detritus")

4 13

[cells-devel] RFE: Set My Cycles Free?
by Kenny Tilton 29 Apr '05

29 Apr '05

James Bielman wrote: >On 27 Apr 2005, Kenny Tilton wrote: > > > >>Fascinating. I happen to have done quite a bit of 6502 programming >>back in my Apple II days. I can't wait to look at your code and see >>how Cells was able to contribute to that. I will also stare at the >>cycle and think about how Cells could be enhanced to handle that >>gracefully, even if just by giving programmers an orderly way to >>apply domain knowledge. >> >> > >Cool. I never really did much so I'm learning as I go. :) I put up a >more detailed description of what happens during an assembly and where >the cycle occurs at: > > http://www.jamesjb.com/assembler-cycle.txt > > Thanks for the detailed breakdown of the problem. You may have noticed that the system does allow a cell to be specified as "cyclic", but then the propagation simply halts if a cycle is detected. This to support cases like a scroll thumb, which both drives and is driven by the text currently displayed in a window. In that case, the cyclic propagation would be to set the cell to the value it already has, so it can simply be skipped. (I could let it continue and then propagation would stop anyway since the skipped set would result in no change, when propagation stops anyway, but I decided, hey, save a few CPU cycles. anyway...) Likewise, in your case the cycle is benign and terminates naturally. And as long as we are considering some way to let the programmer apply domain-specific knowledge.... What if we just eliminate entirely the cyclic thing and let programmers shoot themselves in the foot if they like? That is the Grand Lisp Philosophy, after all. Ironically, I might then consider treating the scroll case as /non/-cyclic. ie, It becomes a special declaration /not/ to cycle, saving a few CPU cycles. Hmmm, but now I am wondering about the CPU cost of cycle detection: (when (find c *causation*) (case (c-cyclicp c) (:run-on (trc "cyclicity running on" c)) ((t) (progn (trc "cyclicity handled gracefully" c) (c-pulse-update c :cyclicity-1) (return-from md-slot-value new-value))) (otherwise (c-break "(setf md-slot-value) setf looping ~a ~a" c *causation*)))) Omigod. What the hell is :run-on doing there? :) I am going to go try that now on your assembler code. Anyway, look at that "(find c *causation*)". That runs allllllllllll the time. The only benefit is automatically notifying the developer when they screw up. I could just toss the whole thing (even the cyclic attribute altogether, I think) or we could have a special such as *cell-trap-cyclic-bugs-please* and then try to figure out when something is cyclinc (not that easy, I believe Turing demonstrated). Of historical interest is that it occurred to me long ago that applications could simply work this way. I mean, it is how the world works. One cause leading to another. And it so happens that one consequence of Cells II is that this endless causal chain no longer means endless recursion, so the timing is good. Thoughts? kenny

1 1

[cells-devel] Cells 2.0 release candidate
by Thomas F. Burdick 28 Apr '05

28 Apr '05

I've put a release candidate for Cells up here: http://www.ocf.berkeley.edu/~tfb/cells_2.0.tar.gz Before I put it up on c-l.net, change the Cliki link, and make noise about it, I'd appreciate it if other Cells users would confirm that it works for them. Particularly users of Cello and Cells-Gtk, which I don't use. The differences from what's in CVS are mostly organizational: I moved utils-kt into the cells directory, rearranged the locations of a couple files, and removed the unused profile code. I replaced defconstant-once (in utils-kt) with a better define-constant that DoesWIM, and I think what Kenny means, too, based on the evidence of his code. I also changed the one use of defconstant to use define-constant, and now everything builds cleanly again on SBCL. I think this should all be uncontroversial. If this works for everybody, I'll paste together a README file from the various candidates in cell-cultures, and release this weekend. Kenny: this tarball looks to me like a good way of organizing cells in CVS, so if you agree, you can just check this in to have a freed-from-cell-cultures cells. Otherwise, you can figure it out, this works for a release anyhow.

3 3

[cells-devel] More on the details...
by Mike J. Bell 10 Mar '05

10 Mar '05

Ok, so I did a survey of the design in one of the applications I built, and I'm pretty convinced I could move to a completely-declarative model, with not *too* much effort. One thing that baffles me though, is how you would go about implementing undo/redo functionality. In my current application, just about everything can be undone/redone, with a theoretically infinite list of snapshots. I had to put in some weird mechanisms to shield the undo/redo system from saving state *too* often, like for example if the user is dragging an object on the screen, it only remembers where it was and where it ended up, not the whole path. It's unbelievably simple to implement this in our imperative world...the undo/redo system (which, incidentally, in written in user-land and requires no support from the architecture) listens for changes in the specified slots, records everything when they change, and when you tell it, will walk the stack and publish saved data at a later time. Obviously, when you look at most of the "core" data slots in my application, you'll find at least three publishers: the thing that really calculates what it should be at runtime, and then undo, and redo. How do you solve this in Cells? It sounds like it would be really annoying to have to write "dispatch" slots that marshall the three different possible values for every cell that falls into this pattern...but I guess that's what macros are for. What about integrating it into the Cells engine itself? I mean, since Cells is declarative, theoretically you should be able to record the value of all the independent cells (the "roots" of your DAG of slot dependencies) and then just reset them all accordingly to get the whole system into the same state as it was...right? Thanks for your comments... -- Mike J. Bell on gmail

1 0

[cells-devel] Imperative vs. declarative
by Mike J. Bell 08 Mar '05

08 Mar '05

Hey Kenny, I did a lot of thinking about what you said about declarative vs. imperative. I'm not sure what's the right terminology, but I did finally see the light. We've had problems in applications written in our framework when there are multiple producers of one datum. In a lot of cases (benign and simple), it's been OK. However, as soon as things get bigger, we put a repeating pattern into our designs where a single controller function will act as a gatekeeper, reading from multiple channels of data, and forming the single producer for the difficult datum in the previously intractable design. I've thought about it quite a bit, and I've proved to myself that this is equivalent to your declarative model, even if there are some slight structural differences*. So, in order for me to get from where I am to where Cells is, all I need to do is instead of waiting for the multiple producers issue to get out of hand and uncontrollable...just nip it in the bud and don't allow it to begin with. Then every piece of data has only one producer. Thanks again for talking with me about it! Mike * Speaking of structure, question for you. Let's say you're declaring a slot to be a function of a couple other slots in Cells. How do you know they exist? I.e., where do you find your objects? Do you have like a database somewhere (hash of name->object or the like) that you lookup to find things? Are they all passed in at construction time? (I would imagine this wouldn't scale well at all). Is there some other scoping mechanism? I'm not sure if Cells has any builtin support for finding the other objects/slots that participate in Cells, or if you roll your own per application...but I'd love to hear about how you solve it when *you* write code. -- Mike J. Bell on gmail

2 1

[cells-devel] Newbie questions
by Mike J. Bell 08 Mar '05

08 Mar '05

I suppose some of this might be in a FAQ or something, but I'm somewhat lazy and I've got some questions burning. I also apologize for A) not knowing CL very well B) not knowing very much about CLOS at all (except what it stands for). Please pardon any strange or misused terminology. That said, I've got some questions about how Cells works. 1) Synchronicity, or the currency conversion problem: Let's say I define a slot in an object that represents the amount of US Dollars I have in a bank account. Let's further say that in my app I also want to represent the amount of Japanese Yen in my account. If someone "sets" the amount of dollars, I want the yen slot to be updated. If someone sets the yen, I want the dollars to be updated. Is there a mechanism to create such co-dependent cells? (Obviously this is addressing the update cycle problem, and at the shortest path level: A depends on B depends on A (length 1), which forms a very useful group of calculations). 2) Equals: It looks like, from reading 01-Cell-basics.lisp, that setting a slot to an "equivalent" object does not cause all its dependencies to fire again (in order to save substantial useless recalculations). What does "equivalent" mean? Can I install my own equivalency operator, per slot (or per class would be fine) so that Cells knows when computations should be rerun? 3) Lack of values, or triggers: It's easy to come up with typed slots that participate in calculations. However, what about untyped events? For instance, a press of a button conveys no useful state information. Is it possible in Cells to make slots dependent upon the "change" of a stateless slot? (This sort of ties back into the equals business...I understand you could implement this sort of functionality by setting a slot to, for example, a gensym uninterned symbol, so that there is no useful value and it's sure to cause everything to recalculate by any useful definition of equals, but this solution is...well, kind of ugly. It would be nice to be able to define the recalculation or "firing" semantics of a slot, which is a superset of the "equals" issue above). 4) Transactions: Let's say you have 50 or 60 slots that are connected in a complicated graph of calculation. A change to one slot (let's call this "initiation") causes all of these guys to start running until finally the system reaches a steady state and no more changes occur. We could conceptualize this initiation, subsequent calculations and then collapse into steady state as a single "transaction." Now, imagine that at the second-to-last calculation of this propagation of values, the system enters a state of inconsistency. In other words, the initiation of that one state change way back in the beginning is actually invalid. However, we don't know that (given that this is a nice event-driven framework) until step 52, and we've got 40 slots that are all now different than they were, and *wrong*. Ideally, it would be nice to have mechanism that A) notifies the programmer, similar to a "catch" construct, so that s/he can note it in an appropriate fashion, and B) restores all the slots in the system to the last known good steady state; i.e., what they were before the initiation occured. Does Cells have a transaction model similar to this? If so, can someone explain it? Are there separate phases of execution in the transaction? Are there separate "guards" that are responsible for determining the validity of system state? Is there a way to specify that slots get updated only once the system state becomes steady; i.e. they don't participate in the middle of the transaction? (These beasts have quite a few constraining properties, I realize, but they could (are) be very useful to reduce the amount of "spinning" the recalculation has to do). Thanks in advance for all your comments. Mike -- Mike J. Bell on gmail

3 3

Re: [cells-devel] More newbie questions
by Kenny Tilton 07 Mar '05

07 Mar '05

Mike J. Bell wrote: >Hey Kenny...I've got sort of a philosophical question for you. (I'm >much more interested in the intent of Cells rather than the mechanics, >even though the mechanics define the intent...I'm sure you know what I >mean). > >The spirit of Cells seems to be to very much like the declarative >functional world of spreadsheets (ok, I cheated and actually *read* >that in the docs. =). If I were to start a new project (and thus >legacy code/app is irrelevant), why would I use Cells and not Haskell >or some other pure lazy functional language? > >If the answer is along the lines of "CL is super cool 1337 d00d, why >use anything else" that's fine. What I'm digging for here is any >major philosophical differences between using Cells (and I mean >*using*, like building your entire app on as much Cells functionality >as possible and not mixing paradigms) > aside: actually, I think it would be hard to mix paradigms. I always point out that Cells is a slippery slope: use them a little and pretty soon you have to use them for everything. the paradigm is not "lazy functional", it is "dataflow". In my apps, all input gets fed into c-input cells, and all application behavior is manifested by def-c-output methods. The web of cells is a working model where slots have causal power over other slots. The feel of the /programming/ is spreadsheet-y, but the result is, again, a working model. Working in the sense that one simply SETfs an input cell and the whole model reacts /and/ behaves automatically, according to the supplied rules. Of course, a spreadsheet is also a working model. getting back to the slippery slope, I am not sure how one could combine imperative, programmer-oriented control with the automatic dataflow engine -- where would one put the hooks? > and purely functional, >declarative, lazy languages. What's the discriminator? > > Sorry, I have never used anything like Haskell, so I have no idea what it feels like or how to compare, other than what I said above. But maybe this will be close (my apologies if I am muddying the waters): if you have a lazy functional language, the control lies outside the declarative authoring, because, as I understand lazy, nothing happens until someone asks. So there must be a control flow programmed some other way (imperative?) which finally does the asking. In which case one is not really getting all the benefit possible out of the declarative approach. kt

1 0