On Fri, Jan 25, 2013 at 3:35 PM, David Clark <[email protected]>wrote:

> This post concerns the “eleventh rule”.****
>
> ** **
>
> Why would parallelism be tied to Haskell?  Was there parallel code before
> Haskell (invented in 1985) and it’s not obvious when Haskell actually got
> the ability to execute code in parallel?  Mainframes had multiple CPUs
> running concurrently by the late 1960’s, early 70’s.  I remember an IMSAI
> computer that used 256 8080 CPUs in 1975 when I bought my first
> microcomputer.****
>
> ** **
>
> Our CPU’s are inherently sequential like C, Java etc. so is there a
> bug-ridden, slow implementation of C in every version of Haskell?****
>
> ** **
>
> For those who think programming AGI would work well in Haskell or Lisp,
> ask yourself this question : Will a working AGI be fully programmed by
> people or mostly by itself?****
>
> ** **
>
> If you believe that 1, 10 or 2000 algorithms need be created by people and
> then all that is needed for liftoff is data that can be learned by the AGI
> or uploaded, then languages like C++, Java, C#, Haskell or Lisp might be an
> acceptable choice for you.  If you think that programmers must get an AGI
> to some level of intelligence and then it will be smart enough to continue
> to program itself, then you think that eventually the AGI must be built on
> a language where the AGI can act like a programmer from the inside rather
> than just from the outside.
>

I completely agree, eventually the AGI has to be able to program itself
from the inside, much like we humans do it, or at least how those of us
that have some measure of self-control over our thoughts.

I believe that to create an AGI may require thousands of algorithms, and
many people working on it in likely a distributed fashion.
My vision is that someone can make an optimization of an algorithm or new
feature on their computer, and propagate it through the network,  either
through an F2F darknet for initial testing, as well as through the use of
traditional peer-reviewed distributions for mass audiences.

 It'll be a while, perhaps a year or more before I have support for OR
sentences allowing for alternative algorithms in the code,  though it is
certainly in the roadmap.

being human speakable it'll be more accessible to average people than Lisp,
C or PPN.

though yes, certainly am not implementing in PPN,
and when there is a byte code, it'll be SOV, closer to RPN.

****
>
> ** **
>
> As we all know, there is no difference between code and data in a computer
> other than how it is interpreted.  If you think that a small amount of code
> can be produced and then data itself can be executed as if it were code
> then you believe that programming (eventually if not from the start) must
> be done from the inside while the program runs.****
>
> ** **
>
> Haskell doesn’t have the ability to program itself, especially if it is
> currently running.  I think Haskell has many other fundamental flaws when
> used to create AGI but this alone should stop it’s use.****
>
> ** **
>
> Can Haskell:****
>
> **1.       **Coordinate many users or tasks that want access to a single
> data structure?****
>
> **2.       **Haskell wants it’s functions to have no “side effects” but
> how then do you coordinate many functions accessing the same data structure?
> ****
>
> **3.       **What kind of macro structure do all these functions have?
> Are all functions in the same name space?  How does this work over many
> CPUs in a single memory space, over a local area network and over the
> internet?****
>
> **4.       **What tools does Haskell have for coordinating multiple
> programmers working on the same project at the same time, from a distance
> (local area network or over the internet)?****
>
> **5.       **What mechanism does Haskell have to encapsulate multiple
> functions with a data structure?****
>
> **6.       **Does Haskell have a full functioned database facility or
> does it depend on an outside RDMS system?****
>
> ** **
>
> Do you believe that AGI is possible without a fast and flexible data store
> that is huge, smart and flexible enough to span multiple computers in many
> locations?  Is RDMS the answer?  Would you use the built in triggers and
> stored procedures to make the data consistent and fast?  If so, where does
> Haskell fit into that?  Would it be better if Haskell was put into a RDMS
> and allowed to be the triggers and stored procedures?  What if relational
> data is fine but more flexibility is needed to create an AGI?  Do you see
> the definition for RDMS changing any time soon?****
>
> ** **
>
> This is a relatively long post BUT unlike Ben, I think that the language
> and system that an AGI is created in matters.  I am definitely interested
> in opposing views!****
>
> ** **
>
> David Clark****
>
> ** **
>
> *From:* Juan Carlos Kuri Pinto [mailto:[email protected]]
> *Sent:* January-23-13 3:37 PM
> *To:* AGI
> *Subject:* [agi] Greenspun's tenth rule and eleventh rule ^_^****
>
> ** **
>
> Greenspun's tenth rule: Any sufficiently complicated C or Fortran program
> contains an ad hoc, informally-specified, bug-ridden, slow implementation
> of half of Common Lisp.****
>
> ** **
>
> http://en.wikipedia.org/wiki/Greenspun's_tenth_rule****
>
> ** **
>
> Greenspun's eleventh rule: Any sufficiently parallel program written in a
> non-purely functional programming language, like C, Assembler, Java, Lisp,
> Scheme, and OCaml, contains an ad hoc, informally-specified, bug-ridden,
> slow implementation of half of Haskell.****
>   *AGI* | Archives <https://www.listbox.com/member/archive/303/=now>
> <https://www.listbox.com/member/archive/rss/303/5037279-a88c7a6d> | 
> Modify<https://www.listbox.com/member/?&;>Your Subscription
> <http://www.listbox.com>
>



-------------------------------------------
AGI
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/21088071-f452e424
Modify Your Subscription: 
https://www.listbox.com/member/?member_id=21088071&id_secret=21088071-58d57657
Powered by Listbox: http://www.listbox.com

Reply via email to