An interesting paper was discovered
connected with the off topic comments
on geometical algorithm design that appeared
in this group some months ago
so I thought I would pass along the link -
not the final answer but a step in that
direction.
see
"The Spatio-Temporal Topological Operator Dimension,
a Hyperstructure for Multidimensional Spatio-Temporal
Exploration and Analysis" (Adobe pdf format)
by P. Marchand
at
http://sirs.scg.ulaval.ca/yvanbedard/reserve/download/these/These_PMarchand.pdf
Thanks
Jim Pannozzi
P.S., Lisp and/or APL2 remain the 2 ideal languages to implement
this sort of thing (though a newcomer on the block, J,
may also be a candidate).
Reference:
http://groups.google.com/group/comp.lang.lisp/browse_thread/thread/f8aed36ae7884e4d/38c6da50dfc26741?lnk=st&q=takuon+lisp&rnum=10&hl=en#38c6da50dfc26741
(from comp.lang.lisp April 2005).
The conceptual breakthrough that I seek and which I was probably
not clear enough about when I started this thread, is fundamentally
3D in nature. It involves the geometric manipulation of 3D shapes (not
2d!)
in a 3D perspective projection space. It additionally involves things which
have not yet been invented - most particulary, a correspondence between
software development algorithmic constructs and some sort of geometrical
or fractal shapes. I eventually decided that fractals were probably going
to
be the most likely attempt at realizing this.
That is not to detract from or take away from the dataflow concepts
or other 2d visualization attempts - they are just are different idea
and not at all what I was suggesting.
Musashi wrote:
> P.S., Lisp and/or APL2 remain the 2 ideal languages to implement
> this sort of thing (though a newcomer on the block, J,
> may also be a candidate).
Can you explain what properties make Lisp and APL2 ideal for this task?
--
Dr Jon D Harrop, Flying Frog Consultancy
http://www.ffconsultancy.com
"Jon Harrop" <······@jdh30.plus.com> wrote in message
······························@ptn-nntp-reader02.plus.net...
> Musashi wrote:
>> P.S., Lisp and/or APL2 remain the 2 ideal languages to implement
>> this sort of thing (though a newcomer on the block, J,
>> may also be a candidate).
>
> Can you explain what properties make Lisp and APL2 ideal for this task?
>
> --
> Dr Jon D Harrop, Flying Frog Consultancy
> http://www.ffconsultancy.com
The ideal language for this task does not exist but might actually
arrise out of the search for the algorithm - fractal structure shape
correspondence.
(Side thought... hmmm... interesting, to discover the correspondence
is to discover a new computational language - shapes that compute).
Ignore for a moment the obvious - easy self referentiality of lisp or
the superiour array indexing of APL2.
The key for me, and it is only an intuition, is that at some level the
language used
must either have built in memetic meta structures, or else have the facility
to easily
build them. By "memetic meta structures" I mean constructs which have some
analogy, or similarity, however vague or sharp, however useful or apparently
useless,
with intelligent processes in the real world - with our own minds, for
example.
In the case of Lisp, it is the list data structure and the fact that the
language itself,
and all of the constructs, are built upon this foundation. (It is
irrelevant,
if our minds really do NOT use lists, if for example, they work by an
elaborate
scheme of arcanely linked associations, because it is the model,
however amateurish, that counts).
In the case of APL2, it is the symbology itself, the reduction of common
mathematical,
logical or set operations to a single symbol, and therefore the replication
of mathematical, logical or set reasoning by a flow of such symbols.
The human psychology of thinking is filled with such symbol associations
and most certainly has NOTHING to do with a bunch
of lines of C++ code with the likes of IF... ELSE... WHILE ... etc.
Drawbacks: Rerember the goal - as others have pointed out,
this may be a Quixotic quest for a non-existent holy grail because
1. There may be no such correspondence as I am seeking and
2. Even if exists, it may be so multi-dimensional as to be impossible
to project onto 3d space and therefore non-visualizable.
Thanks
Jim
Musashi wrote:
> In the case of APL2, it is the symbology itself, the reduction of common
> mathematical,
> logical or set operations to a single symbol, and therefore the replication
> of mathematical, logical or set reasoning by a flow of such symbols.
> The human psychology of thinking is filled with such symbol associations
> and most certainly has NOTHING to do with a bunch
> of lines of C++ code with the likes of IF... ELSE... WHILE ... etc.
perhaps the human brain is more like Prolog than Lisp or C++.
--
Frank Bu�, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Frank Buss <··@frank-buss.de> writes:
> perhaps the human brain is more like Prolog than Lisp or C++.
No, it is most definitely spaghetti code written in very low level
assembler.
--
http://www.david-steuber.com/
The UnBlog: An island of conformity in a sea of quirks.
The lowest click through rate in Google's AdSense program.
----------------------------------------------------------------------
David Steuber wrote:
> Frank Buss <··@frank-buss.de> writes:
>
>
>>perhaps the human brain is more like Prolog than Lisp or C++.
>
>
> No, it is most definitely spaghetti code written in very low level
> assembler.
>
Actually, the power of the human mind argues against "intelligent
design". Only intelligence can produce something as daft as spaghetti
code, and spaghetti code could never achieve the rudiments of
intelligence, such as simple perception.
But you are right on one thing: the instruction set is small.
--
Kenny
Why Lisp? http://wiki.alu.org/RtL_Highlight_Film
"I've wrestled with reality for 35 years, Doctor, and I'm happy to state
I finally won out over it."
Elwood P. Dowd, "Harvey", 1950
Kenny Tilton <·······@nyc.rr.com> writes:
> David Steuber wrote:
> > Frank Buss <··@frank-buss.de> writes:
> >
> >>perhaps the human brain is more like Prolog than Lisp or C++.
> > No, it is most definitely spaghetti code written in very low level
> > assembler.
> >
>
> Actually, the power of the human mind argues against "intelligent
> design". Only intelligence can produce something as daft as spaghetti
> code, and spaghetti code could never achieve the rudiments of
> intelligence, such as simple perception.
I would think that spaghetti code is an indication of the lack of
intelligent design.
> But you are right on one thing: the instruction set is small.
--
http://www.david-steuber.com/
The UnBlog: An island of conformity in a sea of quirks.
http://www.david-steuber.com/snippets/Boycott_Sony/
----------------------------------------------------------------------
David Steuber wrote:
> Kenny Tilton <·······@nyc.rr.com> writes:
>
>
>>David Steuber wrote:
>>
>>>Frank Buss <··@frank-buss.de> writes:
>>>
>>>
>>>>perhaps the human brain is more like Prolog than Lisp or C++.
>>>
>>>No, it is most definitely spaghetti code written in very low level
>>>assembler.
>>>
>>
>>Actually, the power of the human mind argues against "intelligent
>>design". Only intelligence can produce something as daft as spaghetti
>>code, and spaghetti code could never achieve the rudiments of
>>intelligence, such as simple perception.
>
>
> I would think that spaghetti code is an indication of the lack of
> intelligent design.
Have you ever worked on spaghetti code? In my first assignment ever I
helped two guys try to get some spaghetti code to work. One needs to be
pretty bright to make spaghetti code work. Only a conscious designer can
come up with and make work spaghetti design. So, again, the argument
from intelligent design works against the existence of God.
My breakthrough as a developer came when I realized that any time I was
working hard I must have created bad design. ie, I am not smart enough
to design well, but I am sensible enough to acknowledge when I have
created bad code. That does not require intelligence, it requires an
aversion to work, and that I have.
Stupid-smart people fall in love with their first design and treat
problems arising from bad choices as mere annoyances to be brushed away
with deft insertion of baling wire and duct tape. Nature don't play dat.
--
Kenny
Why Lisp? http://wiki.alu.org/RtL_Highlight_Film
"I've wrestled with reality for 35 years, Doctor, and I'm happy to state
I finally won out over it."
Elwood P. Dowd, "Harvey", 1950
Kenny Tilton <·······@nyc.rr.com> writes:
> Stupid-smart people fall in love with their first design and treat
> problems arising from bad choices as mere annoyances to be brushed
> away with deft insertion of baling wire and duct tape. Nature don't
> play dat.
Hmmm, I think teh bailing wire and duct time sounds exactly like how
evolution works. Nature doesn't get to refactor; it just keeps on
patching.
-Peter
--
Peter Seibel * ·····@gigamonkeys.com
Gigamonkeys Consulting * http://www.gigamonkeys.com/
Practical Common Lisp * http://www.gigamonkeys.com/book/
Kenny Tilton <·······@nyc.rr.com> wrote:
+---------------
| My breakthrough as a developer came when I realized that any time I was
| working hard I must have created bad design. ie, I am not smart enough
| to design well, but I am sensible enough to acknowledge when I have
| created bad code. That does not require intelligence, it requires an
| aversion to work, and that I have.
+---------------
Indeed! The Robert A. Heinlein short story "The Tale of the Man Who
Was Too Lazy To Fail" [a chapter of his novel "Time Enough For Love:
The Lives of Lazarus Long"] explores this phenomenon in considerable
detail. You'll probably love it, if you haven't already read it.
It's about a man who hated work so much that he worked very,
*very* hard so that he wouldn't have to do any (and suceeded!). ;-}
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
Rob Warnock wrote:
> Kenny Tilton <·······@nyc.rr.com> wrote:
> +---------------
> | My breakthrough as a developer came when I realized that any time I was
> | working hard I must have created bad design. ie, I am not smart enough
> | to design well, but I am sensible enough to acknowledge when I have
> | created bad code. That does not require intelligence, it requires an
> | aversion to work, and that I have.
> +---------------
>
> Indeed! The Robert A. Heinlein short story "The Tale of the Man Who
> Was Too Lazy To Fail" [a chapter of his novel "Time Enough For Love:
> The Lives of Lazarus Long"] explores this phenomenon in considerable
> detail. You'll probably love it, if you haven't already read it.
> It's about a man who hated work so much that he worked very,
> *very* hard so that he wouldn't have to do any (and suceeded!). ;-}
Yep. What is a macro? A little bit of trickier programming that makes a
whole lot of other programming effort disappear.
Note that the very hard work is inventive, challenging, fascinating...
you know, neat! And a huge payoff is in sight, so as hard as the work
may be, it is easy and fun to undertake.
--
Kenny
Why Lisp? http://wiki.alu.org/RtL_Highlight_Film
"I've wrestled with reality for 35 years, Doctor, and I'm happy to state
I finally won out over it."
Elwood P. Dowd, "Harvey", 1950
Kenny Tilton <·······@nyc.rr.com> writes:
> David Steuber wrote:
>
> > I would think that spaghetti code is an indication of the lack of
> > intelligent design.
>
> Have you ever worked on spaghetti code? In my first assignment ever I
Yes I have. Every existing code base I've ever worked on contained at
least a little bit of spaghetti.
> helped two guys try to get some spaghetti code to work. One needs to
> be pretty bright to make spaghetti code work. Only a conscious
> designer can come up with and make work spaghetti design. So, again,
> the argument from intelligent design works against the existence of
> God.
I think you argue from a false premise. Spaghetti code arises from
adding more code without properly factoring and integrating with the
existing code. It starts out as the fastest way to do the job, but
gets exponentially more complex as new bits are added.
> Stupid-smart people fall in love with their first design and treat
> problems arising from bad choices as mere annoyances to be brushed
> away with deft insertion of baling wire and duct tape. Nature don't
> play dat.
Yes it does. And dice are most certainly involved.
All DNA needs to do is survive long enough to replicate itself.
Everything else is irrelevant details.
--
http://www.david-steuber.com/
The UnBlog: An island of conformity in a sea of quirks.
http://www.david-steuber.com/snippets/Boycott_Sony/
Kenny Tilton wrote:
> David Steuber wrote:
>> I would think that spaghetti code is an indication of the lack of
>> intelligent design.
> Have you ever worked on spaghetti code? In my first assignment ever I
> helped two guys try to get some spaghetti code to work. One needs to be
> pretty bright to make spaghetti code work. Only a conscious designer can
> come up with and make work spaghetti design. So, again, the argument
> from intelligent design works against the existence of God.
> My breakthrough as a developer came when I realized that any time I was
> working hard I must have created bad design. ie, I am not smart enough
> to design well, but I am sensible enough to acknowledge when I have
> created bad code. That does not require intelligence, it requires an
> aversion to work, and that I have.
> Stupid-smart people fall in love with their first design and treat
> problems arising from bad choices as mere annoyances to be brushed away
> with deft insertion of baling wire and duct tape. Nature don't play dat.
It's a tough call, sometimes... Insufficient laziness is probably
one of my failings as a programmer.
It's easy for me to fall into a trap of continually tweaking the same
(working) functions, over and over and over again, every time I think
of a faster or more general way to do something. When I know that
something can be done in NlogN, for example, I can't *STAND* to have
the N-squared implementation of it in my code - even if the N-squared
version is a one-liner that's easy to check, and the NlogN algorithm,
um, isn't. So a lot of folks have trouble with my code.
And I still use a lot of different design paradigms. I write OO
code when a problem seems to fit OO, but I also use functional or
data-directed or ADT code or other things they don't teach kids
in school these days when they seem to fit a problem, and then I
get OOP-heads who've never seen such things assuming that the
whole has no design discipline at all.
Eh... spaghetti, bumming, tweaking, alternate design paradigms ...
tomaytoe, tomawtoe...
Bear
"Ray Dillinger" <····@sonic.net> wrote in message
······························@news.sonic.net...
> ...
It's easy for me to fall into a trap of continually tweaking the same
(working) functions, over and over and over again, every time I think
of a faster or more general way to do something. When I know that
something can be done in NlogN, for example, I can't *STAND* to have
the N-squared implementation of it in my code - even if the N-squared
version is a one-liner that's easy to check, and the NlogN algorithm,
um, isn't. So a lot of folks have trouble with my code.
> ...
With Geometrical Algorithm design, the tweak
might very well be a slight alteration in a 3d shape.
That's the attraction of the idea, that you can
switch to and fro a textual representation
or a visual (algorithmic shape) representation.
But computing NlogN timings from shapes,
and seeing it visually,
that's something I'm not sure of at all.
Maybe some sort of algorithmic animation
if the theory permits it.
Thanks
Jim Pannozzi
"Ray Dillinger" <····@sonic.net> wrote in message
······························@news.sonic.net...
> Kenny Tilton wrote:
>
>> David Steuber wrote:
>
>>> I would think that spaghetti code is an indication of the lack of
>>> intelligent design.
>
>> Have you ever worked on spaghetti code? In my first assignment ever I
>> helped two guys try to get some spaghetti code to work. One needs to be
>> pretty bright to make spaghetti code work. Only a conscious designer can
>> come up with and make work spaghetti design. So, again, the argument from
>> intelligent design works against the existence of God.
>
>> My breakthrough as a developer came when I realized that any time I was
>> working hard I must have created bad design. ie, I am not smart enough to
>> design well, but I am sensible enough to acknowledge when I have created
>> bad code. That does not require intelligence, it requires an aversion to
>> work, and that I have.
>
>> Stupid-smart people fall in love with their first design and treat
>> problems arising from bad choices as mere annoyances to be brushed away
>> with deft insertion of baling wire and duct tape. Nature don't play dat.
>
> It's a tough call, sometimes... Insufficient laziness is probably
> one of my failings as a programmer.
>
> It's easy for me to fall into a trap of continually tweaking the same
> (working) functions, over and over and over again, every time I think
> of a faster or more general way to do something. When I know that
> something can be done in NlogN, for example, I can't *STAND* to have
> the N-squared implementation of it in my code - even if the N-squared
> version is a one-liner that's easy to check, and the NlogN algorithm,
> um, isn't. So a lot of folks have trouble with my code.
>
> And I still use a lot of different design paradigms. I write OO
> code when a problem seems to fit OO, but I also use functional or
> data-directed or ADT code or other things they don't teach kids
> in school these days when they seem to fit a problem, and then I
> get OOP-heads who've never seen such things assuming that the
> whole has no design discipline at all.
>
> Eh... spaghetti, bumming, tweaking, alternate design paradigms ...
> tomaytoe, tomawtoe...
>
> Bear
>