# 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]