Rafael Kaufmann | 1 Aug 18:01 2000
Picon

Re: Working together

[Thanks to the lack of a Reply-to: field on the list messages' headers,
I sent this only to Ancoron by accident. Here it is.]

I have looked at the BOS page extensively. I haven't been able to find
anything particularly novel or interesting, and the description is
extremely vague. So far, it seems like just Yet Another Barebones OS for
the x86. So, what's the deal, really?

-- Kaufmann, still alive

Brian Rice | 17 Aug 18:43 2000

Pidgin source code snapshot

There are two other messages of mine that have been in the mailing list 
queue for about 12 hours now that discuss this further. So to avoid 
redundancy, here's just the link:
http://www.tunes.org/~water/pidgin.tar.gz

Lee Salzman temporarily has stopped work on it for various reasons, none 
related to actual coding, but at least now you can know that there is 
development going on. As I release new specifications (the site originally 
intended for these documentations seems to have failed as well). If anyone 
else can help with supporting these efforts, please let me know. At this 
point I value consistency and communication over anything else.

At any rate, if people are interested in taking the new documentation and 
specifications I'll be publishing and updating the Lisp implementation of 
Slate, then please let me know. I am also still doing advanced research on 
Slate, mostly with respect to Tunes, so the documents I release will be 
enough for a really good, usable language anyway.

Thanks for your interest and patience,
~

RE01 Rice Brian T. EM2 | 17 Aug 07:44 2000
Picon

Status of Slate implementation and documentation.

I have a lot of explanations and conceptual developments to document, and I
was hoping for a while to use the Diktuon web-database that was being
developed. Because of server problems, it seems I must move it to Bespin, so
perhaps simply integrating it with the Zope Review system is the goal now.
(Tril, input on this?)

Speaking of the Zope Review system, I'd like to know whether Tril considers
this well-developed enough for full-scale use and replacing of the existing
Tunes Review Subproject, apart from considerations of "whether people will
use it" (since I know that I, being stuck on the ship for a while, could
devote time to the areas appropriate to what I work on). If Tril and the
rest of the Tunes members consider it ready, then I'd like to see some
effort put into the public aspect of the Tunes Review site, such as
announcement, invitations for editors, re-configuring the web server to have
tunes.org/Review/ point to the Zope database, et cetera.

As for Slate implementation, Lee Salzman was working on a "pidgin" dialect
of Slate (Self-style meta-objects, in other words), but seems to have come
upon some problems which he hasn't detailed (and which are not related to
the actual coding process). So I've asked him to publish his current results
and I'd also like him to outline the rest of the planned implementation in
comments (Lee, I know you'll read this... please don't drag your feet on
this). So in any case, I'll deliver on my promise to update the
documentation and explanation and plans, and Tril and a few others have
expressed willingness to update the Lisp implementation of Slate. Let's act
on that for now, and consider Lee's plans for the long-run. Lee was also
working on a compiler framework for a dynamically-optimizing interactive
system for Slate (much like Self, only coded to support the meta-object
protocol that is currently being developed), and was doing a lot of research
in that direction. I'd like him to publish any results he has at this point
(Continue reading)

RE01 Rice Brian T. EM2 | 17 Aug 07:21 2000
Picon

Reflection and quotation

I'd like to discuss an interesting aspect of Tunes that previously had not
explicitly occurred to me. That is reflection on the quotation function of a
language. As a preliminary survey, I'd like to know if any of you all know
of languages (experimental or otherwise) that have interesting forms of
quotation, or even possible a notion of quotation which can be dynamically
modified.

To be precise, I mean any set of functions working between the type system
associated with the input to the evaluator and other type systems (commonly
ASCII text and such). In Lisp, there is of course the special form (or is it
just a primitive function?) QUOTE which takes in symbols or lists of symbols
and returns the equivalent CONS tree. (As of the present moment, the web is
unavailable to me, so if some kind person would paste in the CLHS or R5RS
specifications of QUOTE, it would be appreciated :). I've been following
discussions in the Concatenative Languages mailing list, so I know of some
interesting issues that Bill Tanksley and Brent Kerby have been working with
in Joy, Conk, and such.

Basically, if we consider EVAL = UNQUOTE o APPLY as a basic equation for
describing this aspect of the language implementation, we have a general
means of thinking about the problem. Of course, for Tunes we always want to
have useful ways to apply (sic) partial evaluation of parameters on the
evaluating context (to produce different contexts). So this means that our
APPLY will have varying semantics: for instance, we could curry it with
additional parameters or use the Tunes principle of quotienting to have it
consider its source input at a different level (say, instead of textual
strings, abstract tokens). This isn't anything unusual... it's just the
factoring out of the lexer from the parser-backend combination. So in a more
general sense, we're just considering the generic ability to re-factor the
implementation.
(Continue reading)

Kyle Lahnakoski | 18 Aug 04:21 2000

Re: Reflection and quotation


I consider quoting as only a special form of referencing: referencing by
unique 
attribute.  

First I will make a simple, but necessary, distinction.  A function is a
static entity.  Much like in set theory a function can be seen as a set
of ordered pairs, a function can not DO anything.  Performing the
operation that a function specifies is a different concept altogether. 
Furthermore, the code that specifies the function is also a different
concept.  There are many languages that can express the same function. 
A function, as defined above, can be referred to using a variety of
methods.  The simplest is through the use of source code; the code
identifys/specifies a function uniquely.  But we could also a unique
name, or integer ID.  Note these three examples all require a frame of
reference to be effective references.  The source code needs a language
definition, the unique name needs a name space and the unique ID needs a
key space.  Using this unique structure to refer to the function called
referencing.  Specifically: using source code to refer to a function is
called quoting. 

The more general concept of referencing is what I define next. 
Referencing is the use of unique attributes to identify an object
uniquely.  For example I can refer to myself using "The Kyle Lahanakoski
that lives in Canada".  Computers refer to data structures using memory
addresses though pointers.  

Everything appears to be a reference.  In the case of functions: source
code and compiled bytes are both references to the same function object,
but the function object is never realized in the machine.  Every
(Continue reading)

RE01 Rice Brian T. EM2 | 18 Aug 05:38 2000
Picon

RE: Reflection and quotation


> -----Original Message-----
> From: Kyle Lahnakoski [mailto:kyle <at> arcavia.com]
> Sent: Thursday, August 17, 2000 7:21 PM
> To: RE01 Rice Brian T. EM2
> Cc: 'tunes <at> tunes.org'
> Subject: Re: Reflection and quotation

> I consider quoting as only a special form of referencing: 
> referencing by unique attribute.  

That's odd. I thought that Tunes defined attributes in terms of functions.
:)

Indeed, right on the HLL Semantics page
(http://www.tunes.org/HLL/semantics.html), attributes are listed as unary
functions. Now, if you want Tunes goals, then meta-programming has to be
considered, and higher-order attributes simply *are* functions, whether you
like that or not.

In fact, many languages do this in order to provide "object-orientedness".
And if memory serves me correctly, ML has higher-order references, since it
can hold a reference (not a pointer) as a variable, which can in turn also
be a higher-order functional term.

Attributes, in other words, are just artifacts of a view on a system that
supposes the notion of state implicitly.

> First I will make a simple, but necessary, distinction.  A 
> function is a
(Continue reading)

Tril | 18 Aug 14:13 2000

Mailing list changes (again)

Sympa had some issues and I switched all the lists to GNU Mailman
(www.list.org).  The page to start is
http://bespin.org/cgi-bin/mailman/listinfo

I have converted the last few months of Sympa archives, which were not
previously accessible, into Mailman.  The archives from before June 2000
are still in Wilma (http://lists.tunes.org/cgi-bin/wilma).  The new
Mailman archives do not have a search engine right now. 

If you want to change any of your list settings or to SUBSCRIBE or
UNSUBSCRIBE using the Mailman web interface you will have to request a
password from Mailman (first URL, above).  It will assign you a random
password and e-mail it to the address you subscribed under, then you enter
the password on the web to change options.  You need a separate password
for each list, but you can change them later to something easy to
remember. 

If you don't want to use the web interface, but instead through e-mail,
you can learn how to do e-mail commands to Mailman by mailing
LISTNAME-request <at> tunes.org and a subjet or body of "help" (Any listname
will do, but you have to pick one). 

Comments on this change to my private mail address dem <at> tunes.org, thanks.

--

-- 
David Manifold <dem <at> tunes.org> http://bespin.dhs.org/~dem/
This message is placed in the public domain.

Kyle Lahnakoski | 18 Aug 15:00 2000

Re: Reflection and quotation


"RE01 Rice Brian T. EM2" wrote:
> 
> > -----Original Message-----
> > From: Kyle Lahnakoski [mailto:kyle <at> arcavia.com]
> > Sent: Thursday, August 17, 2000 7:21 PM
> > To: RE01 Rice Brian T. EM2
> > Cc: 'tunes <at> tunes.org'
> > Subject: Re: Reflection and quotation
> 
> > I consider quoting as only a special form of referencing:
> > referencing by unique attribute.
> 
> That's odd. I thought that Tunes defined attributes in terms of functions.
> :)
>
> Indeed, right on the HLL Semantics page
> (http://www.tunes.org/HLL/semantics.html), attributes are listed as unary
> functions. Now, if you want Tunes goals, then meta-programming has to be
> considered, and higher-order attributes simply *are* functions, whether you
> like that or not.
> 
> In fact, many languages do this in order to provide "object-orientedness".
> And if memory serves me correctly, ML has higher-order references, since it
> can hold a reference (not a pointer) as a variable, which can in turn also
> be a higher-order functional term.
> 
> Attributes, in other words, are just artifacts of a view on a system that
> supposes the notion of state implicitly.

(Continue reading)

Jecel Assumpcao Jr | 18 Aug 20:18 2000

(very long) development styles

Hi,

Lynn Maxson and I have been discussing our different approaches to
software development. I suggested that it might be more interesting for
us to discuss concrete examples, I he came up with a simple math
problem (a box has B beetles and S spiders, with a total legs L=6*B+8*S
of 46. What are B and S?) and showed me how he would solve it using his
SL/I system. I coded a simple exhaustive search in Self.

The I proposed a more complex problem of the same style: finding a
solution to the "peg solitaire" game. There is some information about
this at:

  http://www.inwap.com/pdp10/hbaker/hakmem/games.html#item75

Unlike most of the problems that I am interested in, this one should
highlight the strengths of such different styles as object oriented
programming, logic programming and functional programming. This very
long email shows my solution using the first two styles. Lynn has coded
this problem in PL/I and is thinking of doing it in SL/I and Trilogy.
He also suggested that if people from the Tunes list could do the same
for other languages (including the various ones they are creating) it
might be a very important addition to the language review subproject.

Most of the examples that have been coded in more than one language are
too trivial to give the reader a good impression of that language. See:

  http://www.ionet.net/~timtroyr/funhouse/beer.html

I am sure that you Tunesers can come up with much better examples than
(Continue reading)

Attila Lendvai (101 | 18 Aug 17:08 2000
Picon

Hello to all!


  Hi!

  I'm a newcomer. I find Tunes very intresting, again togather: VERY :)

  Background: I'm a student, I'm very intrested in the art of programming,
I think I know everything about C++, it implies that I'm looking for
better languages :). I use BeOS as my primary platform, write C++ programs
with extensive multithreading. That's enough...

  In fact it's just a test mail if I'm on the list or not.

  Hope I'll be able to contribute to Tunes.

  bye,

  - 101.

PS: I'm the one who is promoting Mozart and LX.

------------------------------------------------------------------------------
Technical University  of Budapest	WWW:		   www.inf.bme.hu/~101
 Faculty of Electrical Engineering 	E-Mail:			101 <at> inf.bme.hu
  and  Computer  Science  - Student	BeOS dev. number:		E-3048
------------------------------------------------------------------------------


Gmane