I am currently reading "Turtle Geometry", and I am a little disappointed
that there isn't a turtle graphics implementation in Common Lisp. (You
would think kenny at least would have something). In contrast, it was
almost embarrassingly easy to work up something usable in smalltalk (even
before I found the StarSqueakTurtle class).
I would be delighted to find out I am wrong.
Matt
--
"You do not really understand something unless you can
explain it to your grandmother." - Albert Einstein.
In article <······························@c.net>,
Matthew Swank <································@c.net> wrote:
> I am currently reading "Turtle Geometry", and I am a little disappointed
> that there isn't a turtle graphics implementation in Common Lisp. (You
> would think kenny at least would have something). In contrast, it was
> almost embarrassingly easy to work up something usable in smalltalk (even
> before I found the StarSqueakTurtle class).
So, where is your Common Lisp version?
Hacking up a McCLIM version with commands and display should be easy.
MCL comes with a turtle example. Well, StarLogo for the Mac
was written in MCL (now it is Java).
> I would be delighted to find out I am wrong.
>
> Matt
In the meantime this might need some update to run on
anything else than CMUCL:
http://www.ii.uib.no/~knute/lsystems/llisp.html
Uses 3d turtle geometry for Lindenmayer systems.
--
http://lispm.dyndns.org
On Sun, 24 Jun 2007 01:14:08 +0200, Rainer Joswig wrote:
>
> In the meantime this might need some update to run on
> anything else than CMUCL:
>
> http://www.ii.uib.no/~knute/lsystems/llisp.html
>
> Uses 3d turtle geometry for Lindenmayer systems.
This is cool, but it's a little overkill for my needs.
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
On Sun, 24 Jun 2007 01:14:08 +0200, Rainer Joswig wrote:
> In article <······························@c.net>,
> Matthew Swank <································@c.net> wrote:
>
>> I am currently reading "Turtle Geometry", and I am a little disappointed
>> that there isn't a turtle graphics implementation in Common Lisp. (You
>> would think kenny at least would have something). In contrast, it was
>> almost embarrassingly easy to work up something usable in smalltalk (even
>> before I found the StarSqueakTurtle class).
>
> So, where is your Common Lisp version?
> Hacking up a McCLIM version with commands and display should be easy.
(:rant
About every 6 months or so I take a look at CLIM, and it usually gives
me a headache. I'm not sure anyone could write a book called "CLIM in
Small Pieces" with a straight face. Part of the reason for snarky
comment about smalltalk is that doing simple thing that require a rich
interface is an uphill battle in Common Lisp (CLIM just being one
example).
I know there are good reasons for this, but damn! Unless you're a symbol
pusher, doodling in lisp is a pain y'all!)
On the other hand, I love lisp so much I am whining here instead of
switching to smalltalk (I know what a huge loss it would be to the
community).
Matt
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
In article <······························@c.net>,
Matthew Swank <································@c.net> wrote:
> On Sun, 24 Jun 2007 01:14:08 +0200, Rainer Joswig wrote:
>
> > In article <······························@c.net>,
> > Matthew Swank <································@c.net> wrote:
> >
> >> I am currently reading "Turtle Geometry", and I am a little disappointed
> >> that there isn't a turtle graphics implementation in Common Lisp. (You
> >> would think kenny at least would have something). In contrast, it was
> >> almost embarrassingly easy to work up something usable in smalltalk (even
> >> before I found the StarSqueakTurtle class).
> >
> > So, where is your Common Lisp version?
> > Hacking up a McCLIM version with commands and display should be easy.
>
> (:rant
> About every 6 months or so I take a look at CLIM, and it usually gives
> me a headache. I'm not sure anyone could write a book called "CLIM in
> Small Pieces" with a straight face. Part of the reason for snarky
> comment about smalltalk is that doing simple thing that require a rich
> interface is an uphill battle in Common Lisp (CLIM just being one
> example).
Probably the biggest problem is unlearning and overcoming
some mental hurdle. Once you are there a lot of stuff gets easy.
Take for example the CLIM graphics functions. All very straight
forward. Mostly follows the Postscript drawing model. Lots of
nicely named functions with nicely named keyword parameters.
Lot's of stuff has been done with CLIM and Dynamic Windows
(the system that was the main influence for CLIM.
Think of CLIM as a portable DW).
McCLIM should be fine for experimenting.
You get a nice graphical listener:
http://jlr.freeshell.org/data/mcclim/screenshots/2007-03-27-listener-light-4.png
More here: http://common-lisp.net/project/mcclim/
The Wiki hass some help: http://mcclim.cliki.net/index
I have collected some screen shots of DW applications
from the literature:
http://lispm.dyndns.org/symbolics-ui-examples/symbolics-ui-examples.html
You see that applications mostly take up the whole screen
(you'll switch with the keyboard or via menus between applications).
Each application has a few panes that will be automatically
resized based on the window size and a layout description.
There are some specialized panes: title, menu, application display,
command line and options.
The application pane usually has lots of clickable data items.
CLIM/DW let's you combine the object with the output. So
later you can click on the object (or drag it, select it, ...)
and invoke commands. There are extensive context menus
on right-clicking any object.
The menu pane shows often used commands.
The command line shows the command history (even for the
commands that you have invoke from a menu or by clicking/dragging).
You can enter commands and you get prompts for arguments. The
objects are mouse sensitive based on the argument types.
Think of commands as enhanced functions with argument
types, documentation, prompts and so on.
The interaction with these kinds of application user interfaces
is a lot of fun, because they are very 'dynamic' (->
Dynamic Windows).
You see some pretty ancient stuff on the screen shots. The applications
were written in the 80s. Still you see some interesting stuff:
A system commenting soccer games, a storm waring expert system,
natural language explanations of paths through a city, automatic
generation of handbook drawings and explanations, a controller
for Caterpillar operations, a fancy Logo implementation,
kitchen design, some experimental programming environments,
Thinking Machine's document retrievel system, NASA apps, ...
The application/pane model makes a big comeback at Apple currently.
They go away from individual windows to iTunes-like interfaces
with panes. The Finder in 10.5 is also like that. The thing that
Apple does not have in these windows is the command line.
There is also now lots of context menus (right-click).
The color application showing the process displays is the first of its kind
ever. With gauges, pipes, dials, valves, and so on.
> I know there are good reasons for this, but damn! Unless you're a symbol
> pusher, doodling in lisp is a pain y'all!)
>
> On the other hand, I love lisp so much I am whining here instead of
> switching to smalltalk (I know what a huge loss it would be to the
> community).
>
> Matt
So, you want a CLIM example for turtle graphics?
I'll post something. Maybe today or tomorrow.
--
http://lispm.dyndns.org
On Mon, 25 Jun 2007 10:09:37 +0200, Rainer Joswig wrote:
> So, you want a CLIM example for turtle graphics?
>
> I'll post something. Maybe today or tomorrow.
That would be wonderful. I can see there are some interesting ideas in
CLIM.
Matt
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
On Wed, 27 Jun 2007 14:06:40 +0200, Rainer Joswig wrote:
> In article <······························@c.net>,
> Matthew Swank <································@c.net> wrote:
>
>> On Mon, 25 Jun 2007 10:09:37 +0200, Rainer Joswig wrote:
>>
>> > So, you want a CLIM example for turtle graphics?
>> >
>> > I'll post something. Maybe today or tomorrow.
>>
>> That would be wonderful. I can see there are some interesting ideas in
>> CLIM.
>>
>> Matt
>
> This example is really simple. Just to get somebody started.
>
It is very nice-- just the bare bones, but the important stuff is there.
I see the commands: providing a stereotypical repl-like interaction in the
interface. I like how the code separates the establishment of a context
to operate on from the operation itself using the with-turtle macro:
> (defmacro with-turtle ((turtle) &body body)
> `(clim:with-application-frame (frame)
> (let ((*standard-output* (clim:frame-standard-output frame)))
> (let ((,turtle (first (world-objects frame))))
> (setf *turtle* turtle)
> (clim:with-first-quadrant-coordinates (*standard-output* 200 200)
> ,@body)))))
>
Though there seems to be an unintentional variable capture in
"(setf *turtle* turtle) ..."
Anyway CLIM seems cool. However, I do notice that McClim is still
a bit fragile even with the mature X backend.
Matt
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
In article <······························@c.net>,
Matthew Swank <································@c.net> wrote:
> On Wed, 27 Jun 2007 14:06:40 +0200, Rainer Joswig wrote:
>
> > In article <······························@c.net>,
> > Matthew Swank <································@c.net> wrote:
> >
> >> On Mon, 25 Jun 2007 10:09:37 +0200, Rainer Joswig wrote:
> >>
> >> > So, you want a CLIM example for turtle graphics?
> >> >
> >> > I'll post something. Maybe today or tomorrow.
> >>
> >> That would be wonderful. I can see there are some interesting ideas in
> >> CLIM.
> >>
> >> Matt
> >
> > This example is really simple. Just to get somebody started.
> >
>
> It is very nice-- just the bare bones, but the important stuff is there.
>
> I see the commands: providing a stereotypical repl-like interaction in the
> interface. I like how the code separates the establishment of a context
> to operate on from the operation itself using the with-turtle macro:
>
> > (defmacro with-turtle ((turtle) &body body)
> > `(clim:with-application-frame (frame)
> > (let ((*standard-output* (clim:frame-standard-output frame)))
> > (let ((,turtle (first (world-objects frame))))
> > (setf *turtle* turtle)
> > (clim:with-first-quadrant-coordinates (*standard-output* 200 200)
> > ,@body)))))
> >
>
> Though there seems to be an unintentional variable capture in
> "(setf *turtle* turtle) ..."
Not bad, you found that. I just put that variable in to
show the describe in the listener. But there is a comma
missing in front of turtle...
> Anyway CLIM seems cool. However, I do notice that McClim is still
> a bit fragile even with the mature X backend.
Yes. It is quite a bit fragile and some of its behavior is
still not really satisfying (and ugly). Maybe
it needs more people sending bug reports?
>
> Matt
--
http://lispm.dyndns.org
Matthew Swank wrote:
> I am currently reading "Turtle Geometry", and I am a little disappointed
> that there isn't a turtle graphics implementation in Common Lisp. (You
> would think kenny at least would have something). In contrast, it was
> almost embarrassingly easy to work up something usable in smalltalk (even
> before I found the StarSqueakTurtle class).
With lispbuilder-sdl it is very easy to implement turtle graphics:
http://www.frank-buss.de/tmp/turtle.png
With the latest SVN version (the last release is a bit outdated), it is
implemented like this.
(defpackage #:turtle (:use #:sdl #:cl))
(in-package #:turtle)
(defparameter *width* 600)
(defparameter *height* 600)
(defparameter *x* (truncate *width* 2))
(defparameter *y* (truncate *height* 2))
(defparameter *pen-down-state* nil)
(defparameter *angle* 90.0)
(defun up ()
(setf *pen-down-state* nil))
(defun down ()
(setf *pen-down-state* t))
(defun left (angle)
(incf *angle* angle))
(defun right (angle)
(decf *angle* angle))
(defun fw (length)
(let ((angle (* *angle* (/ pi 180.0))))
(let ((dx (* (sin angle) length))
(dy (* (cos angle) length))
(x *x*)
(y *y*))
(incf *x* dx)
(incf *y* dy)
(when *pen-down-state*
(draw-line-* x y *x* *y*)))))
(defun koch (length &optional (depth 3))
(let ((fw (if (zerop depth)
(lambda () (fw length))
(lambda () (koch length (1- depth))))))
(funcall fw)
(left 60)
(funcall fw)
(right 120)
(funcall fw)
(left 60)
(funcall fw)))
(defun snow (length)
(loop repeat 3 do
(koch length)
(right 120)))
(defun winter ()
(loop for i from 1 to 50 do
(left 30)
(down)
(snow (+ 0.1 (random 0.3)))
(up)
(fw (+ 20 (* 3 i)))))
(defun turtle ()
(with-init ()
(window *width* *height* :title-caption "Turtle Graphics")
(clear-display *white*)
(setf *default-color* *black*)
(winter)
(update-display)
(with-events (:wait)
(:quit-event () t)
(:key-down-event (:key key)
(when (key= key :SDL-KEY-ESCAPE)
(push-quit-event)))
(:video-expose-event () (update-display)))))
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Frank Buss <··@frank-buss.de> writes:
> Matthew Swank wrote:
>
>> I am currently reading "Turtle Geometry", and I am a little disappointed
>> that there isn't a turtle graphics implementation in Common Lisp. (You
>> would think kenny at least would have something). In contrast, it was
>> almost embarrassingly easy to work up something usable in smalltalk (even
>> before I found the StarSqueakTurtle class).
>
> With lispbuilder-sdl it is very easy to implement turtle graphics:
Or you can use my cl-cairo2 package
(http://common-lisp.net/project/cl-cairo2/), which now has (a
hopefully portable) X11 output.
Tamas
On Sun, 24 Jun 2007 07:30:26 +0200, Frank Buss wrote:
> Matthew Swank wrote:
>
>> I am currently reading "Turtle Geometry", and I am a little disappointed
>> that there isn't a turtle graphics implementation in Common Lisp. (You
>> would think kenny at least would have something). In contrast, it was
>> almost embarrassingly easy to work up something usable in smalltalk (even
>> before I found the StarSqueakTurtle class).
>
> With lispbuilder-sdl it is very easy to implement turtle graphics:
>
Something ain't right: (using the svn lispbuilder stack on sbcl linux/x86)
(turtle)
-->
NIL is not a Lisp string or pointer.
[Condition of type SIMPLE-ERROR]
Restarts:
0: [ABORT] Return to SLIME's top level.
1: [TERMINATE-THREAD] Terminate this thread (#<THREAD "repl-thread" {AF18AB1}>)
Backtrace:
0: ((SB-PCL::FAST-METHOD CFFI:TRANSLATE-TO-FOREIGN
(T CFFI::FOREIGN-STRING-TYPE))
#<unavailable argument>
#<unavailable argument>
NIL
#<unavailable argument>)
1: (LISPBUILDER-SDL-CFFI::SDL-WM-SET-CAPTION "Turtle Graphics" NIL)
Locals:
SB-DEBUG::ARG-0 = "Turtle Graphics"
SB-DEBUG::ARG-1 = NIL
2: (LISPBUILDER-SDL-BASE:SET-SCREEN 600 600)
Locals:
SB-DEBUG::ARG-0 = 10
SB-DEBUG::ARG-1 = 600
SB-DEBUG::ARG-2 = 600
3: (WINDOW 600 600)
Locals:
SB-DEBUG::ARG-0 = 4
SB-DEBUG::ARG-1 = 600
SB-DEBUG::ARG-2 = 600
4: (TURTLE)
[No Locals]
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
On Mon, 25 Jun 2007 21:13:47 +0200, Frank Buss wrote:
> Looks like SBCL is a bit more picky about missing parameters than
> LispWorks. Try specifying both parameters for the caption:
>
> (window *width* *height* :title-caption "Turtle Graphics" :icon-caption
> "Turtle Graphics")
Thanks, that worked.
Matt
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.
On Jun 23, 6:08 pm, Matthew Swank
<································@c.net> wrote:
> I am currently reading "Turtle Geometry", and I am a little disappointed
> that there isn't a turtle graphics implementation in Common Lisp. (You
> would think kenny at least would have something). In contrast, it was
> almost embarrassingly easy to work up something usable in smalltalk (even
> before I found the StarSqueakTurtle class).
>
> I would be delighted to find out I am wrong.
>
> Matt
>
> --
> "You do not really understand something unless you can
> explain it to your grandmother." - Albert Einstein.
I thought Lisp with turtle graphics was called Logo. :-)
On Jun 24, 12:08 am, Matthew Swank
<································@c.net> wrote:
> I am currently reading "TurtleGeometry", and I am a little disappointed
> that there isn't aturtlegraphics implementation in Common Lisp. (You
> would think kenny at least would have something). In contrast, it was
> almost embarrassingly easy to work up something usable in smalltalk (even
> before I found the StarSqueakTurtle class).
>
> I would be delighted to find out I am wrong.
>
> Matt
>
> --
> "You do not really understand something unless you can
> explain it to your grandmother." - Albert Einstein.
Read only if you are interested in some old history...
I just came across an old video from Cambridge Atari Research.
Seems like that hacked some Logo stuff on the Lisp Machine. Qlogo
was it. There were also some other fancy applications, like
a Lisp Machine controlling a puppet, gesture based programming,
and an early Music authoring tool.
Here are the links to the videos at google:
http://lispm.dyndns.org/news?ID=NEWS-2007-07-17-1
On Tue, 17 Jul 2007 13:19:41 -0700, ······@corporate-world.lisp.de wrote:
> On Jun 24, 12:08 am, Matthew Swank
> <································@c.net> wrote:
>> I am currently reading "TurtleGeometry", and I am a little disappointed
>> that there isn't aturtlegraphics implementation in Common Lisp. (You
>> would think kenny at least would have something). In contrast, it was
>> almost embarrassingly easy to work up something usable in smalltalk (even
>> before I found the StarSqueakTurtle class).
>>
>> I would be delighted to find out I am wrong.
>>
>> Matt
>>
>> --
>> "You do not really understand something unless you can
>> explain it to your grandmother." - Albert Einstein.
>
> Read only if you are interested in some old history...
>
> I just came across an old video from Cambridge Atari Research.
> Seems like that hacked some Logo stuff on the Lisp Machine. Qlogo
> was it. There were also some other fancy applications, like
> a Lisp Machine controlling a puppet, gesture based programming,
> and an early Music authoring tool.
>
> Here are the links to the videos at google:
> http://lispm.dyndns.org/news?ID=NEWS-2007-07-17-1
Cool, though it plays like an obituary for Atari Labs. Was that the case
in 1984?
Some notes. Alan Kay was running the show! He seems to turn up the most
interesting places. The button box language is reminiscent of the etoys
in Squeak. Of all the example research, the one thing that still seemed
kind of primitive was the musical composition tools: at least the
algorithmic stuff.
Matt
--
"You do not really understand something unless you
can explain it to your grandmother." - Albert Einstein.