Martin Fowler talks about Lisp...
Pascal Costanza
http://martinfowler.com/articles/languageWorkbench.html
Pascal
--
2nd European Lisp and Scheme Workshop
July 26 - Glasgow, Scotland - co-located with ECOOP 2005
http://lisp-ecoop05.bknr.net/
Joe Marshall
> ...and favorably so. See
> http://martinfowler.com/articles/languageWorkbench.html
I noticed that Tiobe ( http://www.tiobe.com/ )
now rates Lisp as a `Mainstream Language' with an `A' rating.
What is the world coming to?
Rainer Joswig
3ilnm1F...@individual.net:
> ...and favorably so. See
>
> http://martinfowler.com/articles/languageWorkbench.html
>
>
> Pascal
His example in some primitive way:
The macro does most of the work. It generates a class for
the data and two methods for parsing the lines.
(defmacro defmapping (name mapping &body fields)
`(progn
(defclass ,name ()
,(loop for (nil nil slot) in fields
collect slot))
(defmethod find-mapping-class-name ((mapping (eql ',(intern mapping))))
',name)
(defmethod parse-line-for-class (line (class-name (eql ',(intern
name))))
(let ((object (make-instance class-name)))
(loop for (start end slot) in ',fields
do (setf (slot-value object slot) (subseq line start (1+
end))))
object))))
Now we use the macro to define the mappings:
(defmapping service-call "SVCL"
(04 18 customer-name)
(19 23 customer-id)
(24 27 call-type-code)
(28 35 date-of-call-string)))
(defmapping usage "USGE"
(04 08 customer-id)
(09 22 customer-name)
(30 30 cycle)
(31 36 read-date))
The example lines:
(defparameter *test-lines*
"SVCLFOWLER 10101MS0120050313.........................
SVCLHOHPE 10201DX0320050315........................
SVCLTWO x10301MRP220050329..............................
USGE10301TWO x50214..7050329...............................")
Let's try it out:
CL-USER 21 > (map nil 'describe
(with-input-from-string (stream *test-lines*)
(loop for line = (read-line stream nil nil)
while line
collect (parse-line-for-class line (find-mapping-class-name
(intern (subseq line 0 4)))))))
#<SERVICE-CALL 10082C7F> is a SERVICE-CALL
CUSTOMER-NAME "FOWLER "
CUSTOMER-ID "10101"
CALL-TYPE-CODE "MS01"
DATE-OF-CALL-STRING "20050313"
#<SERVICE-CALL 100828A3> is a SERVICE-CALL
CUSTOMER-NAME "HOHPE "
CUSTOMER-ID "10201"
CALL-TYPE-CODE "DX03"
DATE-OF-CALL-STRING "20050315"
#<SERVICE-CALL 100824BB> is a SERVICE-CALL
CUSTOMER-NAME "TWO x"
CUSTOMER-ID "10301"
CALL-TYPE-CODE "MRP2"
DATE-OF-CALL-STRING "20050329"
#<USAGE 100820CF> is an USAGE
CUSTOMER-ID "10301"
CUSTOMER-NAME "TWO x"
CYCLE "7"
READ-DATE "050329"
Andras Simon
thal...@gmail.com
> (defmacro defmapping (name mapping &body fields)
> `(progn
> (defclass ,name ()
> ,(loop for (nil nil slot) in fields
> collect slot))
> (defmethod find-mapping-class-name ((mapping (eql ',(intern mapping))))
> ',name)
> (defmethod parse-line-for-class (line (class-name (eql ',(intern
> name))))
> (let ((object (make-instance class-name)))
> (loop for (start end slot) in ',fields
> do (setf (slot-value object slot) (subseq line start (1+
> end))))
> object))))
Hi Rainer!
This was very interesting. How short and simple you made it look,
especially compared to that clumsy C# code Martin posted. However, I
tried your code on both clisp and sbcl and ran into a problem. (intern
'something) doesn't work in them so I had to change your code a tiny
bit.
Here's a version that works for me. Please let me know if the fix is
insufficient in some way,
(defmacro defmapping (name mapping &body fields)
`(progn
(defclass ,name ()
,(loop for (nil nil slot) in fields
collect slot))
(defmethod find-mapping-class-name ((mapping (eql ',(intern
mapping))))
',name)
(defmethod parse-line-for-class (line (class-name (eql ',(intern
(symbol-name name)))))
(let ((object (make-instance class-name)))
(loop for (start end slot) in ',fields
do (setf (slot-value object slot) (subseq line start (1+
end))))
object))))
Regards, Tommy
Rainer Joswig
<thal...@gmail.com> in
1120682504....@g47g2000cwa.googlegroups.com:
Try this one:
(defmacro defmapping (name mapping &body fields)
`(progn
(defclass ,name ()
,(loop for (nil nil slot) in fields
collect slot))
(defmethod find-mapping-class-name ((mapping (eql ',(intern mapping))))
',name)
(defmethod parse-line-for-class (line (class-name (eql ',name)))
Rainer Joswig
BEF306B6.FE68%jos...@lisp.de:
> Am 06.07.2005 22:41 Uhr schrieb "thal...@gmail.com" unter
> <thal...@gmail.com> in
> 1120682504....@g47g2000cwa.googlegroups.com:
>
>> Rainer Joswig wrote:
>>> (defmacro defmapping (name mapping &body fields)
>>> `(progn
>>> (defclass ,name ()
>>> ,(loop for (nil nil slot) in fields
>>> collect slot))
>>> (defmethod find-mapping-class-name ((mapping (eql ',(intern mapping))))
>>> ',name)
>>> (defmethod parse-line-for-class (line (class-name (eql ',(intern
>>> name))))
>>> (let ((object (make-instance class-name)))
>>> (loop for (start end slot) in ',fields
>>> do (setf (slot-value object slot) (subseq line start (1+
>>> end))))
>>> object))))
>>
>> Hi Rainer!
>>
>> This was very interesting. How short and simple you made it look,
>> especially compared to that clumsy C# code Martin posted.
I've written a short article about some DSL style programming technique:
http://lispm.dyndns.org/news?ID=NEWS-2005-07-08-1
GP lisper
>
> I've written a short article about some DSL style programming technique:
>
> http://lispm.dyndns.org/news?ID=NEWS-2005-07-08-1
I enjoyed the article, but the part that I really need to grok is
looking at:
SVCLHOHPE 10201DX0320050315........................
and seeing a mapping macro as the way to solve this problem. Clearly
I need to slough thru these problems a few times more.
Rainer Joswig
in 1120863635.4cb311645ca9886eb8604a246f0fd4eb@teranews:
What you can know from looking at the data is:
- it is some text based format with one record per line
- there is a tag in front of each line, which gives you the record type
- the record will have several fields
- different records will have different sets of fields
- records are best represented by Common Lisp classes
- fields are best represented by Common Lisp object's slots
- then you need a simple way to describe the layout the data and compute the
class from this description
- plus you need some mechanism to get from the record type the class
- ...
Parts of the development process are demonstrated in the video referenced
in the article. You might need some time to download it...
GP lisper
>
> Parts of the development process are demonstrated in the video referenced
> in the article. You might need some time to download it...
If I get it downloaded (second attempt now), I'll rehost it (if you
don't mind).
--
LOOP :: a Domain Specific Language.
GP lisper
> in 1120863635.4cb311645ca9886eb8604a246f0fd4eb@teranews:
>>
>>
>> and seeing a mapping macro as the way to solve this problem. Clearly
>> I need to slough thru these problems a few times more.
>
> What you can know from looking at the data is:
>
> - it is some text based format with one record per line
> - there is a tag in front of each line, which gives you the record type
> - the record will have several fields
> - different records will have different sets of fields
> - records are best represented by Common Lisp classes
Agreed (but that last one moved from below to above during the
rewriting of this post).
> - fields are best represented by Common Lisp object's slots
> - then you need a simple way to describe the layout the data and compute the
> class from this description
> - plus you need some mechanism to get from the record type the class
I have Keenes book and several examples, including nifty cells code
from Kenny which follows the above list nearly verbatim. In writing
this post and rethinking the problem, I get a glimmer of this CLOS
stuff, just as I did when I read Keene the first time. As an old
assembly hacker, I think I'm so used to writing all the boilerplate
that it is hard to step back from it to see the 'simpler'
approach...but I think I can learn to like CLOS.
Thanks!
GP lisper
>
>
> On Sat, 09 Jul 2005 08:55:19 +0200, <jos...@lisp.de> wrote:
>>
>> Parts of the development process are demonstrated in the video referenced
>> in the article. You might need some time to download it...
>
> If I get it downloaded (second attempt now), I'll rehost it (if you
> don't mind).
I think that the resource and data forks (if Macs still do such) are a
problem. I keep ending up with 125M transferred, but only a 7M file.
Rainer Joswig
GP lisper <spam...@CloudDancer.com> wrote:
The file has a size of 131323719 bytes. It transfers fine for me.
GP lisper
From mac to mac? Mac to PC linux? mac to win32? Remote or local?
Joerg Hoehle
> > SVCLHOHPE 10201DX0320050315........................
> What you can know from looking at the data is:
> - it is some text based format with one record per line
> - there is a tag in front of each line, which gives you the record type
> - the record will have several fields
> - different records will have different sets of fields
> - records are best represented by Common Lisp classes
> - fields are best represented by Common Lisp object's slots
This is a bogus conclusion. It doesn't logically follow from anything,
except maybe personal preference.
In one of several such applications, it would have been much to costly
to instanciate a new object for every line (hundreds of thousands, if
not millions of lines in plenty of files).
Instead, I had people write code like when using WITH SLOTS.
They wrote the (vitual) slot names they needed, and that got
transformed (via the DSL) into something like
(parse-integer huge-array :start start-of-that-column :end end-of-that-column)
or even
(let (slotx (parse-integer ...))
&body)
All the users need to know is the name SLOTX, which they declared
themselves via the DSL that describes each line. The rest was MACRO
and LAMBDA.
In the most recent such application, I made use of CLOS because it has
a nice declarative touch) for configuration only. At the time each
line is processed, nothing was using CLOS anymore. FUNCALL was it.
Regards,
Jorg Hohle
Telekom/T-Systems Technology Center
Rainer Joswig
Joerg Hoehle <hoe...@users.sourceforge.net> wrote:
> Rainer Joswig <jos...@lisp.de> writes:
> > > SVCLHOHPE 10201DX0320050315........................
> > What you can know from looking at the data is:
> > - it is some text based format with one record per line
> > - there is a tag in front of each line, which gives you the record type
> > - the record will have several fields
> > - different records will have different sets of fields
> Agree with all the above
>
> > - records are best represented by Common Lisp classes
> > - fields are best represented by Common Lisp object's slots
> This is a bogus conclusion. It doesn't logically follow from anything,
> except maybe personal preference.
No, if you really want to represent fields and records
(as opposed to use the line and just compute stuff) for
further processing, the usual other options would have
been lists, vectors and structures.
> In one of several such applications, it would have been much to costly
> to instanciate a new object for every line (hundreds of thousands, if
> not millions of lines in plenty of files).
Could be. If you still want to work (temporarily) with objects, there are
a few optimizations. CL-HTTP for example uses pools
(resources) of objects and lazy parsing for the slots.
My applications mostly have been just using pools.
facethe...@hotmail.com
> Pascal Costanza <p...@p-cos.net> writes:
>
> > ...and favorably so. See
> > http://martinfowler.com/articles/languageWorkbench.html
>
> I noticed that Tiobe ( http://www.tiobe.com/ )
> now rates Lisp as a `Mainstream Language' with an `A' rating.
>
http://www.itjobswatch.co.uk/default.aspx?page=2&sortby=0&orderby=0&jt=0&q=&id=900
The mainstream languages are on the other page :
1 SQL
2 Java
3 C++
4 VB
5 Perl
........
http://www.itjobswatch.co.uk/default.aspx?page=1&sortby=0&orderby=0&jt=0&q=&id=900
