Everyone knows how much I love Arc, I guess it has influenced my Lisp:
(deftoc |Reducing|
(category "Algebra I" "Fractions")
(genner
(easy
(w (n (rr 2 6))
(m/ n (* n (rr 2 9)))))
(avg
(dsb (n d cf)
(sort (rpu 3 (rr 2 9)) '<)
(m/ (* n cf) (* d cf))))
(hard
(dsb (n d cf)
(rpu 3 (rr 2 12))
(m/ (* n cf) (* d cf)))
(dsb (n1 n2 d1 d2)
(subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
(m/ (* n1 n2) (* d1 d2))))))
[The neat thing being one DSL within another DSL. (This Algebra
application just screams for DSLs because of the repeated coding of
different Algebraic transformations.)]
Btw, the "genner" clause hard-codes random problem generation.
Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
(deftoc add-real
(title "Adding")
(category "Algebra I" "Real Numbers")
(genner
(easy
(m+ (rp 2 (r+ 12)))
(m+ (rp 2 (r- 12)))
(eo (m+ 0 (r+ 12))
(m+ (r+ 12) 0))
(w (n (r+ 12))
(eo (m+ n (- n))
(m+ (- n) n))))
(avg
;; --- two approaches to same thing, without prolog..
(w (ns (rpu 2 (r+ 12)))
(eo (m+ (car ns) (- (cadr ns)))
(m+ (- (car ns)) (cadr ns))))
;; ---- ...and with prolog
(plogn
(generating ?x (fgen (random 12)))
(generating ?y (fgen (random 12)))
(lispp (/= ?x ?y))
(eo (m+ ?x (- ?y))
(m+ (- ?x) ?y))))
(hard
(plogn
(generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
(lispp (and (+? (ct-if '+? ?ns))
(+? (ct-if '-? ?ns))))
(m+ ?ns)))))
I highlighted above a for-the-fun-of-it with/without Prolog pair,
fascinating that the prolog variant is so much easier to code and so
much more verbose. Usually goes the other way.
Anyway, looking ahead I can almost guarantee the prolog approach will
win out -- I have been through this before. In C. Twenty years ago. I
haven't forgotten the agony of enforcing constraints in procedural code.
Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
erecting version 1.0 of a random problem generation framework in an easy
day. Noobs, as much as you dig Lisp, have no idea how much fun it will
be three years in when it disappears and you can Just Build Apps.
kenny
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
"I've never read the rulebook. My job is to catch the ball."
-- Catcher Josh Bard after making a great catch on a foul ball
and then sliding into the dugout, which by the rules allowed the
runners to advance one base costing his pitcher a possible shutout
because there was a runner on third base.
"My sig is longer than most of my articles."
-- Kenny Tilton
P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
<···········@optonline.net>:
> Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> (deftoc |Reducing|
> (category "Algebra I" "Fractions")
> (genner
> (easy
> (w (n (rr 2 6))
> (m/ n (* n (rr 2 9)))))
> (avg
> (dsb (n d cf)
> (sort (rpu 3 (rr 2 9)) '<)
> (m/ (* n cf) (* d cf))))
> (hard
> (dsb (n d cf)
> (rpu 3 (rr 2 12))
> (m/ (* n cf) (* d cf)))
> (dsb (n1 n2 d1 d2)
> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> (m/ (* n1 n2) (* d1 d2))))))
>
> [The neat thing being one DSL within another DSL. (This Algebra
> application just screams for DSLs because of the repeated coding of
> different Algebraic transformations.)]
>
> Btw, the "genner" clause hard-codes random problem generation.
>
> Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> (deftoc add-real
> (title "Adding")
> (category "Algebra I" "Real Numbers")
> (genner
> (easy
> (m+ (rp 2 (r+ 12)))
> (m+ (rp 2 (r- 12)))
> (eo (m+ 0 (r+ 12))
> (m+ (r+ 12) 0))
> (w (n (r+ 12))
> (eo (m+ n (- n))
> (m+ (- n) n))))
> (avg
> ;; --- two approaches to same thing, without prolog..
> (w (ns (rpu 2 (r+ 12)))
> (eo (m+ (car ns) (- (cadr ns)))
> (m+ (- (car ns)) (cadr ns))))
> ;; ---- ...and with prolog
> (plogn
> (generating ?x (fgen (random 12)))
> (generating ?y (fgen (random 12)))
> (lispp (/= ?x ?y))
> (eo (m+ ?x (- ?y))
> (m+ (- ?x) ?y))))
> (hard
> (plogn
> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> (lispp (and (+? (ct-if '+? ?ns))
> (+? (ct-if '-? ?ns))))
> (m+ ?ns)))))
>
> I highlighted above a for-the-fun-of-it with/without Prolog pair,
> fascinating that the prolog variant is so much easier to code and so
> much more verbose. Usually goes the other way.
>
> Anyway, looking ahead I can almost guarantee the prolog approach will
> win out -- I have been through this before. In C. Twenty years ago. I
> haven't forgotten the agony of enforcing constraints in procedural code.
>
> Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> erecting version 1.0 of a random problem generation framework in an easy
> day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> be three years in when it disappears and you can Just Build Apps.
>
> kenny
>
Just in case I am not on your "kill" list. I have sided with Pascal in
that full words are better.
It might not matter much to you, but it matters to anyone else trying to
read you code. And their incentive to try in the first place. Tried the
abbrev thing and found a million ways to abbreviate a word. In the end
just a waste of time trying to figure out which one was used.
That's my two bits.
--------------
John Thingstad
From: Kent M Pitman
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <uhcdg7qpv.fsf@nhplace.com>
"John Thingstad" <·······@online.no> writes:
> På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> <···········@optonline.net>:
>
> > Everyone knows how much I love Arc, I guess it has influenced my Lisp:
> >
> > (deftoc |Reducing|
> > (category "Algebra I" "Fractions")
> > (genner
> > (easy
> > (w (n (rr 2 6))
> > (m/ n (* n (rr 2 9)))))
> > [...]
> > ))
> Just in case I am not on your "kill" list. I have sided with Pascal in
> that full words are better.
Others are reading, too.
> It might not matter much to you, but it matters to anyone else trying
> to read you code.
Indeed, I can't tell if Kenny is being tongue-in-cheek or for real.
I enjoy Kenny's provocative posts but
[ http://en.wikipedia.org/wiki/The_Boy_Who_Cried_Wolf ]
> And their incentive to try in the first place.
That code example certainly hasn't turned me around.
> Tried the abbrev thing and found a million ways to abbreviate
> a word. In the end just a waste of time trying to figure out which
> one was used.
> That's my two bits.
Thanks. Saved me the trouble, since I was thinking similarly but hadn't
the patience to write anything.
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481b391b$0$11631$607ed4bc@cv.net>
John Thingstad wrote:
> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> <···········@optonline.net>:
>
>> Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>>
>> (deftoc |Reducing|
>> (category "Algebra I" "Fractions")
>> (genner
>> (easy
>> (w (n (rr 2 6))
>> (m/ n (* n (rr 2 9)))))
>> (avg
>> (dsb (n d cf)
>> (sort (rpu 3 (rr 2 9)) '<)
>> (m/ (* n cf) (* d cf))))
>> (hard
>> (dsb (n d cf)
>> (rpu 3 (rr 2 12))
>> (m/ (* n cf) (* d cf)))
>> (dsb (n1 n2 d1 d2)
>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
>> (m/ (* n1 n2) (* d1 d2))))))
>>
>> [The neat thing being one DSL within another DSL. (This Algebra
>> application just screams for DSLs because of the repeated coding of
>> different Algebraic transformations.)]
>>
>> Btw, the "genner" clause hard-codes random problem generation.
>>
>> Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>>
>> (deftoc add-real
>> (title "Adding")
>> (category "Algebra I" "Real Numbers")
>> (genner
>> (easy
>> (m+ (rp 2 (r+ 12)))
>> (m+ (rp 2 (r- 12)))
>> (eo (m+ 0 (r+ 12))
>> (m+ (r+ 12) 0))
>> (w (n (r+ 12))
>> (eo (m+ n (- n))
>> (m+ (- n) n))))
>> (avg
>> ;; --- two approaches to same thing, without prolog..
>> (w (ns (rpu 2 (r+ 12)))
>> (eo (m+ (car ns) (- (cadr ns)))
>> (m+ (- (car ns)) (cadr ns))))
>> ;; ---- ...and with prolog
>> (plogn
>> (generating ?x (fgen (random 12)))
>> (generating ?y (fgen (random 12)))
>> (lispp (/= ?x ?y))
>> (eo (m+ ?x (- ?y))
>> (m+ (- ?x) ?y))))
>> (hard
>> (plogn
>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
>> (lispp (and (+? (ct-if '+? ?ns))
>> (+? (ct-if '-? ?ns))))
>> (m+ ?ns)))))
>>
>> I highlighted above a for-the-fun-of-it with/without Prolog pair,
>> fascinating that the prolog variant is so much easier to code and so
>> much more verbose. Usually goes the other way.
>>
>> Anyway, looking ahead I can almost guarantee the prolog approach will
>> win out -- I have been through this before. In C. Twenty years ago. I
>> haven't forgotten the agony of enforcing constraints in procedural code.
>>
>> Meanwhile, what a pleasure to be doing /applications/ again with
>> Lisp, erecting version 1.0 of a random problem generation framework
>> in an easy day. Noobs, as much as you dig Lisp, have no idea how much
>> fun it will be three years in when it disappears and you can Just
>> Build Apps.
>>
>> kenny
>>
>
> Just in case I am not on your "kill" list. I have sided with Pascal in
> that full words are better.
You both are (in my killfile and wrong).
> It might not matter much to you, but it matters to anyone else trying
> to read you code.
Your understanding is too superficial for you to be allowed an opinion.
Like I said, I have done this before. There is an ocean of this stuff to
churn out, and certain things like eo ("either-or") and rr
("random-value-in-range") will occur dozens of times, meaning reading
them will be easy to the author (the only one who matters, but also
anyone who has looked at the API for five minutes) and unabbreviated we
end up with the things that /are/ different from use to use and needs to
be debugged/refined disappearing like needles in a haystack of spelled
out versions.
Why must I explain this to people who use macros to hide boilerplate?
> And their incentive to try in the first place. Tried
> the abbrev thing and found a million ways to abbreviate a word.
No wonder you had trouble -- you were supposed to pick one abbreviation
per word.
> In the
> end just a waste of time trying to figure out which one was used.
> That's my two bits.
Can I ' you on that?
kt
ps. Tilton's Laws of Abbreviation:
- the abbreviated term must be at least seven characters long
- the abbreviation must be no more than half the length of the abbreviated
- the abbreviation must always be used
k
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
P� Fri, 02 May 2008 17:54:02 +0200, skrev Ken Tilton
<···········@optonline.net>:
>
>
> John Thingstad wrote:
>> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> ps. Tilton's Laws of Abbreviation:
>
> - the abbreviated term must be at least seven characters long
> - the abbreviation must be no more than half the length of the
> abbreviated
> - the abbreviation must always be used
>
> k
>
like m+ ?
--------------
John Thingstad
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481b9529$0$15167$607ed4bc@cv.net>
John Thingstad wrote:
> P� Fri, 02 May 2008 17:54:02 +0200, skrev Ken Tilton
> <···········@optonline.net>:
>
>>
>>
>> John Thingstad wrote:
>>
>>> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>
>
>> ps. Tilton's Laws of Abbreviation:
>>
>> - the abbreviated term must be at least seven characters long
>> - the abbreviation must be no more than half the length of the
>> abbreviated
>> - the abbreviation must always be used
>>
>> k
>>
>
> like m+ ?
That is short for (mx-gen #\+ <rest being operands>), as in "make an
addition". I will let you forget out what m- m/ m* and the rest do, and
then figure out that when writing 250 generators it won't be very hard
to remember an API with a dozen commonly used forms falling into just a
few groups.
<sigh> You people really don't program all that much, do you? Too bad,
you don't know what you are missing.
kenny
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481bb4ab$0$25039$607ed4bc@cv.net>
Ken Tilton wrote:
>
>
> John Thingstad wrote:
>
>> P� Fri, 02 May 2008 17:54:02 +0200, skrev Ken Tilton
>> <···········@optonline.net>:
>>
>>>
>>>
>>> John Thingstad wrote:
>>>
>>>> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>>
>>
>>
>>> ps. Tilton's Laws of Abbreviation:
>>>
>>> - the abbreviated term must be at least seven characters long
>>> - the abbreviation must be no more than half the length of the
>>> abbreviated
>>> - the abbreviation must always be used
>>>
>>> k
>>>
>>
>> like m+ ?
>
>
> That is short for (mx-gen #\+ <rest being operands>), as in "make an
> addition". I will let you forget out what m- m/ m* and the rest do...
Pop quiz: How would you generate an absolute value such as |-42|?
If you (or your buddy) know, you (and your buddy) lose.
I love this game!
kenny
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
I think judicious use of abbreviations can lead to more maintainable
code. For example, CL-WHO's HTM, STR and ESC abbreviations are
incredibly
useful because you have them all over the place.
If I had ESCAPE-STRING all over my code it would be a distracting
mess.
But those are just a few well-defined abbreviations and they can only
occur
within the limited scope of the HTML output macro. Is it the same with
GENNER here?
In the OP's second example, why is GENNER abbreviated (occurs once in
a
prominent location), but not TITLE and CATEGORY (occur once in a
prominent location)?
Leslie
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481c4fbc$0$25027$607ed4bc@cv.net>
Leslie P. Polzer wrote:
> I think judicious use of abbreviations can lead to more maintainable
> code. For example, CL-WHO's HTM, STR and ESC abbreviations are
> incredibly
> useful because you have them all over the place.
> If I had ESCAPE-STRING all over my code it would be a distracting
> mess.
>
> But those are just a few well-defined abbreviations and they can only
> occur
> within the limited scope of the HTML output macro. Is it the same with
> GENNER here?
Yep. In fact, at first the little guys were all flets and macrolets but
that made debugging harder when I was still developing them. They could
go back now.
>
> In the OP's second example, why is GENNER abbreviated (occurs once in
> a
> prominent location), but not TITLE and CATEGORY (occur once in a
> prominent location)?
Haha, historical: at first I had "seeds" which got cloned, but that was
killing me and I really need to ship, so I changed to seeder (since I
was now specifying functions to create problems) but then I realized
(duh) they were not seeds any more so the name should be... then i could
not think of a good name (really the main reason) and decided enough
already, stop with the hairsplitting and get on with the software, these
bits generate random problems, hello "genner"!
ie, to a certain extent I am trying to break the perfection habit by
bending over backwards not to sweat inconsequential things...
Maybe "random-generator"? "Problem-factory"? Just "factory" might not be
bad...
:)
Meanwhile:
(deftoc subt-real
(title "Subtracting")
(category "Algebra I" "Real Numbers")
(genner
(easy
(w (x (rr 6 (r+ 20)))
(m- x (rr 2 x)))
(w (x (rr 6 (r+ 20)))
(m- (- x) (rr 2 x)))
(w (x (rr 6 (r+ 20)))
(m- x (- (rr 2 x))))
(w (x (rr 6 (r+ 20)))
(m- (- x) (- (rr 2 x)))))))
The punch line is that by now everyone can read the above and predict
the problems produced. :)
kt
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481d1046$0$11604$607ed4bc@cv.net>
Ken Tilton wrote:
>
>
> Leslie P. Polzer wrote:
>
>> I think judicious use of abbreviations can lead to more maintainable
>> code. For example, CL-WHO's HTM, STR and ESC abbreviations are
>> incredibly
>> useful because you have them all over the place.
>> If I had ESCAPE-STRING all over my code it would be a distracting
>> mess.
>>
>> But those are just a few well-defined abbreviations and they can only
>> occur
>> within the limited scope of the HTML output macro. Is it the same with
>> GENNER here?
>
>
> Yep. In fact, at first the little guys were all flets and macrolets but
> that made debugging harder when I was still developing them. They could
> go back now.
>
>>
>> In the OP's second example, why is GENNER abbreviated (occurs once in
>> a
>> prominent location), but not TITLE and CATEGORY (occur once in a
>> prominent location)?
>
>
> Haha, historical: at first I had "seeds" which got cloned, but that was
> killing me and I really need to ship, so I changed to seeder (since I
> was now specifying functions to create problems) but then I realized
> (duh) they were not seeds any more so the name should be... then i could
> not think of a good name (really the main reason) and decided enough
> already, stop with the hairsplitting and get on with the software, these
> bits generate random problems, hello "genner"!
>
> ie, to a certain extent I am trying to break the perfection habit by
> bending over backwards not to sweat inconsequential things...
>
> Maybe "random-generator"? "Problem-factory"? Just "factory" might not be
> bad...
>
> :)
>
> Meanwhile:
>
> (deftoc subt-real
> (title "Subtracting")
> (category "Algebra I" "Real Numbers")
> (genner
> (easy
> (w (x (rr 6 (r+ 20)))
Ooops! I am big enough to confess: that should be (rr 6 20), not (rr 6
(r+ 20)), which is clearly nonsense. (Well, somewhat retracting the
confession, it jumped right out at me when reviewing the code, I did not
have to debug it or anything. Anyway, what happened was I cloned an rp
form, mistaking it for rr!
Hmmm. rp is "repeat". Maybe I should go verbose and make it "rpt"?
I'd go with "rep", but I believe the Finnish army has that reserved for
/fast/-moving barges.
kenny
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
On Fri, 02 May 2008 18:26:11 -0400, <···········@optonline.net> wrote:
><sigh> You people really don't program all that much, do you? Too bad,
> you don't know what you are missing.
Guilty as charged. ;-)
Since I use lisp, I don't need to spend lots of time coding.
I don't need 100k lines-of-code. It's summertime soon, so instead of
'programming' I can watch the ladies working on this summers tan,
while chuckling about those nose-to-the-grindstone programmers.
Well, you've done such a good job that I won't even bother to remember
that Arc even exists. Since I don't program alot, I'll never remember
abbr and thus I enjoy long-names-with-any-chars-for-stuff now.
--
One of the strokes of genius from McCarthy
was making lists the center of the language - kt
** Posted from http://www.teranews.com **
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481c4ba6$0$25026$607ed4bc@cv.net>
GP lisper wrote:
> On Fri, 02 May 2008 18:26:11 -0400, <···········@optonline.net> wrote:
>
>><sigh> You people really don't program all that much, do you? Too bad,
>>you don't know what you are missing.
>
>
> Guilty as charged. ;-)
Oh, no! Cells loses a user! Under five now, I think...
>
> Since I use lisp, I don't need to spend lots of time coding.
More time for Freecell!
>
> I don't need 100k lines-of-code. It's summertime soon, so instead of
> 'programming' I can watch the ladies working on this summers tan,
You saw my video!
> while chuckling about those nose-to-the-grindstone programmers.
>
> Well, you've done such a good job that I won't even bother to remember
> that Arc even exists.
I was going to agree, but I guess it ain't over till it's over:
http://www.paulgraham.com/newthings.html
> Since I don't program alot, I'll never remember
> abbr and thus I enjoy long-names-with-any-chars-for-stuff now.
>
Reminds me. I still have to write up the "aa, bb, cc, and dd" war story
on meaningful datanames... a /classic/ case for good names. But then
that leaves moot the question of whether short is always bad.
Rinse. Repeat.
kt
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
On Sat, 03 May 2008 07:25:26 -0400, <···········@optonline.net> wrote:
> GP lisper wrote:
>> On Fri, 02 May 2008 18:26:11 -0400, <···········@optonline.net> wrote:
>>
>>><sigh> You people really don't program all that much, do you? Too bad,
>>>you don't know what you are missing.
>>
>> Guilty as charged. ;-)
>
> Oh, no! Cells loses a user! Under five now, I think...
Hey, I like driving Ferraris...so going back to a horse is out of the
question.
>> Since I use lisp, I don't need to spend lots of time coding.
>
> More time for Freecell!
Freecell is for tots, Spider is the game!
I run lisp code at least 10x as often as I improve it, looks like a
few Megs of compiled lisp (on linux, that doesn't include the image)
every day.
--
One of the strokes of genius from McCarthy
was making lists the center of the language - kt
** Posted from http://www.teranews.com **
P� Sat, 03 May 2008 00:26:11 +0200, skrev Ken Tilton
<···········@optonline.net>:
>
>
> John Thingstad wrote:
>> P� Fri, 02 May 2008 17:54:02 +0200, skrev Ken Tilton
>> <···········@optonline.net>:
>>
>>>
>>>
>>> John Thingstad wrote:
>>>
>>>> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>>
>>> ps. Tilton's Laws of Abbreviation:
>>>
>>> - the abbreviated term must be at least seven characters long
>>> - the abbreviation must be no more than half the length of the
>>> abbreviated
>>> - the abbreviation must always be used
>>>
>>> k
>>>
>> like m+ ?
>
> That is short for (mx-gen #\+ <rest being operands>), as in "make an
> addition". I will let you forget out what m- m/ m* and the rest do, and
> then figure out that when writing 250 generators it won't be very hard
> to remember an API with a dozen commonly used forms falling into just a
> few groups.
>
> <sigh> You people really don't program all that much, do you? Too bad,
> you don't know what you are missing.
>
> kenny
>
Oh.. I code. I just use fuzzy completion a lot :)
--------------
John Thingstad
From: =?ISO-8859-15?Q?Pertti_Kellom=E4ki?=
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <fvetf4$vkq$1@news.cc.tut.fi>
John Thingstad wrote:
> Tried the
> abbrev thing and found a million ways to abbreviate a word. In the end
> just a waste of time trying to figure out which one was used.
The Finnish Army field manual states that words can be abbreviated
at the beginning, at the end, in the middle, or in a mixed mode
of the three.
My favorite abbreviation in the book was "rhikkma", which
stands for "ruuhikalustokuorma", which in translation means
a bunch of barges being transported somewhere. Maybe it is my
general inadeptness in all things military, but I never saw the
need for that particular abbreviation in the first place...
--
Pertti
On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
> På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> <···········@optonline.net>:
>
>
>
> > Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> > (deftoc |Reducing|
> > (category "Algebra I" "Fractions")
> > (genner
> > (easy
> > (w (n (rr 2 6))
> > (m/ n (* n (rr 2 9)))))
> > (avg
> > (dsb (n d cf)
> > (sort (rpu 3 (rr 2 9)) '<)
> > (m/ (* n cf) (* d cf))))
> > (hard
> > (dsb (n d cf)
> > (rpu 3 (rr 2 12))
> > (m/ (* n cf) (* d cf)))
> > (dsb (n1 n2 d1 d2)
> > (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> > (m/ (* n1 n2) (* d1 d2))))))
>
> > [The neat thing being one DSL within another DSL. (This Algebra
> > application just screams for DSLs because of the repeated coding of
> > different Algebraic transformations.)]
>
> > Btw, the "genner" clause hard-codes random problem generation.
>
> > Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> > (deftoc add-real
> > (title "Adding")
> > (category "Algebra I" "Real Numbers")
> > (genner
> > (easy
> > (m+ (rp 2 (r+ 12)))
> > (m+ (rp 2 (r- 12)))
> > (eo (m+ 0 (r+ 12))
> > (m+ (r+ 12) 0))
> > (w (n (r+ 12))
> > (eo (m+ n (- n))
> > (m+ (- n) n))))
> > (avg
> > ;; --- two approaches to same thing, without prolog..
> > (w (ns (rpu 2 (r+ 12)))
> > (eo (m+ (car ns) (- (cadr ns)))
> > (m+ (- (car ns)) (cadr ns))))
> > ;; ---- ...and with prolog
> > (plogn
> > (generating ?x (fgen (random 12)))
> > (generating ?y (fgen (random 12)))
> > (lispp (/= ?x ?y))
> > (eo (m+ ?x (- ?y))
> > (m+ (- ?x) ?y))))
> > (hard
> > (plogn
> > (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> > (lispp (and (+? (ct-if '+? ?ns))
> > (+? (ct-if '-? ?ns))))
> > (m+ ?ns)))))
>
> > I highlighted above a for-the-fun-of-it with/without Prolog pair,
> > fascinating that the prolog variant is so much easier to code and so
> > much more verbose. Usually goes the other way.
>
> > Anyway, looking ahead I can almost guarantee the prolog approach will
> > win out -- I have been through this before. In C. Twenty years ago. I
> > haven't forgotten the agony of enforcing constraints in procedural code.
>
> > Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> > erecting version 1.0 of a random problem generation framework in an easy
> > day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> > be three years in when it disappears and you can Just Build Apps.
>
> > kenny
>
> Just in case I am not on your "kill" list. I have sided with Pascal in
> that full words are better.
I vote for full words , though look at a dictionary and try to find
shortest synonym.
Very-long-and-descriptive-names sucks. But code that looks like a
three-year-old with a particular fondness for periods and colons was
set before the keyboard. ( http://www.jsoftware.com/help/jforc/contents.htm)
My favourite article about Snctns isnt Pwr
http://home.comcast.net/~dness/notes/succinct.html
and something about readibility that I find very useful.
http://www.5jt.com/articles/Three%20Principles%20of%20Coding%20Clarity.doc
so no I'm not willing to sell my soul for few characters less.
> It might not matter much to you, but it matters to anyone else trying to
> read you code. And their incentive to try in the first place. Tried the
> abbrev thing and found a million ways to abbreviate a word. In the end
> just a waste of time trying to figure out which one was used.
> That's my two bits.
>
> --------------
> John Thingstad
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481d1c50$0$25021$607ed4bc@cv.net>
Slobodan Blazeski wrote:
> On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>
>>P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>><···········@optonline.net>:
>>
>>
>>
>>
>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>>
>>>(deftoc |Reducing|
>>> (category "Algebra I" "Fractions")
>>> (genner
>>> (easy
>>> (w (n (rr 2 6))
>>> (m/ n (* n (rr 2 9)))))
>>> (avg
>>> (dsb (n d cf)
>>> (sort (rpu 3 (rr 2 9)) '<)
>>> (m/ (* n cf) (* d cf))))
>>> (hard
>>> (dsb (n d cf)
>>> (rpu 3 (rr 2 12))
>>> (m/ (* n cf) (* d cf)))
>>> (dsb (n1 n2 d1 d2)
>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
>>> (m/ (* n1 n2) (* d1 d2))))))
>>
>>>[The neat thing being one DSL within another DSL. (This Algebra
>>>application just screams for DSLs because of the repeated coding of
>>>different Algebraic transformations.)]
>>
>>>Btw, the "genner" clause hard-codes random problem generation.
>>
>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>>
>>>(deftoc add-real
>>> (title "Adding")
>>> (category "Algebra I" "Real Numbers")
>>> (genner
>>> (easy
>>> (m+ (rp 2 (r+ 12)))
>>> (m+ (rp 2 (r- 12)))
>>> (eo (m+ 0 (r+ 12))
>>> (m+ (r+ 12) 0))
>>> (w (n (r+ 12))
>>> (eo (m+ n (- n))
>>> (m+ (- n) n))))
>>> (avg
>>> ;; --- two approaches to same thing, without prolog..
>>> (w (ns (rpu 2 (r+ 12)))
>>> (eo (m+ (car ns) (- (cadr ns)))
>>> (m+ (- (car ns)) (cadr ns))))
>>> ;; ---- ...and with prolog
>>> (plogn
>>> (generating ?x (fgen (random 12)))
>>> (generating ?y (fgen (random 12)))
>>> (lispp (/= ?x ?y))
>>> (eo (m+ ?x (- ?y))
>>> (m+ (- ?x) ?y))))
>>> (hard
>>> (plogn
>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
>>> (lispp (and (+? (ct-if '+? ?ns))
>>> (+? (ct-if '-? ?ns))))
>>> (m+ ?ns)))))
>>
>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
>>>fascinating that the prolog variant is so much easier to code and so
>>>much more verbose. Usually goes the other way.
>>
>>>Anyway, looking ahead I can almost guarantee the prolog approach will
>>>win out -- I have been through this before. In C. Twenty years ago. I
>>>haven't forgotten the agony of enforcing constraints in procedural code.
>>
>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
>>>erecting version 1.0 of a random problem generation framework in an easy
>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
>>>be three years in when it disappears and you can Just Build Apps.
>>
>>>kenny
>>
>>Just in case I am not on your "kill" list. I have sided with Pascal in
>>that full words are better.
>
> I vote for full words , though look at a dictionary and try to find
> shortest synonym.
> Very-long-and-descriptive-names sucks. But code that looks like a
> three-year-old with a particular fondness for periods and colons was
> set before the keyboard. ( http://www.jsoftware.com/help/jforc/contents.htm)
This is very disappointing.
We already have on the table Tilton's Law of Abbreviation, signifying my
concurrence with the general rule, and I have gone to the trouble of
pointing out why this situation is exceptional, yet not not one of you
has said one word addressing the validity of the exception, which is the
only issue on the table given my concurrence with the general rule.
The earnest dullard can follow rules, the craftsman knows when they do
not apply. This is the thing we cannot teach, to expert systems or even
good students. It requires a meta-understanding of the rule, an
understanding of from where the rule came and then whether the
circumstances at hand come from the same place.
And what do I hear from You People? A cast in concrete knee-jerk rote
repeating snap-saluting line-toeing mindless recitation of something you
read in chapter 3 of a programming proverbs book.
Super. You got 5 points from your teacher who was looking for The One
Right Answer and you just flunked out of the U. of Kenny.
kenny
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481d2add$0$15172$607ed4bc@cv.net>
Ken Tilton wrote:
>
>
> Slobodan Blazeski wrote:
>
>> On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>>
>>> P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>>> <···········@optonline.net>:
>>>
>>>
>>>
>>>
>>>> Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>>>
>>>
>>>> (deftoc |Reducing|
>>>> (category "Algebra I" "Fractions")
>>>> (genner
>>>> (easy
>>>> (w (n (rr 2 6))
>>>> (m/ n (* n (rr 2 9)))))
>>>> (avg
>>>> (dsb (n d cf)
>>>> (sort (rpu 3 (rr 2 9)) '<)
>>>> (m/ (* n cf) (* d cf))))
>>>> (hard
>>>> (dsb (n d cf)
>>>> (rpu 3 (rr 2 12))
>>>> (m/ (* n cf) (* d cf)))
>>>> (dsb (n1 n2 d1 d2)
>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
>>>> (m/ (* n1 n2) (* d1 d2))))))
>>>
>>>
>>>> [The neat thing being one DSL within another DSL. (This Algebra
>>>> application just screams for DSLs because of the repeated coding of
>>>> different Algebraic transformations.)]
>>>
>>>
>>>> Btw, the "genner" clause hard-codes random problem generation.
>>>
>>>
>>>> Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>>>
>>>
>>>> (deftoc add-real
>>>> (title "Adding")
>>>> (category "Algebra I" "Real Numbers")
>>>> (genner
>>>> (easy
>>>> (m+ (rp 2 (r+ 12)))
>>>> (m+ (rp 2 (r- 12)))
>>>> (eo (m+ 0 (r+ 12))
>>>> (m+ (r+ 12) 0))
>>>> (w (n (r+ 12))
>>>> (eo (m+ n (- n))
>>>> (m+ (- n) n))))
>>>> (avg
>>>> ;; --- two approaches to same thing, without prolog..
>>>> (w (ns (rpu 2 (r+ 12)))
>>>> (eo (m+ (car ns) (- (cadr ns)))
>>>> (m+ (- (car ns)) (cadr ns))))
>>>> ;; ---- ...and with prolog
>>>> (plogn
>>>> (generating ?x (fgen (random 12)))
>>>> (generating ?y (fgen (random 12)))
>>>> (lispp (/= ?x ?y))
>>>> (eo (m+ ?x (- ?y))
>>>> (m+ (- ?x) ?y))))
>>>> (hard
>>>> (plogn
>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
>>>> (lispp (and (+? (ct-if '+? ?ns))
>>>> (+? (ct-if '-? ?ns))))
>>>> (m+ ?ns)))))
>>>
>>>
>>>> I highlighted above a for-the-fun-of-it with/without Prolog pair,
>>>> fascinating that the prolog variant is so much easier to code and so
>>>> much more verbose. Usually goes the other way.
>>>
>>>
>>>> Anyway, looking ahead I can almost guarantee the prolog approach will
>>>> win out -- I have been through this before. In C. Twenty years ago. I
>>>> haven't forgotten the agony of enforcing constraints in procedural
>>>> code.
>>>
>>>
>>>> Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
>>>> erecting version 1.0 of a random problem generation framework in an
>>>> easy
>>>> day. Noobs, as much as you dig Lisp, have no idea how much fun it will
>>>> be three years in when it disappears and you can Just Build Apps.
>>>
>>>
>>>> kenny
>>>
>>>
>>> Just in case I am not on your "kill" list. I have sided with Pascal in
>>> that full words are better.
>>
>>
>> I vote for full words , though look at a dictionary and try to find
>> shortest synonym.
>> Very-long-and-descriptive-names sucks. But code that looks like a
>> three-year-old with a particular fondness for periods and colons was
>> set before the keyboard. (
>> http://www.jsoftware.com/help/jforc/contents.htm)
>
>
> This is very disappointing.
>
> We already have on the table Tilton's Law of Abbreviation, signifying my
> concurrence with the general rule, and I have gone to the trouble of
> pointing out why this situation is exceptional, yet not not one of you
> has said one word addressing the validity of the exception, which is the
> only issue on the table given my concurrence with the general rule.
>
> The earnest dullard can follow rules, the craftsman knows when they do
> not apply. This is the thing we cannot teach, to expert systems or even
> good students. It requires a meta-understanding of the rule, an
> understanding of from where the rule came and then whether the
> circumstances at hand come from the same place.
>
> And what do I hear from You People? A cast in concrete knee-jerk rote
> repeating snap-saluting line-toeing mindless recitation of something you
> read in chapter 3 of a programming proverbs book.
>
> Super. You got 5 points from your teacher who was looking for The One
> Right Answer and you just flunked out of the U. of Kenny.
>
And you now have to code:
(mx-generate #\-
(mx-generate #\*
(random-in-range 2 9)
(random-in-range 2 9))
(random-in-range 2 9))
...instead of:
(m- (m* (rr 2 9)(rr 2 9))
(rr 2 9)))
Approximately three hundred fifty times. I would have typed "350" but...
kenny
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481df977$0$11630$607ed4bc@cv.net>
Ah, a child of three can see where this is headed, given that math
notation is so much better for math (surprise!):
(deftoc order-of-op
(category "Algebra I" "Real Numbers")
(title "Order of Operations")
(factory
#+wait
(easy
(m+- (m* (rr 2 9)(rr 2 9))(rr 2 9))
(m+- (rr 2 9)(m* (rr 2 9)(rr 2 9)))
(m+ (rr 2 9)(m^ (rr 2 5)(rr 2 3)))
(m- (m^ (rr 2 5)(rr 2 3))(rr 2 9))
(m* (rr 2 9)(mp (m- (rr 2 9)(rr 2 9))))
(m* (mp (m+ (rr 2 9)(rr 2 9)))(rr 2 9)))
(avg
(m+- (m^ (rr 2 5)(rr 2 3))(m^ (rr 2 5)(rr 2 3)))
(m^ (m+- (rr 2 12)(rr 1 8))(rr 2 3))
(m+- (r+- 1 12) (m* (rr 2 12)(rr 2 12)) (r+- 1 12))
(let* ((f (rr 2 5))
(v (rpu 2 (rr 2 9))))
(m/ (* (car v) (r+- 2 5))
(mp (m+ (sp+ (* (car v) f)))))
)
(m� (let ((n (rr 2 10))
(cf (rr 2 12)))
(list (m+ (sp+ (* n cf)))
(m+ (sp+ cf)))))
(m+- (m� (let ((n (rr 2 10))
(cf (rr 2 12)))
(list (m+ (sp+ (* n cf)))
(m+ (sp+ cf)))))
(rr 2 20))
)
How about an encoded string?
"j=r2-12,k=j*r2-12:(k%+2)�(j%+2)�r2-12"
Instead of:
(m+- (m� (let ((n (rr 2 10))
(cf (rr 2 12)))
(list (m+ (sp+ (* n cf)))
(m+ (sp+ cf)))))
(rr 2 20))
Instead of -- well, some of you don't have broadband... :)
Anyway, perhaps now it is clear why you all are arguing with the K
crowd, not The Kenny.
Himself (holding off on the nifty string thingy until done with order of
operations examples which happen to be unusually big expression-wise and
might be the only place they make a difference)
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
> Slobodan Blazeski wrote:
> > On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>
> >>På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> >><···········@optonline.net>:
>
> >>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> >>>(deftoc |Reducing|
> >>> (category "Algebra I" "Fractions")
> >>> (genner
> >>> (easy
> >>> (w (n (rr 2 6))
> >>> (m/ n (* n (rr 2 9)))))
> >>> (avg
> >>> (dsb (n d cf)
> >>> (sort (rpu 3 (rr 2 9)) '<)
> >>> (m/ (* n cf) (* d cf))))
> >>> (hard
> >>> (dsb (n d cf)
> >>> (rpu 3 (rr 2 12))
> >>> (m/ (* n cf) (* d cf)))
> >>> (dsb (n1 n2 d1 d2)
> >>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> >>> (m/ (* n1 n2) (* d1 d2))))))
>
> >>>[The neat thing being one DSL within another DSL. (This Algebra
> >>>application just screams for DSLs because of the repeated coding of
> >>>different Algebraic transformations.)]
>
> >>>Btw, the "genner" clause hard-codes random problem generation.
>
> >>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> >>>(deftoc add-real
> >>> (title "Adding")
> >>> (category "Algebra I" "Real Numbers")
> >>> (genner
> >>> (easy
> >>> (m+ (rp 2 (r+ 12)))
> >>> (m+ (rp 2 (r- 12)))
> >>> (eo (m+ 0 (r+ 12))
> >>> (m+ (r+ 12) 0))
> >>> (w (n (r+ 12))
> >>> (eo (m+ n (- n))
> >>> (m+ (- n) n))))
> >>> (avg
> >>> ;; --- two approaches to same thing, without prolog..
> >>> (w (ns (rpu 2 (r+ 12)))
> >>> (eo (m+ (car ns) (- (cadr ns)))
> >>> (m+ (- (car ns)) (cadr ns))))
> >>> ;; ---- ...and with prolog
> >>> (plogn
> >>> (generating ?x (fgen (random 12)))
> >>> (generating ?y (fgen (random 12)))
> >>> (lispp (/= ?x ?y))
> >>> (eo (m+ ?x (- ?y))
> >>> (m+ (- ?x) ?y))))
> >>> (hard
> >>> (plogn
> >>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> >>> (lispp (and (+? (ct-if '+? ?ns))
> >>> (+? (ct-if '-? ?ns))))
> >>> (m+ ?ns)))))
>
> >>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
> >>>fascinating that the prolog variant is so much easier to code and so
> >>>much more verbose. Usually goes the other way.
>
> >>>Anyway, looking ahead I can almost guarantee the prolog approach will
> >>>win out -- I have been through this before. In C. Twenty years ago. I
> >>>haven't forgotten the agony of enforcing constraints in procedural code.
>
> >>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> >>>erecting version 1.0 of a random problem generation framework in an easy
> >>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> >>>be three years in when it disappears and you can Just Build Apps.
>
> >>>kenny
>
> >>Just in case I am not on your "kill" list. I have sided with Pascal in
> >>that full words are better.
>
> > I vote for full words , though look at a dictionary and try to find
> > shortest synonym.
> > Very-long-and-descriptive-names sucks. But code that looks like a
> > three-year-old with a particular fondness for periods and colons was
> > set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>
> This is very disappointing.
>
> We already have on the table Tilton's Law of Abbreviation, signifying my
> concurrence with the general rule, and I have gone to the trouble of
> pointing out why this situation is exceptional, yet not not one of you
> has said one word addressing the validity of the exception, which is the
> only issue on the table given my concurrence with the general rule.
>
> The earnest dullard can follow rules, the craftsman knows when they do
> not apply. This is the thing we cannot teach, to expert systems or even
> good students. It requires a meta-understanding of the rule, an
> understanding of from where the rule came and then whether the
> circumstances at hand come from the same place.
>
> And what do I hear from You People? A cast in concrete knee-jerk rote
> repeating snap-saluting line-toeing mindless recitation of something you
> read in chapter 3 of a programming proverbs book.
>
> Super. You got 5 points from your teacher who was looking for The One
> Right Answer and you just flunked out of the U. of Kenny.
Kenny I've read your explanation but I still disagree with you it has
nothing to do listening some teacher or fallowing some cast in
concrete rule. It just the way I feel it's right.
Take for example assignment operator:
cl setf
scheme set!
q :
j =:
c++ =
For anybody using the language more than 3 days it would be crystal
clear what this do.Because we're getting use to parse those *symbols*.
Also in case of c++ we have even different meaning, because = in math
means SAME. In case of j we have to understand what's that strange
equal.
But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
is already prebuilt in our knowledge of english meaning we don't hog
any more of our brain resources to parse the setf set! or : It's
longer but tolerable. We have to type 6 characters but we release our
brain resources from context switching and symbol lookup. If we are so
on shortness maybe using IS is better. Not clear as ASSIGN but still
brain resources are lower. Think (is foo 4) or in tradition syntax foo
is 4; // looks like cobol? So adding a lot of meaningless
abbreviations like above is just not my style. Your brain might
function differently, but I have a natural tendency to remove brain
hogging coming from long functions, abreviations or shortcuts. I know
that each thing takes only a negligeble thing but they quickly add up.
This is the reason I don't like Emacs YMMV.
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <481f0522$0$15193$607ed4bc@cv.net>
Slobodan Blazeski wrote:
> On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
>
>>Slobodan Blazeski wrote:
>>
>>>On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>>
>>>>P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>>>><···········@optonline.net>:
>>
>>>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>>
>>>>>(deftoc |Reducing|
>>>>> (category "Algebra I" "Fractions")
>>>>> (genner
>>>>> (easy
>>>>> (w (n (rr 2 6))
>>>>> (m/ n (* n (rr 2 9)))))
>>>>> (avg
>>>>> (dsb (n d cf)
>>>>> (sort (rpu 3 (rr 2 9)) '<)
>>>>> (m/ (* n cf) (* d cf))))
>>>>> (hard
>>>>> (dsb (n d cf)
>>>>> (rpu 3 (rr 2 12))
>>>>> (m/ (* n cf) (* d cf)))
>>>>> (dsb (n1 n2 d1 d2)
>>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
>>>>> (m/ (* n1 n2) (* d1 d2))))))
>>
>>>>>[The neat thing being one DSL within another DSL. (This Algebra
>>>>>application just screams for DSLs because of the repeated coding of
>>>>>different Algebraic transformations.)]
>>
>>>>>Btw, the "genner" clause hard-codes random problem generation.
>>
>>>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>>
>>>>>(deftoc add-real
>>>>> (title "Adding")
>>>>> (category "Algebra I" "Real Numbers")
>>>>> (genner
>>>>> (easy
>>>>> (m+ (rp 2 (r+ 12)))
>>>>> (m+ (rp 2 (r- 12)))
>>>>> (eo (m+ 0 (r+ 12))
>>>>> (m+ (r+ 12) 0))
>>>>> (w (n (r+ 12))
>>>>> (eo (m+ n (- n))
>>>>> (m+ (- n) n))))
>>>>> (avg
>>>>> ;; --- two approaches to same thing, without prolog..
>>>>> (w (ns (rpu 2 (r+ 12)))
>>>>> (eo (m+ (car ns) (- (cadr ns)))
>>>>> (m+ (- (car ns)) (cadr ns))))
>>>>> ;; ---- ...and with prolog
>>>>> (plogn
>>>>> (generating ?x (fgen (random 12)))
>>>>> (generating ?y (fgen (random 12)))
>>>>> (lispp (/= ?x ?y))
>>>>> (eo (m+ ?x (- ?y))
>>>>> (m+ (- ?x) ?y))))
>>>>> (hard
>>>>> (plogn
>>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
>>>>> (lispp (and (+? (ct-if '+? ?ns))
>>>>> (+? (ct-if '-? ?ns))))
>>>>> (m+ ?ns)))))
>>
>>>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
>>>>>fascinating that the prolog variant is so much easier to code and so
>>>>>much more verbose. Usually goes the other way.
>>
>>>>>Anyway, looking ahead I can almost guarantee the prolog approach will
>>>>>win out -- I have been through this before. In C. Twenty years ago. I
>>>>>haven't forgotten the agony of enforcing constraints in procedural code.
>>
>>>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
>>>>>erecting version 1.0 of a random problem generation framework in an easy
>>>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
>>>>>be three years in when it disappears and you can Just Build Apps.
>>
>>>>>kenny
>>
>>>>Just in case I am not on your "kill" list. I have sided with Pascal in
>>>>that full words are better.
>>
>>>I vote for full words , though look at a dictionary and try to find
>>>shortest synonym.
>>>Very-long-and-descriptive-names sucks. But code that looks like a
>>>three-year-old with a particular fondness for periods and colons was
>>>set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>>
>>This is very disappointing.
>>
>>We already have on the table Tilton's Law of Abbreviation, signifying my
>>concurrence with the general rule, and I have gone to the trouble of
>>pointing out why this situation is exceptional, yet not not one of you
>>has said one word addressing the validity of the exception, which is the
>>only issue on the table given my concurrence with the general rule.
>>
>>The earnest dullard can follow rules, the craftsman knows when they do
>>not apply. This is the thing we cannot teach, to expert systems or even
>>good students. It requires a meta-understanding of the rule, an
>>understanding of from where the rule came and then whether the
>>circumstances at hand come from the same place.
>>
>>And what do I hear from You People? A cast in concrete knee-jerk rote
>>repeating snap-saluting line-toeing mindless recitation of something you
>>read in chapter 3 of a programming proverbs book.
>>
>>Super. You got 5 points from your teacher who was looking for The One
>>Right Answer and you just flunked out of the U. of Kenny.
>
>
> Kenny I've read your explanation but I still disagree with you it has
> nothing to do listening some teacher or fallowing some cast in
> concrete rule. It just the way I feel it's right.
> Take for example assignment operator:
> cl setf
> scheme set!
> q :
> j =:
> c++ =
>
> For anybody using the language more than 3 days it would be crystal
> clear what this do.Because we're getting use to parse those *symbols*.
> Also in case of c++ we have even different meaning, because = in math
> means SAME. In case of j we have to understand what's that strange
> equal.
> But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
> is already prebuilt in our knowledge of english meaning we don't hog
> any more of our brain resources to parse the setf set! or : It's
> longer but tolerable. We have to type 6 characters but we release our
> brain resources from context switching and symbol lookup. If we are so
> on shortness maybe using IS is better. Not clear as ASSIGN but still
> brain resources are lower. Think (is foo 4) or in tradition syntax foo
> is 4; // looks like cobol? So adding a lot of meaningless
> abbreviations like above is just not my style. Your brain might
> function differently, but I have a natural tendency to remove brain
> hogging coming from long functions, abreviations or shortcuts. I know
> that each thing takes only a negligeble thing but they quickly add up.
> This is the reason I don't like Emacs YMMV.
Jeez, it's a simple question:
This?:
(mx-generate #\-
(mx-generate #\*
(random-in-range 2 9)
(random-in-range 2 9))
(random-in-range 2 9))
...or this:
(m- (m* (rr 2 9)(rr 2 9))
(rr 2 9)))
...or maybe something infixy and even closer to what I am trying to
express (hint) like this:
"r2[9]*r2[9]-r2[9]"
...or some other infix/string scheme? I mean, we all know prefix is
better, to hell with mathematical notation, highly optimized and
familiar for math!
Now I realize you already have your answer locked in on:
(mx-generate #\-
(mx-generate #\*
(random-in-range 2 9)
(random-in-range 2 9))
(random-in-range 2 9))
...so I have some bad news for you, parsing that "mx" adds up, you have
to change them all to mathematical-expression.
And random-number-in-range-inclusive.
:)
What you are forgetting is (a) there is no disagreement over the general
rule "eschew abbreviation" and that (b) what is going on is a
translation from one domain to another so the closer we can bend the
latter to look like the former the better.
Graham covered this pretty well in On Lisp, not sure why I have to
explain this to a Lisp group.
kenny
ps. I am afraid you must stop using format. ~&? ~{? ~0,2,,a? WTF?!
:)k
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
On May 5, 3:00 pm, Ken Tilton <···········@optonline.net> wrote:
> Slobodan Blazeski wrote:
> > On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
>
> >>Slobodan Blazeski wrote:
>
> >>>On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>
> >>>>På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> >>>><···········@optonline.net>:
>
> >>>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> >>>>>(deftoc |Reducing|
> >>>>> (category "Algebra I" "Fractions")
> >>>>> (genner
> >>>>> (easy
> >>>>> (w (n (rr 2 6))
> >>>>> (m/ n (* n (rr 2 9)))))
> >>>>> (avg
> >>>>> (dsb (n d cf)
> >>>>> (sort (rpu 3 (rr 2 9)) '<)
> >>>>> (m/ (* n cf) (* d cf))))
> >>>>> (hard
> >>>>> (dsb (n d cf)
> >>>>> (rpu 3 (rr 2 12))
> >>>>> (m/ (* n cf) (* d cf)))
> >>>>> (dsb (n1 n2 d1 d2)
> >>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> >>>>> (m/ (* n1 n2) (* d1 d2))))))
>
> >>>>>[The neat thing being one DSL within another DSL. (This Algebra
> >>>>>application just screams for DSLs because of the repeated coding of
> >>>>>different Algebraic transformations.)]
>
> >>>>>Btw, the "genner" clause hard-codes random problem generation.
>
> >>>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> >>>>>(deftoc add-real
> >>>>> (title "Adding")
> >>>>> (category "Algebra I" "Real Numbers")
> >>>>> (genner
> >>>>> (easy
> >>>>> (m+ (rp 2 (r+ 12)))
> >>>>> (m+ (rp 2 (r- 12)))
> >>>>> (eo (m+ 0 (r+ 12))
> >>>>> (m+ (r+ 12) 0))
> >>>>> (w (n (r+ 12))
> >>>>> (eo (m+ n (- n))
> >>>>> (m+ (- n) n))))
> >>>>> (avg
> >>>>> ;; --- two approaches to same thing, without prolog..
> >>>>> (w (ns (rpu 2 (r+ 12)))
> >>>>> (eo (m+ (car ns) (- (cadr ns)))
> >>>>> (m+ (- (car ns)) (cadr ns))))
> >>>>> ;; ---- ...and with prolog
> >>>>> (plogn
> >>>>> (generating ?x (fgen (random 12)))
> >>>>> (generating ?y (fgen (random 12)))
> >>>>> (lispp (/= ?x ?y))
> >>>>> (eo (m+ ?x (- ?y))
> >>>>> (m+ (- ?x) ?y))))
> >>>>> (hard
> >>>>> (plogn
> >>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> >>>>> (lispp (and (+? (ct-if '+? ?ns))
> >>>>> (+? (ct-if '-? ?ns))))
> >>>>> (m+ ?ns)))))
>
> >>>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
> >>>>>fascinating that the prolog variant is so much easier to code and so
> >>>>>much more verbose. Usually goes the other way.
>
> >>>>>Anyway, looking ahead I can almost guarantee the prolog approach will
> >>>>>win out -- I have been through this before. In C. Twenty years ago. I
> >>>>>haven't forgotten the agony of enforcing constraints in procedural code.
>
> >>>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> >>>>>erecting version 1.0 of a random problem generation framework in an easy
> >>>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> >>>>>be three years in when it disappears and you can Just Build Apps.
>
> >>>>>kenny
>
> >>>>Just in case I am not on your "kill" list. I have sided with Pascal in
> >>>>that full words are better.
>
> >>>I vote for full words , though look at a dictionary and try to find
> >>>shortest synonym.
> >>>Very-long-and-descriptive-names sucks. But code that looks like a
> >>>three-year-old with a particular fondness for periods and colons was
> >>>set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>
> >>This is very disappointing.
>
> >>We already have on the table Tilton's Law of Abbreviation, signifying my
> >>concurrence with the general rule, and I have gone to the trouble of
> >>pointing out why this situation is exceptional, yet not not one of you
> >>has said one word addressing the validity of the exception, which is the
> >>only issue on the table given my concurrence with the general rule.
>
> >>The earnest dullard can follow rules, the craftsman knows when they do
> >>not apply. This is the thing we cannot teach, to expert systems or even
> >>good students. It requires a meta-understanding of the rule, an
> >>understanding of from where the rule came and then whether the
> >>circumstances at hand come from the same place.
>
> >>And what do I hear from You People? A cast in concrete knee-jerk rote
> >>repeating snap-saluting line-toeing mindless recitation of something you
> >>read in chapter 3 of a programming proverbs book.
>
> >>Super. You got 5 points from your teacher who was looking for The One
> >>Right Answer and you just flunked out of the U. of Kenny.
>
> > Kenny I've read your explanation but I still disagree with you it has
> > nothing to do listening some teacher or fallowing some cast in
> > concrete rule. It just the way I feel it's right.
> > Take for example assignment operator:
> > cl setf
> > scheme set!
> > q :
> > j =:
> > c++ =
>
> > For anybody using the language more than 3 days it would be crystal
> > clear what this do.Because we're getting use to parse those *symbols*.
> > Also in case of c++ we have even different meaning, because = in math
> > means SAME. In case of j we have to understand what's that strange
> > equal.
> > But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
> > is already prebuilt in our knowledge of english meaning we don't hog
> > any more of our brain resources to parse the setf set! or : It's
> > longer but tolerable. We have to type 6 characters but we release our
> > brain resources from context switching and symbol lookup. If we are so
> > on shortness maybe using IS is better. Not clear as ASSIGN but still
> > brain resources are lower. Think (is foo 4) or in tradition syntax foo
> > is 4; // looks like cobol? So adding a lot of meaningless
> > abbreviations like above is just not my style. Your brain might
> > function differently, but I have a natural tendency to remove brain
> > hogging coming from long functions, abreviations or shortcuts. I know
> > that each thing takes only a negligeble thing but they quickly add up.
> > This is the reason I don't like Emacs YMMV.
>
> Jeez, it's a simple question:
>
> This?:
>
> (mx-generate #\-
> (mx-generate #\*
> (random-in-range 2 9)
> (random-in-range 2 9))
> (random-in-range 2 9))
>
> ...or this:
>
> (m- (m* (rr 2 9)(rr 2 9))
> (rr 2 9)))
>
> ...or maybe something infixy and even closer to what I am trying to
> express (hint) like this:
>
> "r2[9]*r2[9]-r2[9]"
>
> ...or some other infix/string scheme?
In Edi
(hook (create #\-) (create #\* dup) (random 2 9))
Where:
1. (hook fn1 fn2 atom) => (fn (fn2 atom) atom))
2. If (define create (x &rest args) ...) then
(create #\-) => (lambda (&rest args) (apply create #\- args))
3. Dup is a operator that tells how many copies of the argument
should be supplied :
(m* (rr 2 9)(rr 2 9) (rr 2 9)) <=> (m* (dup 2)
4. (random x y) is ... you know
>I mean, we all know prefix is
> better, to hell with mathematical notation, highly optimized and
> familiar for math!
>
> Now I realize you already have your answer locked in on:
>
> (mx-generate #\-
> (mx-generate #\*
> (random-in-range 2 9)
> (random-in-range 2 9))
> (random-in-range 2 9))
>
> ...so I have some bad news for you, parsing that "mx" adds up, you have
> to change them all to mathematical-expression.
>
> And random-number-in-range-inclusive.
>
> :)
>
> What you are forgetting is (a) there is no disagreement over the general
> rule "eschew abbreviation" and that (b) what is going on is a
> translation from one domain to another so the closer we can bend the
> latter to look like the former the better.
>
> Graham covered this pretty well in On Lisp, not sure why I have to
> explain this to a Lisp group.
>
> kenny
>
> ps. I am afraid you must stop using format. ~&? ~{? ~0,2,,a? WTF?!
>
> :)k
>
> --http://smuglispweeny.blogspot.com/http://www.theoryyalgebra.com/
> ECLM rant:http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
> ECLM talk:http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en- Hide quoted text -
>
> - Show quoted text -
On May 6, 4:23 pm, Slobodan Blazeski <·················@gmail.com>
wrote:
> On May 5, 3:00 pm, Ken Tilton <···········@optonline.net> wrote:
>
>
>
>
>
> > Slobodan Blazeski wrote:
> > > On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
>
> > >>Slobodan Blazeski wrote:
>
> > >>>On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>
> > >>>>På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> > >>>><···········@optonline.net>:
>
> > >>>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> > >>>>>(deftoc |Reducing|
> > >>>>> (category "Algebra I" "Fractions")
> > >>>>> (genner
> > >>>>> (easy
> > >>>>> (w (n (rr 2 6))
> > >>>>> (m/ n (* n (rr 2 9)))))
> > >>>>> (avg
> > >>>>> (dsb (n d cf)
> > >>>>> (sort (rpu 3 (rr 2 9)) '<)
> > >>>>> (m/ (* n cf) (* d cf))))
> > >>>>> (hard
> > >>>>> (dsb (n d cf)
> > >>>>> (rpu 3 (rr 2 12))
> > >>>>> (m/ (* n cf) (* d cf)))
> > >>>>> (dsb (n1 n2 d1 d2)
> > >>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> > >>>>> (m/ (* n1 n2) (* d1 d2))))))
>
> > >>>>>[The neat thing being one DSL within another DSL. (This Algebra
> > >>>>>application just screams for DSLs because of the repeated coding of
> > >>>>>different Algebraic transformations.)]
>
> > >>>>>Btw, the "genner" clause hard-codes random problem generation.
>
> > >>>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> > >>>>>(deftoc add-real
> > >>>>> (title "Adding")
> > >>>>> (category "Algebra I" "Real Numbers")
> > >>>>> (genner
> > >>>>> (easy
> > >>>>> (m+ (rp 2 (r+ 12)))
> > >>>>> (m+ (rp 2 (r- 12)))
> > >>>>> (eo (m+ 0 (r+ 12))
> > >>>>> (m+ (r+ 12) 0))
> > >>>>> (w (n (r+ 12))
> > >>>>> (eo (m+ n (- n))
> > >>>>> (m+ (- n) n))))
> > >>>>> (avg
> > >>>>> ;; --- two approaches to same thing, without prolog..
> > >>>>> (w (ns (rpu 2 (r+ 12)))
> > >>>>> (eo (m+ (car ns) (- (cadr ns)))
> > >>>>> (m+ (- (car ns)) (cadr ns))))
> > >>>>> ;; ---- ...and with prolog
> > >>>>> (plogn
> > >>>>> (generating ?x (fgen (random 12)))
> > >>>>> (generating ?y (fgen (random 12)))
> > >>>>> (lispp (/= ?x ?y))
> > >>>>> (eo (m+ ?x (- ?y))
> > >>>>> (m+ (- ?x) ?y))))
> > >>>>> (hard
> > >>>>> (plogn
> > >>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> > >>>>> (lispp (and (+? (ct-if '+? ?ns))
> > >>>>> (+? (ct-if '-? ?ns))))
> > >>>>> (m+ ?ns)))))
>
> > >>>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
> > >>>>>fascinating that the prolog variant is so much easier to code and so
> > >>>>>much more verbose. Usually goes the other way.
>
> > >>>>>Anyway, looking ahead I can almost guarantee the prolog approach will
> > >>>>>win out -- I have been through this before. In C. Twenty years ago. I
> > >>>>>haven't forgotten the agony of enforcing constraints in procedural code.
>
> > >>>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> > >>>>>erecting version 1.0 of a random problem generation framework in an easy
> > >>>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> > >>>>>be three years in when it disappears and you can Just Build Apps.
>
> > >>>>>kenny
>
> > >>>>Just in case I am not on your "kill" list. I have sided with Pascal in
> > >>>>that full words are better.
>
> > >>>I vote for full words , though look at a dictionary and try to find
> > >>>shortest synonym.
> > >>>Very-long-and-descriptive-names sucks. But code that looks like a
> > >>>three-year-old with a particular fondness for periods and colons was
> > >>>set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>
> > >>This is very disappointing.
>
> > >>We already have on the table Tilton's Law of Abbreviation, signifying my
> > >>concurrence with the general rule, and I have gone to the trouble of
> > >>pointing out why this situation is exceptional, yet not not one of you
> > >>has said one word addressing the validity of the exception, which is the
> > >>only issue on the table given my concurrence with the general rule.
>
> > >>The earnest dullard can follow rules, the craftsman knows when they do
> > >>not apply. This is the thing we cannot teach, to expert systems or even
> > >>good students. It requires a meta-understanding of the rule, an
> > >>understanding of from where the rule came and then whether the
> > >>circumstances at hand come from the same place.
>
> > >>And what do I hear from You People? A cast in concrete knee-jerk rote
> > >>repeating snap-saluting line-toeing mindless recitation of something you
> > >>read in chapter 3 of a programming proverbs book.
>
> > >>Super. You got 5 points from your teacher who was looking for The One
> > >>Right Answer and you just flunked out of the U. of Kenny.
>
> > > Kenny I've read your explanation but I still disagree with you it has
> > > nothing to do listening some teacher or fallowing some cast in
> > > concrete rule. It just the way I feel it's right.
> > > Take for example assignment operator:
> > > cl setf
> > > scheme set!
> > > q :
> > > j =:
> > > c++ =
>
> > > For anybody using the language more than 3 days it would be crystal
> > > clear what this do.Because we're getting use to parse those *symbols*.
> > > Also in case of c++ we have even different meaning, because = in math
> > > means SAME. In case of j we have to understand what's that strange
> > > equal.
> > > But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
> > > is already prebuilt in our knowledge of english meaning we don't hog
> > > any more of our brain resources to parse the setf set! or : It's
> > > longer but tolerable. We have to type 6 characters but we release our
> > > brain resources from context switching and symbol lookup. If we are so
> > > on shortness maybe using IS is better. Not clear as ASSIGN but still
> > > brain resources are lower. Think (is foo 4) or in tradition syntax foo
> > > is 4; // looks like cobol? So adding a lot of meaningless
> > > abbreviations like above is just not my style. Your brain might
> > > function differently, but I have a natural tendency to remove brain
> > > hogging coming from long functions, abreviations or shortcuts. I know
> > > that each thing takes only a negligeble thing but they quickly add up.
> > > This is the reason I don't like Emacs YMMV.
>
> > Jeez, it's a simple question:
>
> > This?:
>
> > (mx-generate #\-
> > (mx-generate #\*
> > (random-in-range 2 9)
> > (random-in-range 2 9))
> > (random-in-range 2 9))
>
> > ...or this:
>
> > (m- (m* (rr 2 9)(rr 2 9))
> > (rr 2 9)))
>
> > ...or maybe something infixy and even closer to what I am trying to
> > express (hint) like this:
>
> > "r2[9]*r2[9]-r2[9]"
>
> > ...or some other infix/string scheme?
>
> In Edi
> (hook (create #\-) (create #\* dup) (random 2 9))
> Where:
> 1. (hook fn1 fn2 atom) => (fn (fn2 atom) atom))
> 2. If (define create (x &rest args) ...) then
> (create #\-) => (lambda (&rest args) (apply create #\- args))
> 3. Dup is a operator that tells how many copies of the argument
> should be supplied :
> (m* (rr 2 9)(rr 2 9) (rr 2 9)) <=> (m* (dup 2)
> 4. (random x y) is ... you know
Sorry I forget to give you a credit for in-the-name instructions, edi
is polymorhic, so what if there is monadic create then below wouldn't
work
(create #\-) => (lambda (&rest args) (apply create #\- args)) sp using
in-the-name instructions
(create\2 #\-) meaning I'm talking about dyadic create. Something
they're nifty but I prefer to avoid them so final result
(hook (create\2 #\-) (create\2 #\* dup) (random 2 9)) or
(hook (dyad create #\-) (dyad create #\* dup) (random 2 9))
On May 6, 4:45 pm, Slobodan Blazeski <·················@gmail.com>
wrote:
> On May 6, 4:23 pm, Slobodan Blazeski <·················@gmail.com>
> wrote:
>
>
>
>
>
> > On May 5, 3:00 pm, Ken Tilton <···········@optonline.net> wrote:
>
> > > Slobodan Blazeski wrote:
> > > > On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
>
> > > >>Slobodan Blazeski wrote:
>
> > > >>>On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>
> > > >>>>På Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
> > > >>>><···········@optonline.net>:
>
> > > >>>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>
> > > >>>>>(deftoc |Reducing|
> > > >>>>> (category "Algebra I" "Fractions")
> > > >>>>> (genner
> > > >>>>> (easy
> > > >>>>> (w (n (rr 2 6))
> > > >>>>> (m/ n (* n (rr 2 9)))))
> > > >>>>> (avg
> > > >>>>> (dsb (n d cf)
> > > >>>>> (sort (rpu 3 (rr 2 9)) '<)
> > > >>>>> (m/ (* n cf) (* d cf))))
> > > >>>>> (hard
> > > >>>>> (dsb (n d cf)
> > > >>>>> (rpu 3 (rr 2 12))
> > > >>>>> (m/ (* n cf) (* d cf)))
> > > >>>>> (dsb (n1 n2 d1 d2)
> > > >>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
> > > >>>>> (m/ (* n1 n2) (* d1 d2))))))
>
> > > >>>>>[The neat thing being one DSL within another DSL. (This Algebra
> > > >>>>>application just screams for DSLs because of the repeated coding of
> > > >>>>>different Algebraic transformations.)]
>
> > > >>>>>Btw, the "genner" clause hard-codes random problem generation.
>
> > > >>>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>
> > > >>>>>(deftoc add-real
> > > >>>>> (title "Adding")
> > > >>>>> (category "Algebra I" "Real Numbers")
> > > >>>>> (genner
> > > >>>>> (easy
> > > >>>>> (m+ (rp 2 (r+ 12)))
> > > >>>>> (m+ (rp 2 (r- 12)))
> > > >>>>> (eo (m+ 0 (r+ 12))
> > > >>>>> (m+ (r+ 12) 0))
> > > >>>>> (w (n (r+ 12))
> > > >>>>> (eo (m+ n (- n))
> > > >>>>> (m+ (- n) n))))
> > > >>>>> (avg
> > > >>>>> ;; --- two approaches to same thing, without prolog..
> > > >>>>> (w (ns (rpu 2 (r+ 12)))
> > > >>>>> (eo (m+ (car ns) (- (cadr ns)))
> > > >>>>> (m+ (- (car ns)) (cadr ns))))
> > > >>>>> ;; ---- ...and with prolog
> > > >>>>> (plogn
> > > >>>>> (generating ?x (fgen (random 12)))
> > > >>>>> (generating ?y (fgen (random 12)))
> > > >>>>> (lispp (/= ?x ?y))
> > > >>>>> (eo (m+ ?x (- ?y))
> > > >>>>> (m+ (- ?x) ?y))))
> > > >>>>> (hard
> > > >>>>> (plogn
> > > >>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
> > > >>>>> (lispp (and (+? (ct-if '+? ?ns))
> > > >>>>> (+? (ct-if '-? ?ns))))
> > > >>>>> (m+ ?ns)))))
>
> > > >>>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
> > > >>>>>fascinating that the prolog variant is so much easier to code and so
> > > >>>>>much more verbose. Usually goes the other way.
>
> > > >>>>>Anyway, looking ahead I can almost guarantee the prolog approach will
> > > >>>>>win out -- I have been through this before. In C. Twenty years ago. I
> > > >>>>>haven't forgotten the agony of enforcing constraints in procedural code.
>
> > > >>>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
> > > >>>>>erecting version 1.0 of a random problem generation framework in an easy
> > > >>>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
> > > >>>>>be three years in when it disappears and you can Just Build Apps.
>
> > > >>>>>kenny
>
> > > >>>>Just in case I am not on your "kill" list. I have sided with Pascal in
> > > >>>>that full words are better.
>
> > > >>>I vote for full words , though look at a dictionary and try to find
> > > >>>shortest synonym.
> > > >>>Very-long-and-descriptive-names sucks. But code that looks like a
> > > >>>three-year-old with a particular fondness for periods and colons was
> > > >>>set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>
> > > >>This is very disappointing.
>
> > > >>We already have on the table Tilton's Law of Abbreviation, signifying my
> > > >>concurrence with the general rule, and I have gone to the trouble of
> > > >>pointing out why this situation is exceptional, yet not not one of you
> > > >>has said one word addressing the validity of the exception, which is the
> > > >>only issue on the table given my concurrence with the general rule.
>
> > > >>The earnest dullard can follow rules, the craftsman knows when they do
> > > >>not apply. This is the thing we cannot teach, to expert systems or even
> > > >>good students. It requires a meta-understanding of the rule, an
> > > >>understanding of from where the rule came and then whether the
> > > >>circumstances at hand come from the same place.
>
> > > >>And what do I hear from You People? A cast in concrete knee-jerk rote
> > > >>repeating snap-saluting line-toeing mindless recitation of something you
> > > >>read in chapter 3 of a programming proverbs book.
>
> > > >>Super. You got 5 points from your teacher who was looking for The One
> > > >>Right Answer and you just flunked out of the U. of Kenny.
>
> > > > Kenny I've read your explanation but I still disagree with you it has
> > > > nothing to do listening some teacher or fallowing some cast in
> > > > concrete rule. It just the way I feel it's right.
> > > > Take for example assignment operator:
> > > > cl setf
> > > > scheme set!
> > > > q :
> > > > j =:
> > > > c++ =
>
> > > > For anybody using the language more than 3 days it would be crystal
> > > > clear what this do.Because we're getting use to parse those *symbols*.
> > > > Also in case of c++ we have even different meaning, because = in math
> > > > means SAME. In case of j we have to understand what's that strange
> > > > equal.
> > > > But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
> > > > is already prebuilt in our knowledge of english meaning we don't hog
> > > > any more of our brain resources to parse the setf set! or : It's
> > > > longer but tolerable. We have to type 6 characters but we release our
> > > > brain resources from context switching and symbol lookup. If we are so
> > > > on shortness maybe using IS is better. Not clear as ASSIGN but still
> > > > brain resources are lower. Think (is foo 4) or in tradition syntax foo
> > > > is 4; // looks like cobol? So adding a lot of meaningless
> > > > abbreviations like above is just not my style. Your brain might
> > > > function differently, but I have a natural tendency to remove brain
> > > > hogging coming from long functions, abreviations or shortcuts. I know
> > > > that each thing takes only a negligeble thing but they quickly add up.
> > > > This is the reason I don't like Emacs YMMV.
>
> > > Jeez, it's a simple question:
>
> > > This?:
>
> > > (mx-generate #\-
> > > (mx-generate #\*
> > > (random-in-range 2 9)
> > > (random-in-range 2 9))
> > > (random-in-range 2 9))
>
> > > ...or this:
>
> > > (m- (m* (rr 2 9)(rr 2 9))
> > > (rr 2 9)))
>
> > > ...or maybe something infixy and even closer to what I am trying to
> > > express (hint) like this:
>
> > > "r2[9]*r2[9]-r2[9]"
>
> > > ...or some other infix/string scheme?
>
> > In Edi
> > (hook (create #\-) (create #\* dup) (random 2 9))
> > Where:
> > 1. (hook fn1 fn2 atom) => (fn (fn2 atom) atom))
> > 2. If (define create (x &rest args) ...) then
> > (create #\-) => (lambda (&rest args) (apply create #\- args))
> > 3. Dup is a operator that tells how many copies of the argument
> > should be supplied :
> > (m* (rr 2 9)(rr 2 9) (rr 2 9)) <=> (m* (dup 2)
> > 4. (random x y) is ... you know
>
> Sorry I forget to give you a credit for in-the-name instructions, edi
> is polymorhic, so what if there is monadic create then below wouldn't
> work
> (create #\-) => (lambda (&rest args) (apply create #\- args)) sp using
> in-the-name instructions
> (create\2 #\-) meaning I'm talking about dyadic create. Something
> they're nifty but I prefer to avoid them so final result
> (hook (create\2 #\-) (create\2 #\* dup) (random 2 9)) or
> (hook (dyad create #\-) (dyad create #\* dup) (random 2 9))- Hide quoted text -
>
> - Show quoted text -
My mistake, you can't use hook because you'll only get a single random
so you're stack with
(create #\- (create #\* (random 2 9) (random 2 9)) (random 2 9)) as
random is not a functional operator.
From: Ken Tilton
Subject: Re: You want abbreviations? You can't handle abbreviations!
Date:
Message-ID: <48208056$0$15166$607ed4bc@cv.net>
Slobodan Blazeski wrote:
> On May 6, 4:23 pm, Slobodan Blazeski <·················@gmail.com>
> wrote:
>
>>On May 5, 3:00 pm, Ken Tilton <···········@optonline.net> wrote:
>>
>>
>>
>>
>>
>>
>>>Slobodan Blazeski wrote:
>>>
>>>>On May 4, 4:15 am, Ken Tilton <···········@optonline.net> wrote:
>>
>>>>>Slobodan Blazeski wrote:
>>
>>>>>>On May 2, 1:00 pm, "John Thingstad" <·······@online.no> wrote:
>>
>>>>>>>P� Fri, 02 May 2008 05:02:03 +0200, skrev Ken Tilton
>>>>>>><···········@optonline.net>:
>>
>>>>>>>>Everyone knows how much I love Arc, I guess it has influenced my Lisp:
>>
>>>>>>>>(deftoc |Reducing|
>>>>>>>> (category "Algebra I" "Fractions")
>>>>>>>> (genner
>>>>>>>> (easy
>>>>>>>> (w (n (rr 2 6))
>>>>>>>> (m/ n (* n (rr 2 9)))))
>>>>>>>> (avg
>>>>>>>> (dsb (n d cf)
>>>>>>>> (sort (rpu 3 (rr 2 9)) '<)
>>>>>>>> (m/ (* n cf) (* d cf))))
>>>>>>>> (hard
>>>>>>>> (dsb (n d cf)
>>>>>>>> (rpu 3 (rr 2 12))
>>>>>>>> (m/ (* n cf) (* d cf)))
>>>>>>>> (dsb (n1 n2 d1 d2)
>>>>>>>> (subseq (shuffle (list 2 3 5 7 9 11 13)) 0 4)
>>>>>>>> (m/ (* n1 n2) (* d1 d2))))))
>>
>>>>>>>>[The neat thing being one DSL within another DSL. (This Algebra
>>>>>>>>application just screams for DSLs because of the repeated coding of
>>>>>>>>different Algebraic transformations.)]
>>
>>>>>>>>Btw, the "genner" clause hard-codes random problem generation.
>>
>>>>>>>>Hmmm. Where'd the prolog go? Ah, different problem (halfway down):
>>
>>>>>>>>(deftoc add-real
>>>>>>>> (title "Adding")
>>>>>>>> (category "Algebra I" "Real Numbers")
>>>>>>>> (genner
>>>>>>>> (easy
>>>>>>>> (m+ (rp 2 (r+ 12)))
>>>>>>>> (m+ (rp 2 (r- 12)))
>>>>>>>> (eo (m+ 0 (r+ 12))
>>>>>>>> (m+ (r+ 12) 0))
>>>>>>>> (w (n (r+ 12))
>>>>>>>> (eo (m+ n (- n))
>>>>>>>> (m+ (- n) n))))
>>>>>>>> (avg
>>>>>>>> ;; --- two approaches to same thing, without prolog..
>>>>>>>> (w (ns (rpu 2 (r+ 12)))
>>>>>>>> (eo (m+ (car ns) (- (cadr ns)))
>>>>>>>> (m+ (- (car ns)) (cadr ns))))
>>>>>>>> ;; ---- ...and with prolog
>>>>>>>> (plogn
>>>>>>>> (generating ?x (fgen (random 12)))
>>>>>>>> (generating ?y (fgen (random 12)))
>>>>>>>> (lispp (/= ?x ?y))
>>>>>>>> (eo (m+ ?x (- ?y))
>>>>>>>> (m+ (- ?x) ?y))))
>>>>>>>> (hard
>>>>>>>> (plogn
>>>>>>>> (generating ?ns (fgen (rp (eo 3 4) (eo (r+ 12)(r- 12)))))
>>>>>>>> (lispp (and (+? (ct-if '+? ?ns))
>>>>>>>> (+? (ct-if '-? ?ns))))
>>>>>>>> (m+ ?ns)))))
>>
>>>>>>>>I highlighted above a for-the-fun-of-it with/without Prolog pair,
>>>>>>>>fascinating that the prolog variant is so much easier to code and so
>>>>>>>>much more verbose. Usually goes the other way.
>>
>>>>>>>>Anyway, looking ahead I can almost guarantee the prolog approach will
>>>>>>>>win out -- I have been through this before. In C. Twenty years ago. I
>>>>>>>>haven't forgotten the agony of enforcing constraints in procedural code.
>>
>>>>>>>>Meanwhile, what a pleasure to be doing /applications/ again with Lisp,
>>>>>>>>erecting version 1.0 of a random problem generation framework in an easy
>>>>>>>>day. Noobs, as much as you dig Lisp, have no idea how much fun it will
>>>>>>>>be three years in when it disappears and you can Just Build Apps.
>>
>>>>>>>>kenny
>>
>>>>>>>Just in case I am not on your "kill" list. I have sided with Pascal in
>>>>>>>that full words are better.
>>
>>>>>>I vote for full words , though look at a dictionary and try to find
>>>>>>shortest synonym.
>>>>>>Very-long-and-descriptive-names sucks. But code that looks like a
>>>>>>three-year-old with a particular fondness for periods and colons was
>>>>>>set before the keyboard. (http://www.jsoftware.com/help/jforc/contents.htm)
>>
>>>>>This is very disappointing.
>>
>>>>>We already have on the table Tilton's Law of Abbreviation, signifying my
>>>>>concurrence with the general rule, and I have gone to the trouble of
>>>>>pointing out why this situation is exceptional, yet not not one of you
>>>>>has said one word addressing the validity of the exception, which is the
>>>>>only issue on the table given my concurrence with the general rule.
>>
>>>>>The earnest dullard can follow rules, the craftsman knows when they do
>>>>>not apply. This is the thing we cannot teach, to expert systems or even
>>>>>good students. It requires a meta-understanding of the rule, an
>>>>>understanding of from where the rule came and then whether the
>>>>>circumstances at hand come from the same place.
>>
>>>>>And what do I hear from You People? A cast in concrete knee-jerk rote
>>>>>repeating snap-saluting line-toeing mindless recitation of something you
>>>>>read in chapter 3 of a programming proverbs book.
>>
>>>>>Super. You got 5 points from your teacher who was looking for The One
>>>>>Right Answer and you just flunked out of the U. of Kenny.
>>
>>>>Kenny I've read your explanation but I still disagree with you it has
>>>>nothing to do listening some teacher or fallowing some cast in
>>>>concrete rule. It just the way I feel it's right.
>>>>Take for example assignment operator:
>>>>cl setf
>>>>scheme set!
>>>>q :
>>>>j =:
>>>>c++ =
>>
>>>>For anybody using the language more than 3 days it would be crystal
>>>>clear what this do.Because we're getting use to parse those *symbols*.
>>>>Also in case of c++ we have even different meaning, because = in math
>>>>means SAME. In case of j we have to understand what's that strange
>>>>equal.
>>>>But what if we use ASSIGN like (assign foo 4) <=> (setf foo 4) Assign
>>>>is already prebuilt in our knowledge of english meaning we don't hog
>>>>any more of our brain resources to parse the setf set! or : It's
>>>>longer but tolerable. We have to type 6 characters but we release our
>>>>brain resources from context switching and symbol lookup. If we are so
>>>>on shortness maybe using IS is better. Not clear as ASSIGN but still
>>>>brain resources are lower. Think (is foo 4) or in tradition syntax foo
>>>>is 4; // looks like cobol? So adding a lot of meaningless
>>>>abbreviations like above is just not my style. Your brain might
>>>>function differently, but I have a natural tendency to remove brain
>>>>hogging coming from long functions, abreviations or shortcuts. I know
>>>>that each thing takes only a negligeble thing but they quickly add up.
>>>>This is the reason I don't like Emacs YMMV.
>>
>>>Jeez, it's a simple question:
>>
>>>This?:
>>
>>> (mx-generate #\-
>>> (mx-generate #\*
>>> (random-in-range 2 9)
>>> (random-in-range 2 9))
>>> (random-in-range 2 9))
>>
>>>...or this:
>>
>>> (m- (m* (rr 2 9)(rr 2 9))
>>> (rr 2 9)))
>>
>>>...or maybe something infixy and even closer to what I am trying to
>>>express (hint) like this:
>>
>>> "r2[9]*r2[9]-r2[9]"
>>
>>>...or some other infix/string scheme?
>>
>>In Edi
>>(hook (create #\-) (create #\* dup) (random 2 9))
>>Where:
>>1. (hook fn1 fn2 atom) => (fn (fn2 atom) atom))
>>2. If (define create (x &rest args) ...) then
>>(create #\-) => (lambda (&rest args) (apply create #\- args))
>>3. Dup is a operator that tells how many copies of the argument
>>should be supplied :
>>(m* (rr 2 9)(rr 2 9) (rr 2 9)) <=> (m* (dup 2)
>>4. (random x y) is ... you know
>
>
> Sorry I forget to give you a credit for in-the-name instructions, edi
> is polymorhic, so what if there is monadic create then below wouldn't
> work
> (create #\-) => (lambda (&rest args) (apply create #\- args)) sp using
> in-the-name instructions
> (create\2 #\-) meaning I'm talking about dyadic create. Something
> they're nifty but I prefer to avoid them so final result
> (hook (create\2 #\-) (create\2 #\* dup) (random 2 9)) or
> (hook (dyad create #\-) (dyad create #\* dup) (random 2 9))
It occurs to me that we may not be in disagreement, since I have already
identified my controversial naming as a faulty half-way step to a
full-blown mathy infix even terser more effective syntax requiring a
special parser yadda-yadda. ie, the logical extension to an infix string
or somesuch does not support my naming, it refutes it. Interesting how
that works.
kt
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
ECLM rant:
http://video.google.com/videoplay?docid=-1331906677993764413&hl=en
ECLM talk:
http://video.google.com/videoplay?docid=-9173722505157942928&q=&hl=en
Ken Tilton <·········@gmail.com> wrote:
+---------------
| Everyone knows how much I love Arc, I guess it has influenced my Lisp:
|
| (deftoc |Reducing|
| (category "Algebra I" "Fractions")
| (genner ... ))
+---------------
Heh! You missed an opportunity! If you compile (or load) this code
with READTABLE-CASE set to :INVERT, you can save two more characters: ;-}
(deftoc Reducing
(category "Algebra I" "Fractions")
(genner ... ))
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
Rob Warnock wrote:
> Ken Tilton <·········@gmail.com> wrote:
> +---------------
> | Everyone knows how much I love Arc, I guess it has influenced my Lisp:
> |
> | (deftoc |Reducing|
> | (category "Algebra I" "Fractions")
> | (genner ... ))
> +---------------
>
> Heh! You missed an opportunity! If you compile (or load) this code
> with READTABLE-CASE set to :INVERT, you can save two more characters: ;-}
>
> (deftoc Reducing
> (category "Algebra I" "Fractions")
> (genner ... ))
Yes, and you could even go back to using StudlyCaps, too!
As someone who suffers from being documentally challenged, I'm not sure I
agree. I have for years used a 5 point font and a ton of C-x 3 panes in
Emacs to combat my lack of any short term memory whatsoever. Perhaps I do
have short term memory but it's functional (like the universe) not
procedural (like the daily grind).
Unfortunately I also suffer from whitespace induced blindness, for the
same reason as above. MathML vs TeX? TeX always wins.
I use abbreviation with moderation (not as in occasionally, but after
consideration of needs, that's what moderation means).
I have to side with K, here.
It looks like gibberish at first, but my reading patience goes low with
long names which affects my reading comprehension much more than
abbreviation does.