[Fonc] Google Code shutdown

[Norman Nunley]

It appears that the Maru repository has not yet been migrated to github.
(See: https://code.google.com/p/support/wiki/ReadOnlyTransition ) Were
there any plans to make that happen? Is there still interest in the project?

The primary benefit for doing so is that the read-only page will provide a
redirecting link to the new repository location. It will also preserve any
change history that managed to make it to the repository.

Norman

[Faré]

Post by Norman Nunley
It appears that the Maru repository has not yet been migrated to github.
(See: https://code.google.com/p/support/wiki/ReadOnlyTransition ) Were there
any plans to make that happen? Is there still interest in the project?
The primary benefit for doing so is that the read-only page will provide a
redirecting link to the new repository location. It will also preserve any
change history that managed to make it to the repository.

There is a mirror there:
https://github.com/attila-lendvai/maru

Attila did some further cleanups and added support for bootstrapping
from Common Lisp, in branches; though there were bugs / discrepancies
in the Common Lisp version that he never resolved, by lack of
documentation / understanding of what the specification was, exactly.

—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org
Suggesting I hate people with religion because I hate religion is like
suggesting I hate people with cancer because I hate cancer. — Ricky Gervais

[Julian Leviston]

It’d be nice if there was a bootstrap from a myriad of common, popular languages (like, say, JS)


But is this just another way of saying “Hey, we need something like OMeta”? hm. I don’t know.

It’s very interesting for pedagogical reasons, but the complete lack of comments makes things incredibly difficult for “the beginner”.

But, hey, perhaps it’s not for “the beginner”?

Julian

http://www.getcontented.com.au/ - Amazing website creation service. Get a professional, distinguished yet highly affordable website today.
http://www.getcontented.com.au/flute_websites.html - website design & hosting service for flutists

Post by Faré

Post by Norman Nunley
It appears that the Maru repository has not yet been migrated to github.
(See: https://code.google.com/p/support/wiki/ReadOnlyTransition ) Were there
any plans to make that happen? Is there still interest in the project?
The primary benefit for doing so is that the read-only page will provide a
redirecting link to the new repository location. It will also preserve any
change history that managed to make it to the repository.

https://github.com/attila-lendvai/maru
Attila did some further cleanups and added support for bootstrapping
from Common Lisp, in branches; though there were bugs / discrepancies
in the Common Lisp version that he never resolved, by lack of
documentation / understanding of what the specification was, exactly.
—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org
Suggesting I hate people with religion because I hate religion is like
suggesting I hate people with cancer because I hate cancer. — Ricky Gervais
_______________________________________________
Fonc mailing list
http://mailman.vpri.org/mailman/listinfo/fonc_mailman.vpri.org

[Attila Lendvai]

Post by Faré
https://github.com/attila-lendvai/maru
Attila did some further cleanups and added support for bootstrapping
from Common Lisp, in branches; though there were bugs / discrepancies
in the Common Lisp version that he never resolved, by lack of
documentation / understanding of what the specification was, exactly.

the bootstrap from CL gets quite far, but my interest faded away
mostly due to the lack of interest from others. i also didn't feel
convinced that the C eval couldn't/shouldn't be more minimal, but then
i don't understand the whole thing quite good enough to judge.

and yes, it would have helped a lot if there were more tests and
especially more *organized* tests. IIRC i did put some effort into
reorganizing the tests as my understanding of the system grew.

i also put some effort into separating bootstrap stages. where IIRC
stage-1 is the eval written in C or CL, stage-2 is the
generated/compiled eval made by running the maru compiler in stage-1,
and stage-3 is the result of running the maru compiler using stage-2
(and hopefully bit-by-bit equivalent with stage-2).

[Faré]

Ian's answer.

—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org
"If you do not pick the simplest explanation, you're being manipulated." —
and if you're being manipulated, you're an agent of EVIL.
For only EVIL specializes in manipulation.


---------- Forwarded message ----------
From: Ian Piumarta <***@gmail.com>
Date: Wed, Aug 12, 2015 at 8:27 AM
Subject: Re: [Fonc] Google Code shutdown
To: Norman Nunley <***@gmail.com>, Faré <***@gmail.com>, Julian
Leviston <***@leviston.net>


Dear Norman, François, Julian,

(Sorry for the direct-mail spam. For silly reasons, I cannot post to
that list any more.)

The code.google repo was always just a copy of my Mercurial repo,
which is (and will continue to be, Network Solutions' occasional
attempts to repossess my domains notwithstanding) reified here:

http://piumarta.com/software/maru/

That page includes both the `original' version (the one on Google
code) and a newer version (which had a better, almost real, compiler
but didn't quite reach the point of self-support before I lost
momentum).

(BTW: there is also a `newest' version, since last year or so, that is
more than 10 times faster OOTB and designed with ease of runtime
dynamic compilation in mind, but it's still not quite finished and
I've been too lazy/procrastinatious [sic] to upload it anywhere.)

I'm not a huge fan of git, or github (or anything that favours
fragmentation over collaboration). There is also no reason to assume
github will be any more permanent than Google code, and lots of
reasons to believe that if/when it goes it will be `lights out without
warning' from which, at least, Google had the good grace (and
PR-sensitivity) to spare us. So I probably should put a link to the
above URL in the Google code page before it freezes over.

Julian: I am very sorry about the lack of comments in my code. When a
brain gets to be as old and tired as mine it only has space left to
remember one way to do any given thing, so looking back at code
written several years ago holds absolutely no surprises; the way I did
anything then is the only way I can imagine doing the same thing now.
I guess code comments are a premature casualty of looming dementia.
;-)

And yes, it would be nice to have a bootstrap from any popular
language. Even better: how about a single abstract general-purpose
`generic' description of how to bootstrap a system, that could
generate a concrete bootstrap in any popular and locally-convenient
language? But that was just the original idea of Maru (or at least of
its immediate predecessor). To date, however, the only `back-ends'
I've managed to make are C and x86 assembler, and neither in a form
that could really be called general-purpose. And the only serious
front end is a textual representation of the intermediate
representation. And the intermediate representation lacks any of the
rigour that such an ideal deserves.

The simplest possible bijections from any GP programming system to
extended lambda calculus, and from ELC to any GP computer hardware,
still eludes.

(FWLIW, I've been trying to do this off and on since 1992 when I
worked for a while on ANDF.

https://en.wikipedia.org/wiki/Architecture_Neutral_Distribution_Format

I still think ANDF's [and TDF/TenDRA before it] big mistake was their
death grip on declarative specification. If they had introduced state
into their model, then made the model executable and self-modifying,
it could have been our missing pair of bijections. Instead dealing
with ANDF felt exactly like trying to write a nontrivial program using
only CPP macros.)

Thanks to all three of you for continuing to show some interest in
this stuff. It should inspire me to take up the cause in some fashion
once more, spare time permitting.

Regards
Ian

[Faré]

Post by Faré
And yes, it would be nice to have a bootstrap from any popular
language. Even better: how about a single abstract general-purpose
`generic' description of how to bootstrap a system, that could
generate a concrete bootstrap in any popular and locally-convenient
language? But that was just the original idea of Maru (or at least of
its immediate predecessor). To date, however, the only `back-ends'
I've managed to make are C and x86 assembler, and neither in a form
that could really be called general-purpose. And the only serious
front end is a textual representation of the intermediate
representation. And the intermediate representation lacks any of the
rigour that such an ideal deserves.
The simplest possible bijections from any GP programming system to
extended lambda calculus, and from ELC to any GP computer hardware,
still eludes.

That's the approach taken by Shen (and before it Qi):
implement the entire language on top of a rather minimal "kernel
lambda" lisp layer, that itself is implemented in CL, JS, C, Java,
etc.
http://shenlanguage.org/download_form.html
https://github.com/Shen-Language/shen-sources

Problem is they forget to complete the bootstrap with a compiler.

—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org
"An idealist is one who, on noticing that a rose smells better than a
cabbage, concludes that it will also make better soup." — H.L. Mencken

[Alexis Read]

I was looking at Pure, as a possible language atop maru, for a GP computing
system:
http://purelang.bitbucket.org/

Additionally, for real-time deterministic use ie. the flexibility that Rust
purports to offer, I think maru would benefit from a realtime GC solution.
I've started replacing the mark-sweep gc.c code (from the maru 2.4 branch)
with a realtime version based on this paper:
http://liu.diva-portal.org/smash/get/diva2:20899/FULLTEXT01.pdf

The solution is very small, in-keeping with the maru codebase.
Also note that, as Pure is similarly small (and decoupled from it's
backend), and supports equational programming, you could theoretically
bring formal verification to the maru/pure codebase ie. it can prove itself.

Nothing to show yet as my C knowledge is rusty to say the least, but i'll
upload it to a repo when I have something workable. Of course if anyone is
good with C, help would be appreciated!

Post by Faré

Post by Faré
And yes, it would be nice to have a bootstrap from any popular
language. Even better: how about a single abstract general-purpose
`generic' description of how to bootstrap a system, that could
generate a concrete bootstrap in any popular and locally-convenient
language? But that was just the original idea of Maru (or at least of
its immediate predecessor). To date, however, the only `back-ends'
I've managed to make are C and x86 assembler, and neither in a form
that could really be called general-purpose. And the only serious
front end is a textual representation of the intermediate
representation. And the intermediate representation lacks any of the
rigour that such an ideal deserves.
The simplest possible bijections from any GP programming system to
extended lambda calculus, and from ELC to any GP computer hardware,
still eludes.

implement the entire language on top of a rather minimal "kernel
lambda" lisp layer, that itself is implemented in CL, JS, C, Java,
etc.
http://shenlanguage.org/download_form.html
https://github.com/Shen-Language/shen-sources
Problem is they forget to complete the bootstrap with a compiler.
—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics•
http://fare.tunes.org
"An idealist is one who, on noticing that a rose smells better than a
cabbage, concludes that it will also make better soup." — H.L. Mencken
_______________________________________________
Fonc mailing list
http://mailman.vpri.org/mailman/listinfo/fonc_mailman.vpri.org

[Kjell Godo]

@Julian

i am your "beginner"

and i would like to document Maru

and document it with a testCase thing

if anyone would explain Maru to me

except that

i already have too much to do

but if anyone would agree

to keep explaining it to me

i would like to convert

it into a tree

Post by Alexis Read
I was looking at Pure, as a possible language atop maru, for a GP
http://purelang.bitbucket.org/
Additionally, for real-time deterministic use ie. the flexibility that
Rust purports to offer, I think maru would benefit from a realtime GC
solution. I've started replacing the mark-sweep gc.c code (from the maru
http://liu.diva-portal.org/smash/get/diva2:20899/FULLTEXT01.pdf
The solution is very small, in-keeping with the maru codebase.
Also note that, as Pure is similarly small (and decoupled from it's
backend), and supports equational programming, you could theoretically
bring formal verification to the maru/pure codebase ie. it can prove itself.
Nothing to show yet as my C knowledge is rusty to say the least, but i'll
upload it to a repo when I have something workable. Of course if anyone is
good with C, help would be appreciated!

Post by Faré

Post by Faré
And yes, it would be nice to have a bootstrap from any popular
language. Even better: how about a single abstract general-purpose
`generic' description of how to bootstrap a system, that could
generate a concrete bootstrap in any popular and locally-convenient
language? But that was just the original idea of Maru (or at least of
its immediate predecessor). To date, however, the only `back-ends'
I've managed to make are C and x86 assembler, and neither in a form
that could really be called general-purpose. And the only serious
front end is a textual representation of the intermediate
representation. And the intermediate representation lacks any of the
rigour that such an ideal deserves.
The simplest possible bijections from any GP programming system to
extended lambda calculus, and from ELC to any GP computer hardware,
still eludes.

implement the entire language on top of a rather minimal "kernel
lambda" lisp layer, that itself is implemented in CL, JS, C, Java,
etc.
http://shenlanguage.org/download_form.html
https://github.com/Shen-Language/shen-sources
Problem is they forget to complete the bootstrap with a compiler.
—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics•
http://fare.tunes.org
"An idealist is one who, on noticing that a rose smells better than a
cabbage, concludes that it will also make better soup." — H.L. Mencken
_______________________________________________
Fonc mailing list
http://mailman.vpri.org/mailman/listinfo/fonc_mailman.vpri.org

[Kurt Stephens]

Post by Alexis Read
I've started replacing the mark-sweep gc.c code (from the maru
http://liu.diva-portal.org/smash/get/diva2:20899/FULLTEXT01.pdf

Interesting Paper...

Baker's Treadmill (mentioned in the paper) is relatively easy to
implement on top of malloc() and has guaranteed real-time behavior
without requiring a concurrent collector. A maru lisp implementation be
an interesting project. :)

-- KAS

[Dirk Pranke]

I for one would also be quite interested in a "newest" version of Maru, if
that helps inspire Ian to post it somewhere :).

-- Dirk

Post by Faré
Ian's answer.
—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics•
http://fare.tunes.org
"If you do not pick the simplest explanation, you're being manipulated." —
and if you're being manipulated, you're an agent of EVIL.
For only EVIL specializes in manipulation.
---------- Forwarded message ----------
Date: Wed, Aug 12, 2015 at 8:27 AM
Subject: Re: [Fonc] Google Code shutdown
Dear Norman, François, Julian,
(Sorry for the direct-mail spam. For silly reasons, I cannot post to
that list any more.)
The code.google repo was always just a copy of my Mercurial repo,
which is (and will continue to be, Network Solutions' occasional
http://piumarta.com/software/maru/
That page includes both the `original' version (the one on Google
code) and a newer version (which had a better, almost real, compiler
but didn't quite reach the point of self-support before I lost
momentum).
(BTW: there is also a `newest' version, since last year or so, that is
more than 10 times faster OOTB and designed with ease of runtime
dynamic compilation in mind, but it's still not quite finished and
I've been too lazy/procrastinatious [sic] to upload it anywhere.)
I'm not a huge fan of git, or github (or anything that favours
fragmentation over collaboration). There is also no reason to assume
github will be any more permanent than Google code, and lots of
reasons to believe that if/when it goes it will be `lights out without
warning' from which, at least, Google had the good grace (and
PR-sensitivity) to spare us. So I probably should put a link to the
above URL in the Google code page before it freezes over.
Julian: I am very sorry about the lack of comments in my code. When a
brain gets to be as old and tired as mine it only has space left to
remember one way to do any given thing, so looking back at code
written several years ago holds absolutely no surprises; the way I did
anything then is the only way I can imagine doing the same thing now.
I guess code comments are a premature casualty of looming dementia.
;-)
And yes, it would be nice to have a bootstrap from any popular
language. Even better: how about a single abstract general-purpose
`generic' description of how to bootstrap a system, that could
generate a concrete bootstrap in any popular and locally-convenient
language? But that was just the original idea of Maru (or at least of
its immediate predecessor). To date, however, the only `back-ends'
I've managed to make are C and x86 assembler, and neither in a form
that could really be called general-purpose. And the only serious
front end is a textual representation of the intermediate
representation. And the intermediate representation lacks any of the
rigour that such an ideal deserves.
The simplest possible bijections from any GP programming system to
extended lambda calculus, and from ELC to any GP computer hardware,
still eludes.
(FWLIW, I've been trying to do this off and on since 1992 when I
worked for a while on ANDF.
https://en.wikipedia.org/wiki/Architecture_Neutral_Distribution_Format
I still think ANDF's [and TDF/TenDRA before it] big mistake was their
death grip on declarative specification. If they had introduced state
into their model, then made the model executable and self-modifying,
it could have been our missing pair of bijections. Instead dealing
with ANDF felt exactly like trying to write a nontrivial program using
only CPP macros.)
Thanks to all three of you for continuing to show some interest in
this stuff. It should inspire me to take up the cause in some fashion
once more, spare time permitting.
Regards
Ian
_______________________________________________
Fonc mailing list
http://mailman.vpri.org/mailman/listinfo/fonc_mailman.vpri.org