Abstracting away the complexity is the goal.
chris glur — 2010-02-20 16:26:21
I refute the contention that human readability is NOT the most important
attribute of programs.
Here's a real-life task, for which I'd like to see the cat-like skeleton code:-
Previously we had Usenet. Now the kiddies have moved over to blogs.
It's like the crowding-out of public transport by private cars.
With Usenet, individual articles could be indexed. With blogs the whole
article and comment set is an atomic unit.
Usenet was designed by engineers via RFCs. Blogs evolved chaotically
like natural language.
So, for the professor's blog that gives 4 new topics per week, where I've
asked a question ca. 2 weeks ago, to find possbible answer/s; since blogs
have removed the reader's capability of originating a topic, I had to slip my
question, into the comment-set of one of the blog-owner's topics.
How will cat-like help me find possible answers to my query?
First I'm trying to find my query that a scribbled in a open file on my PC.
Here's how algol-like does it:
FOR AllFiles in dir-tree X FOR AllFiles < 15DaysOld
FOR Allfiles containing GuessWord1
FOR Allfiles containing GuessWord2
FOR Allfiles containing GuessWord3
I speculate that if I can guess 3 uncommon/key words that I'd put in my post,
it might reduce the search to less then 10 files -- on my PC.
With some difficulty, via usenet queries, I previously found [and often use it]
that the first 3 of the 5 steps listed above, can be done easily by:--
find $dir -ctime -$daysOld -exec grep -l $String {} \;
What I like about this is that I can percieve it as BLOB with 3-args:
1. the dir-tree, 2. how many days old, 3. the Search-word.
So now to further reduce the files needing to be to manually searched, I
need to 'pipe' the results through 2 further stages of `BLAB GuessWordn`.
I'm dreaming of a cat-like/dataflow language which looks like:-
DirTree DaysOld String `DASfind` | GuessWord2 `ListFilesWithString`
| GuessWord3 `ListFilesWithString`
I've put the `operators` in " ` ".
What appeals to me about this 'programming style' is that you can just put
the utilities in a library, and grab them whenever you need them.
The first unix utility above, I was 'given' and don't [want to] fully
understand, except to comment that each (file < DaysOld) would need to be
found, before it can be tested for, or not containing $String.
So, the 'local variable' of a file or perhaps [since grep does one line at
a time] a line [of unlimited length] has to be held [point-free/unconcerned
about ?]. It's really nice to be able to abstract-away such details, when
you've had decades of having to caretake every bit.
BTW, I've got my own little few-lines utilitiy, which I 'paste around',
to 'process a list of files' as will be needed above for GuessWord2 & 3.
AFAIK Haskell and others have the mapcar-concept of:
DoTask (TheTask, ListOfFiles) -> ListOfFiles
Does joy have a mapcar-type as 'native' ?
Where are joy's reserved words listed ?
== Chris Glur.
William Tanksley, Jr — 2010-02-20 21:35:39
chris glur <
crglur@...> wrote:
> I refute the contention that human readability is NOT the most important
> attribute of programs.
I assert that saying something neither makes it so, nor constitutes a
refutation. But this is beside the point.
> Here's a real-life task, for which I'd like to see the cat-like skeleton code:-
Sure, why not; go ahead. Factor is a good language for this, I'd
think; unless Joy's gained a lot more of a web library than I'd
thought, you'll be happier with Factor.
> With Usenet, individual articles could be indexed. With blogs the whole
> article and comment set is an atomic unit.
> Usenet was designed by engineers via RFCs. Blogs evolved chaotically
> like natural language.
Blogs and Usenet share much in common -- Usenet evolved chaotically
(in the hands of engineers), just like blogs.
To index individual articles in blogs, we use two basic types of
technology: an article feed, and a backlink registry.Article feeds use
RSS and Atom XML formats (about equally commonly, many sites provide
both), and they're used to let you know when the blog you're watching
has a new article (or comment) posted to it. Backlink registries use
TrackBack or Google Backlink, and they let you know when someone other
than the author of a post has written a blogpost that links to the
post.
> So, for the professor's blog that gives 4 new topics per week, where I've
> asked a question ca. 2 weeks ago, to find possbible answer/s; since blogs
> have removed the reader's capability of originating a topic, I had to slip my
> question, into the comment-set of one of the blog-owner's topics.
Does this prof's blog support comment feeds? If so, you don't have to
do any programming -- I'd just log into Google Reader
(reader.google.com), press 'a' to add a subscription, and paste in the
URL of the comment page you posted on. With any luck, Google Reader
will give you a list of all comments; you can mark the uninteresting
ones read, star the interesting ones, and then when a new comment is
made you'll see it.
> How will cat-like help me find possible answers to my query?
Start first by knowing your "enemy" -- the blog page that holds the
info you want. What standards does it support? Obviously it's written
in HTML, of course, but does it have an RSS feed? Is there a comments
RSS feed? Does it perhaps support email updates (not the greatest way,
but possible)?
Better yet, rather than "hijacking" a blog post to leave an unrelated
comment, find a forum where people discuss similar things, and then
without insulting them, ask your question.
> First I'm trying to find my query that a scribbled in a open file on my PC.
> Here's how algol-like does it:
> FOR AllFiles in dir-tree X FOR AllFiles < 15DaysOld
> FOR Allfiles containing GuessWord1
> FOR Allfiles containing GuessWord2
> FOR Allfiles containing GuessWord3
Why is your pseudocode so wrong? That's horrific.
> I speculate that if I can guess 3 uncommon/key words that I'd put in my post,
> it might reduce the search to less then 10 files -- on my PC.
> With some difficulty, via usenet queries, I previously found [and often use it]
> that the first 3 of the 5 steps listed above, can be done easily by:--
> find $dir -ctime -$daysOld -exec grep -l $String {} \;
> What I like about this is that I can percieve it as BLOB with 3-args:
> 1. the dir-tree, 2. how many days old, 3. the Search-word.
> So now to further reduce the files needing to be to manually searched, I
> need to 'pipe' the results through 2 further stages of `BLAB GuessWordn`.
You can use the same 'grep' command.
> I'm dreaming of a cat-like/dataflow language which looks like:-
> DirTree DaysOld String `DASfind` | GuessWord2 `ListFilesWithString`
> | GuessWord3 `ListFilesWithString`
Yeah, Factor has all that. Read the manual. If you have questions, the
Factor mailing list is excellent. Try not to insult them, though.
> What appeals to me about this 'programming style' is that you can just put
> the utilities in a library, and grab them whenever you need them.
Wow, it's just like programming.
> AFAIK Haskell and others have the mapcar-concept of:
> DoTask (TheTask, ListOfFiles) -> ListOfFiles
> Does joy have a mapcar-type as 'native' ?
> Where are joy's reserved words listed ?
I think Joy calls it 'map'. It's not a reserved word; it's a function,
and it's listed in Manfred's Joy page, in the "Atomic Programs of Joy"
paper (I admit that I'm not sure why he called it that), in the
"Operators for Aggregate Types" section. If you have more questions,
this is probably the best place to ask, although not everyone here
knows anything about Joy itself; this is a more general-purpose group.
Given your entire task, though, you may want a language with a more
developed library, like Factor. Its documentation is available from
its home page, or from its interactive graphical console.
> == Chris Glur.
-Wm
chris glur — 2010-02-21 08:44:07
> To index individual articles in blogs, we use two basic types
> of technology: an article feed, and a backlink registry.Article
> feeds use RSS and Atom XML formats (about equally commonly,
> many sites provide both), and they're used to let you know when
> the blog you're watching has a new article (or comment) posted
> to it. Backlink registries use TrackBack or Google Backlink,
> and they let you know when someone other than the author of
> a post has written a blogpost that links to the post.
That seems complex - what I want to avoid.
Am I wrong that the 'thread' of [typically 80] comments is agregated,
and you can't fetch single comments ?
I've got a utility which does:
goog <URL> <3 words in contents> <file to save Results>
which I shoot off in the background while I'm d/l-ing other stuff.
But I don't want to get married to google. IMO they are becoming the most
powerfull organisation in the world - worrysome.
> Why is your pseudocode so wrong? That's horrific.
Yes switching syntax between: lisp, piped-data-flow, algol
is problematic.
I've been reading the MIT on-line scheme-based tutorials and am astounded at
the clarity of presentation. These old timers even 'touch on' human cognitive
considerations, which as I've been selling is the most important.
...
> Yeah, Factor has all that.
"All that" is what I'm worried about. For me 'less is more'.
I don't want to open another can of worms.
And I've been good at avoiding fads.
It's just that this 'cascading-transformed-data' method is cost effective.
So since scheme can do anything/everything; if it could be achieved by a
piped-data-flow notation that would be great.
William Tanksley, Jr — 2010-02-21 16:06:51
chris glur <
crglur@...> wrote:
>> To index individual articles in blogs, we use two basic types
>> of technology: an article feed, and a backlink registry.Article
>> feeds use RSS and Atom XML formats (about equally commonly,
>> many sites provide both), and they're used to let you know when
>> the blog you're watching has a new article (or comment) posted
>> to it. Backlink registries use TrackBack or Google Backlink,
>> and they let you know when someone other than the author of
>> a post has written a blogpost that links to the post.
> That seems complex - what I want to avoid.
How did you measure the complexity? I don't get it.
> Am I wrong that the 'thread' of [typically 80] comments is agregated,
> and you can't fetch single comments ?
RSS allows you to easily parse out individual articles and comments.
That's its function.
> I've got a utility which does:
> goog <URL> <3 words in contents> <file to save Results>
> which I shoot off in the background while I'm d/l-ing other stuff.
> But I don't want to get married to google. IMO they are becoming the most
> powerfull organisation in the world - worrysome.
What sort of thing does the utility do? I'm guessing it runs a Google
search qualified by "site:<URL>" for the 3 words... But why are you
doing that?
>> Why is your pseudocode so wrong? That's horrific.
> Yes switching syntax between: lisp, piped-data-flow, algol
> is problematic.
No, I mean all the FOR loops. You have a huge set of nested FOR loops.
That's going to be _slow_.
> I've been reading the MIT on-line scheme-based tutorials and am astounded at
> the clarity of presentation. These old timers even 'touch on' human cognitive
> considerations, which as I've been selling is the most important.
MIT's open classware is an incredible resource. It's not "old-timer",
though; it's fairly recent. MIT's "Structure and Interpretation of
Computer Programs" is somewhat old-timer, of course... Good book. I
got depressed reading it, though (back before anyone'd learned about
concatenative stuff; back before I'd done much Forth) -- it makes you
realize how complex variables really make programs.
>> Yeah, Factor has all that.
> "All that" is what I'm worried about. For me 'less is more'.
Hey, that's cool. Let me ask a few questions: Do you want to write
your own HTTP library, or use a prewritten one? How about an XML or
HTML parser? An RSS parser?
I had gotten the (perhaps incorrect) impression that you wanted to use
functions from libraries and not worry about who wrote them. Was I
incorrect? If so, and you actually do enjoy writing every part of
every application, Joy may be for you; but perhaps what you really
want is one of the dialects of ColorForth (you might start with
RainbowForth), since they're designed to let you understand your
application from the hardware up.
I don't think you're really asking for that, though; I think you're
just rejecting what you're offered because that's what you're used to
doing. I don't really know why...
> It's just that this 'cascading-transformed-data' method is cost effective.
Yes. If you believe that, you'll use a dataflow language. I don't see
you even _trying_. I've cited several good languages, and you've
ignored my suggestions.
> So since scheme can do anything/everything; if it could be achieved by a
> piped-data-flow notation that would be great.
Piped data flow is inherently linear (flat). Scheme is inherently
tree-structured (not flat). If you start with Scheme's math, you'll
_never_ reach a piped-data-flow that can do everything. Frankly: flat
languages are _very_ hard to work with. I've written one; trust me on
this. I'm trying to find SOME way to make my flat language
human-intelligible; it may be possible, but how to do it is so far
evading me.
-Wm
chris glur — 2010-02-22 19:59:21
>How did you measure the complexity? I don't get it.
The number of new concepts introduced.
...
> RSS allows you to easily parse out individual articles and comments.
> That's its function.
Perhaps I'll try it.
For decade/s I ignored Turbo-pascal & used my own P-code compiler, because
"turbo" was a fad-word. I've been thinking that blogs are just a passing fad
like sub-prime-loans.
...
> What sort of thing does the utility do? I'm guessing it runs a Google
> search qualified by "site:<URL>" for the 3 words...
Yes, that an example of NOT complexity. You could see what it does.
> But why are you doing that?
1. use the power of google
2. reduce the search-space to <URL> only
3. further reduce to likely articles
so that the size of text that I'll have to read is reduced.
...
]>> Why is your pseudocode so wrong? That's horrific.
]> Yes switching syntax between: lisp, piped-data-flow, algol
]> is problematic.
> No, I mean all the FOR loops. You have a huge set of nested FOR loops.
> That's going to be _slow_.
IMO we mostly talk past each other.
If the algorithm demands nested FORs ...which this one does.
Except my text was wrong. Let's examine further ..
Just look at this mess:-
ContainsWord(
ContainsWord(
ContainsWord(
AllFilesYoungerThanDays(15), <word1>), <word2> , <word3>)
which might STILL be wrong.
Each of the 4 functions returns a set-of-files/FileNames.
How much less complex [cognitive load] is a piped data-flow notation:
15 AllFilesYoungerThanDays |
<word1> ContainsWord |
<word2> ContainsWord |
<word3> ContainsWord |
which can be directly translated from the natural language spec. of
"find which of new-files, contain word1 & word2 & word3".
So there is inevitable nesting:
once the young-enough files have been found, they must be searched.
But the search space decreases by each step.
I'm less interested in the D.Knuth-like considerations of optimising the search
by eg. combining the search for the 3 [or n] words, rather than just doing
3 searches, that the HUMAN readability/maintainablility of the code.
...
> MIT's open classware is an incredible resource. It's not
> "old-timer", though; it's fairly recent.
Their tradition of clear writing [which I can't do] is old.
New technology just allowed open-classware; but the HUMAN capital behind it
adds the value. I was recently browsing my Samuelson [died recently at 94,
still giving lucid interviews till end] 1967 Edition. What brilliance !
...
> you wanted to use functions from libraries
YES! But they must be 'clean' as expounded in SICP.
IMO if they evolve naturally, they get over-run by entropy.
So they need to limited by formality.
Here's 2 example of very common bad:
* the matured and well-respected mail-client 'mutt' has a help-menu of
6 screens, ie. over 100 options; arranged ALPHABETICALLY [instead of
conceptually], in case someone wants to know "I wonder what mutt uses
the 'Z' key, or <esc> Q... for".
--> change topic <---
I mentioned that google is going to take over the world.
That's because search is the most important/needed function.
They've got the key to adding value to OUR explosive accumulatiuon of data.
Perhaps I have a special mental defficiency, but regular-expression-search
is the most fascinating/frustrating can-of-worms for me.
AGAIN I've spent hours, without success the find how to use sed to
<extract the string from the file: which starts with "start" and ends with
"end", exclusively>.
Also ETH-oberon's RX search/replace utility kills me.
But related to 'sed' the following newly discovered cat-like [piping results
through transformers] method fascinates me.
Before I read this cat-mail-list I'd never have seen it this way:
I want to find the list of *sed* usenet groups,
which is in the partition: 'something about "11" ';
in the file: 'something about "*ot*st" ' eg. TotalLst, totalList...etc;
in the dir: 'something about "*net*" '.
Here's the data-flow/piping sequence:
df <-- gives me the list of mounted partitions
| grep 11 <--- gives me the line mentioning the one I want
<missing> <--- the code that I can't do yet to extract a substring via sed
find <the 3 stage pipe above> -name "*ot*st" <--something about "*ot*st"
| grep "*net*" <--- something about "*net*"
----------
So the 5 steps described in the 2 above paragraphs even with messy unix
utilities would give < 100 chars of code.
The beauty/danger-of-BASIC-like-illusion is that you can manually test it
easily by using the 'history key' to pop-up previous commands and modify
or wrap them. Ie. a cutNpaste effect, encouraging a dumbed-down, suck-it-&-see
approach, which I think is the reason for all the sed-tutors who can ride a
bicycle but don't KNOW how to ride a bicycle. Ability from practicing examples
is NOT a substitute for knowledge of the underlying model.
So now that the 5 simple steps have found the file, it remains only to:
<list all lines [since there's one newgroupId per line] containing *sed*>
ie. `| grep "*sed*"
So the data-flow looks like this"
partitionList -> with "11" -> trim-out -> with "*ot*st" -> with "*net*"
-> containing "*sed*"
Pity I couldn't fit it on 1 line-len < 80.
And the reason why I prefer it to the algol style programming that I'm used
to, is that it's much simpler, and therefore more testable and maintainable.
So, the zillions of year-lines of confirmed unix code , prove the viability
of the concept. Except the unix utilities just evolved chaotically and
don't fit together cleanly, as a system which was designed from the ground,
would.
==================
Yes it's flat which is the basis of [reason for] the simplicity.
The nesting comes in the called functions,
which presumably can nestedly call other routines.
I'm not convinced that adding control stuctures to this data-flow-view,
is viable, because it would destroy the one-dimensional simplicity.
IMO forth is a nightmare to read.
Whereas I'm proposing to use flat data-flow to call functions,
as you know, unix uses block-structured algol-style scripts, with
data-flow-tricks to get get values, like [conceptually]
append the date-field of the line mentioning "dog" to the
weight-field of the line mentioning "cat".
== Chris Glur.
John Nowak — 2010-02-23 00:06:32
On Feb 22, 2010, at 2:59 PM, chris glur wrote:
>> How did you measure the complexity? I don't get it.
>
> The number of new concepts introduced.
That's a terrible way to measure complexity.
> For decade/s I ignored Turbo-pascal & used my own P-code compiler,
> because
> "turbo" was a fad-word. I've been thinking that blogs are just a
> passing fad
> like sub-prime-loans.
This exchange is embarrassing to read.
> I'm not convinced that adding control stuctures to this data-flow-
> view,
> is viable, because it would destroy the one-dimensional simplicity.
Yes, just like adding a steering rack to a car.
- jn
William Tanksley, Jr — 2010-02-23 01:06:55
chris glur <
crglur@...> wrote:
> >How did you measure the complexity? I don't get it.
> The number of new concepts introduced.
>
As a subjective definition, this is only valuable when you specify who the
concepts are new to. Wouldn't it be more useful to -- for example -- measure
complexity according to the number of computational steps required to
describe the task? The nice thing about that is that if you've got good
abstractions (a main theme of this email exchange), you can just *use* them
without describing them, thus lowering the apparent complexity.
RSS comes with a free abstraction: the individual comments are presented
separately. You don't need to think about parsing them apart. They're also
clearly dated, which normal web content is not; since your code thinks about
datestamps, this is actually important, and you have no way of getting that
info.
For decade/s I ignored Turbo-pascal & used my own P-code compiler, because
> "turbo" was a fad-word. I've been thinking that blogs are just a passing
> fad
> like sub-prime-loans.
>
I sympathize; I've been trying to think that for years. So far they haven't
gone away :-). To be fair, though, they've got advantages over Usenet. The
only thing I balk at anymore is the word 'blog', and that's just because I'm
a curmudgeon.
> What sort of thing does the utility do? I'm guessing it runs a Google
> > search qualified by "site:<URL>" for the 3 words...
> Yes, that an example of NOT complexity. You could see what it does.
>
Actually, I was puzzled... Took me a while. I guess I've been using feed
aggregators for too long. BTW, there are also services that will email you
when a web page changes. (I wouldn't use 'em either. :-)
> No, I mean all the FOR loops. You have a huge set of nested FOR loops.
> > That's going to be _slow_.
> IMO we mostly talk past each other.
>
Yes, most of the time.
If the algorithm demands nested FORs ...which this one does.
>
My guess would be that it uses one FOR, perhaps two at the most; and a set
of nested IFs.
Except my text was wrong. Let's examine further ..
> Just look at this mess:-
> ContainsWord(
> ContainsWord(
> ContainsWord(
> AllFilesYoungerThanDays(15), <word1>), <word2> , <word3>)
> which might STILL be wrong.
> Each of the 4 functions returns a set-of-files/FileNames.
>
Nod.
How much less complex [cognitive load] is a piped data-flow notation:
> 15 AllFilesYoungerThanDays |
> <word1> ContainsWord |
> <word2> ContainsWord |
> <word3> ContainsWord |
>
Fair statement. Now, in Factor or Joy you could have the same thing, only
without the pipes. Like this:
15 AllFilesYoungerThanDays
<word1> ContainsWord
<word2> ContainsWord
<word3> ContainsWord
The definition of ContainsWord would have the stack effect ( path-list
string -- path-list' ).
I'm less interested in the D.Knuth-like considerations of optimising the
> search
by eg. combining the search for the 3 [or n] words, rather than just doing
> 3 searches, that the HUMAN readability/maintainablility of the code.
>
D Knuth knew well the sinfulness of premature optimization.
> you wanted to use functions from libraries
> YES! But they must be 'clean' as expounded in SICP.
> IMO if they evolve naturally, they get over-run by entropy.
> So they need to limited by formality.
>
What do you mean 'limited by formality'? I agree with the rest of your
point; actually, that's one thing I like about Factor, that because most of
the language's development is centered in the main Factor repository, the
team hasn't been afraid to make major changes even to the core library in
order to produce better code in applications and/or support code: they
change the library, and then change all the applications to make sure it
improves the application code.
Perhaps I have a special mental defficiency, but regular-expression-search
> is the most fascinating/frustrating can-of-worms for me.
> AGAIN I've spent hours, without success the find how to use sed to
> <extract the string from the file: which starts with "start" and ends with
> "end", exclusively>.
>
That reminds me of REBOL's 'parse' function, which instead of using cryptic
regexps, uses more verbose and powerful LL expressions. You might want to
check it out; it's not exactly what you're asking for, but it might serve
your needs better than the other existing technologies.
I can't help you with sed; I prefer string processing rather than regular
expressions, and prefer full programming languages when possible. I suspect
you'd have to agree that 'sed' is pretty much the worst of all possible
worlds -- cryptic and relatively non-powerful.
But related to 'sed' the following newly discovered cat-like [piping results
> through transformers] method fascinates me.
>
I persist in my request that you justify using 'cat-like'. What you're
describing isn't like 'concatenative' languages, and it's not like the 'Cat'
language... Why do you keep using it?
So, the zillions of year-lines of confirmed unix code , prove the viability
> of the concept. Except the unix utilities just evolved chaotically and
> don't fit together cleanly, as a system which was designed from the ground,
> would.
>
Yes, I agree. As a side comment, the OS "plan 9" (from some of the inventors
of Unix) attempted to reengineer Unix from the ground up on roughly those
grounds.
http://www.caerwyn.com/acme/ seems to be the port for most OSes.
Yes it's flat which is the basis of [reason for] the simplicity.
> The nesting comes in the called functions,
> which presumably can nestedly call other routines.
>
Yes, but they're still only flatly structured. Unless, of course, you allow
for immediate words, which is how Forth does its control structures -- and I
think is part of what annoys you.
I'm not convinced that adding control stuctures to this data-flow-view,
> is viable, because it would destroy the one-dimensional simplicity.
>
I understand; but programmers should be taught that when the code _can_ be
flat, it _should_ be. When it _can't_ -- it shouldn't. A more powerful
IMO forth is a nightmare to read.
>
I find it delightful. I enjoy ColorForth as well.
Whereas I'm proposing to use flat data-flow to call functions,
> as you know, unix uses block-structured algol-style scripts, with
> data-flow-tricks to get get values, like [conceptually]
> append the date-field of the line mentioning "dog" to the
> weight-field of the line mentioning "cat".
I'm not sure how I'd do that using only pipes in Unix. I know how I'd do it
in 'real' programming languages.
But once you allow data flow tricks, why not allow a decent set of them?
== Chris Glur.
-Wm
[Non-text portions of this message have been removed]
chris glur — 2010-02-23 01:27:47
You might note that I wrote "data flow VIEW",
and not data flow programming language.
Without giving much thought, I speculate that such a one dimensional
facility, could not be Turing complete.
In the real life example that I gave, clearly the control
structures are embedded in the library 'utilities'.
Did you understand, how I explained that conventionally unix puts
the control structures in the shell-scripts, and has the
'straight-line data transformer chains' embedded in there ?
I want to be more lazy and just string someone else's transformers
together, where it's possible.
BTW you've confirmed what I suspected: it's taboo to discuss the
psychological basis of computing practices. Importantly the MIT
old-boys touch on it discretely.
I can well believe that any diversion from the popular wisdom of
NY [Wall street] was hammered down.
== Chris Glur.
On 2/23/10, John Nowak <john@...> wrote:
>
> On Feb 22, 2010, at 2:59 PM, chris glur wrote:
>
>>> How did you measure the complexity? I don't get it.
>>
>> The number of new concepts introduced.
>
> That's a terrible way to measure complexity.
>
>> For decade/s I ignored Turbo-pascal & used my own P-code compiler,
>> because
>> "turbo" was a fad-word. I've been thinking that blogs are just a
>> passing fad
>> like sub-prime-loans.
>
> This exchange is embarrassing to read.
>
>> I'm not convinced that adding control stuctures to this data-flow-
>> view,
>> is viable, because it would destroy the one-dimensional simplicity.
>
> Yes, just like adding a steering rack to a car.
>
> - jn
>
William Tanksley, Jr — 2010-02-23 18:15:41
chris glur <
crglur@...> wrote:
> Without giving much thought, I speculate that such a one dimensional
> facility, could not be Turing complete.
>
That's what I told you,yes.
I want to be more lazy and just string someone else's transformers
> together, where it's possible.
>
Laziness is a virtue, if you work at it. You're not working at it; you're
just whining.
BTW you've confirmed what I suspected: it's taboo to discuss the
I can well believe that any diversion from the popular wisdom of
> NY [Wall street] was hammered down.
>
You don't make any sense at all. And you haven't discussed any psychological
bases; you've merely blabbered about your pet non-project that you fantasize
will make your work better. If you ever put any work into it, I'll be
surprised. And if you do, it still won't be a concatenative language, and
won't belong on this forum.
If you have any interest in concatenative languages, stay here and learn
with us. If you're only interested in your compositional language, it's off
topic, so we won't discuss it further (this is your first, and much overdue,
warning). If you can discuss psychology we can listen, but so far you
haven't said word one about it, except to fantasize how much better your
ideas would make the world. They might make the world better, but they won't
be discussed anymore on this mailing list.
You are, as of now, moderated. This means that I have to approve your
messages.
== Chris Glur.
-Wm
[Non-text portions of this message have been removed]
John Nowak — 2010-02-24 08:47:23
On Feb 23, 2010, at 1:15 PM, William Tanksley, Jr wrote:
> chris glur <crglur@...> wrote:
>
>> Without giving much thought, I speculate that such a one dimensional
>> facility, could not be Turing complete.
>
> That's what I told you,yes.
I'm not sure if this fits anyone's definition of a "one dimensional
facility", but it may be of interest:
http://www.eecs.usma.edu/webs/people/okasaki/jfp03.ps
- jn
William Tanksley, Jr — 2010-02-24 14:46:58
John Nowak <
john@...> wrote:
> I'm not sure if this fits anyone's definition of a "one dimensional
> facility", but it may be of interest:
> http://www.eecs.usma.edu/webs/people/okasaki/jfp03.ps
>
Indeed it is; it's Okasaki's narrative in which he helps a student whose
keyboard has lost its parentheses, thus requiring him to write only "flat"
programs. Entertaining. That was one of my inspirations for searching for
the zeroone programming language, which Kerby (
http://tunes.org/~iepos/joy.html) finally helped me find.
Kerby modified his combinator search program to work with it (see above);
Apter wrote his own implementation (at
http://www.nsl.com/k/10.k; named 10,
probably because APL users are used to reading everything backwards ;-); and
I wrote my own search program and implementation (at
http://bitbucket.org/wtanksleyjr/tworing/).
A flat concatenative language doesn't meet what Glur expects, though. He
wants a flat language without any capacity for explicit dataflow
manipulation; and that's the one I said won't be a complete programming
language.
- jn
>
-Wm
[Non-text portions of this message have been removed]
stevan apter — 2010-02-24 15:54:49
my first implementation was 01.k. then you or kerby observed that 10
had the nice property that distinct programs had distinct representations
as binary numbers. hence 10.k.
On Feb 24, 2010, at 9:46 AM, William Tanksley, Jr wrote:
> John Nowak <john@...> wrote:
>
> > I'm not sure if this fits anyone's definition of a "one dimensional
> > facility", but it may be of interest:
> > http://www.eecs.usma.edu/webs/people/okasaki/jfp03.ps
> >
>
> Indeed it is; it's Okasaki's narrative in which he helps a student whose
> keyboard has lost its parentheses, thus requiring him to write only "flat"
> programs. Entertaining. That was one of my inspirations for searching for
> the zeroone programming language, which Kerby (
> http://tunes.org/~iepos/joy.html) finally helped me find.
>
> Kerby modified his combinator search program to work with it (see above);
> Apter wrote his own implementation (at http://www.nsl.com/k/10.k; named 10,
> probably because APL users are used to reading everything backwards ;-); and
> I wrote my own search program and implementation (at
> http://bitbucket.org/wtanksleyjr/tworing/).
>
> A flat concatenative language doesn't meet what Glur expects, though. He
> wants a flat language without any capacity for explicit dataflow
> manipulation; and that's the one I said won't be a complete programming
> language.
>
> - jn
> >
>
> -Wm
>
> [Non-text portions of this message have been removed]
>
>
[Non-text portions of this message have been removed]
William Tanksley, Jr — 2010-02-24 16:13:27
stevan apter <
sa@...> wrote:
> my first implementation was 01.k. then you or kerby observed that 10
> had the nice property that distinct programs had distinct representations
> as binary numbers. hence 10.k.
I admit I was joking about your motives; as a stack languages programmer I'm
MORE vulnerable to the charge that I enjoy reading things backwards than any
APL programmer would be. (By the way, to those who don't know APL -- it
executes generally right-to-left, but it's actually read left to right. The
result is surprisingly pleasant, once you learn to pronounce the glyphs; I
could once read 'em, but I can't write 'em. K, J, and Q are more modern
languages that have the same characteristics, but without the non-ASCII
glyphs.)
It was probably me who claimed that; the problem is (like many things I
claim and Kerby didn't comment on) that it's not guaranteed to be true. It's
unlikely that a program will start with an execution combinator, especially
when the executor includes a 'drop' (as my suggestion for a basis did); but
it's possible, since after all the goal combinator may well drop and execute
that exact stack effect. I spent a while using that notation, but it became
unusable once I started trying random bases.
For my current version of tworing/zeroone, I've adopted the convention that
programs are always represented as positive integers, whose leading 1-bit in
binary notation is silently discarded. Thus, '1' is the empty program, and
the others follow from there. (My superoptimizer actually keeps track of the
length, rather than performing a log-base-2 every time I want to check a
program; but that's a minor detail.)
The results are reasonably pleasant. If you're into that kind of thing. :-)
-Wm
[Non-text portions of this message have been removed]