Self-interest August 1995

self-interest@lists.selflanguage.org

10 participants
23 discussions

Re: implementation issues (was: types of people)
by David.Ungar＠Eng.Sun.COM 30 Aug '95

30 Aug '95

Right on! And, I don't think Beta quite solves the block problem-- Consider that Beta still needs a built-in thing for if's, whereas ST & Self (& Scheme) don't. This is important because it means that it feels pretty heavyweight to use a user-defined control structure in Beta, compared to ST or Self. Also, consider that Beta has lexical scoping, as Jecel points out. This is great for some things, but does add complexity to the language-- should it be in or out? (Self has a little of it) I am not sure yet. - Dave At 9:51 AM 8/30/95, Mario Wolczko wrote: >Date: Wed, 30 Aug 1995 01:31:59 -0300 >From: "Jecel Mattos de Assumpcao Jr." <jecel(a)lsi.usp.br> >To: self-interest(a)self.sunlabs.com >Subject: implementation issues (was: types of people) > >rainer(a)physik3.gwdg.de (Rainer Blome) mentioned a few ways in which Self >could become more scheme-like, including the tail-recursion optimization. >"ian (i.r.) woollard" <wolfe(a)bnr.ca> also mentioned this optimization in >another message. > >While this optimization is invisible in a normal execution of a program, >if you get an exception and reflect on the activations ( call the >debugger, for example ) you will find that a large chunk of your stack >is missing. This small deviation from strict source semantics is >against the current Self philosophy. > >I am including a more general "tail-call" optimization in tinySelf as >it reduces context allocation ( I use the heap rather than stacks :-( ) >and enhances parallelism in my active object model. When I get some >numbers on this I will post them here. > >lpd(a)aladdin.com (L. Peter Deutsch) didn't like the suggestion of >macros ( I don't either ) and talked about the Beta way. I have >just finished the Beta tutorial and found it really neat how it >doesn't need blocks. I wish objects could be used in the same way >in Self, but it is not possible. It only works because Beta is >a lexically scoped language, while Self is a dynamically scoped >one. > >About non-LIFO blocks: Self doesn't need them as much as Smalltalk >as it is so easy to create unique inline objects with their own >methods and pass them around instead. > >regards, >-- Jecel -- Dave

1 0

design patterns in Self
by Mario.Wolczko＠Eng.Sun.COM 30 Aug '95

30 Aug '95

Date: Wed, 30 Aug 1995 12:43:01 --100 From: Michael.Huebner(a)PrakInf.TU-Ilmenau.DE (Huebner) To: real-self-interest(a)self.sunlabs.com X-Sun-Charset: US-ASCII A time ago I played with Self and was impressed by its way of delegation. Now I'm reading the book "Design Patterns" from Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. They describe wellknown structures in oo programming, like Adapter, Abstract Factory, Wrapper etc. . When I look at the examples in C++ or Smalltalk I think that the often used mechanism of forewarding a message to a component can be done easier with delegation. So my question: Has anybody thought about Design Patterns in Self? Maybe he found in object-based languages different structures of collaborating objects that are often used than those in object-oriented languages. How are the patterns from the book of "the gang of 4" implemented in Self. Are they easier to implement or are there other problems. When I thought about the Wrapper (alias Decorator) pattern, I found that this pattern would look in Self similiar to the solution in Smalltalk. As you might know a wrapper is an object that acts as its component but changes (enriches) the behavior of its component by redefining the original methods of its component. In most cases the original method is called inside this new method implementation. All method calls on methods that haven't been changed are simply forwarded to the component. In oo languages this is done by explicit forwarding: component.selector in ob languages this could be done by delegation: component in a parent slot. It is possible to chain wrappers because the user of a wrapper can't tell the wrapper from its component. My thoughts led to the conlcusion that the delegation solution isn't possible because of the possibility of unwished inferences of private methods of the component with private methods of the wrapper. Example1: works fine +-- Wrapper ----+ +-- Component --+ | component* ...............................> | m = ( ..i.. ) | | | | i = ( A2 ) | { A2 = right for Component } +---------------+ +---------------+ { A2 = false for Wrapper } Example2: unwished inference +-- Wrapper ----+ +-- Component --+ | component* ...............................> | m = ( ..i.. ) | | i = ( A1 ) | | i = ( A2 ) | { A1 = right for Wrapper } +---------------+ +---------------+ { A1 = false for Component } So there is no save use of delegation for the wrapper pattern. A second reason against delegation in this case is that every redefined method must be inside (not be delegated) the wrapperObject to avoid ambiguitious method resolution which leads to big clumsy objects Maybe other patterns gain more from the Self specifics. I would like to hear about it. Michael

1 0

implementation issues (was: types of people)
by Mario.Wolczko＠Eng.Sun.COM 30 Aug '95

30 Aug '95

Date: Wed, 30 Aug 1995 01:31:59 -0300 From: "Jecel Mattos de Assumpcao Jr." <jecel(a)lsi.usp.br> To: self-interest(a)self.sunlabs.com Subject: implementation issues (was: types of people) rainer(a)physik3.gwdg.de (Rainer Blome) mentioned a few ways in which Self could become more scheme-like, including the tail-recursion optimization. "ian (i.r.) woollard" <wolfe(a)bnr.ca> also mentioned this optimization in another message. While this optimization is invisible in a normal execution of a program, if you get an exception and reflect on the activations ( call the debugger, for example ) you will find that a large chunk of your stack is missing. This small deviation from strict source semantics is against the current Self philosophy. I am including a more general "tail-call" optimization in tinySelf as it reduces context allocation ( I use the heap rather than stacks :-( ) and enhances parallelism in my active object model. When I get some numbers on this I will post them here. lpd(a)aladdin.com (L. Peter Deutsch) didn't like the suggestion of macros ( I don't either ) and talked about the Beta way. I have just finished the Beta tutorial and found it really neat how it doesn't need blocks. I wish objects could be used in the same way in Self, but it is not possible. It only works because Beta is a lexically scoped language, while Self is a dynamically scoped one. About non-LIFO blocks: Self doesn't need them as much as Smalltalk as it is so easy to create unique inline objects with their own methods and pass them around instead. regards, -- Jecel

1 0

[jvitek@cui.unige.ch: [mff@CS.Princeton.EDU: David Ungar's talk at ECOOP]]
by Mario.Wolczko＠Eng.Sun.COM 30 Aug '95

30 Aug '95

Date: Wed, 30 Aug 1995 05:28:06 +0200 X400-Recipients: non-disclosure:; Alternate-Recipient: Allowed From: vitek jan <jvitek(a)cui.unige.ch> To: self-interest(a)self.sunlabs.com In-Reply-To: <9508300155.AA10806(a)obj.Eng.Sun.COM> Subject: [mff(a)CS.Princeton.EDU: David Ungar's talk at ECOOP] I have a summary of ECOOP. There is a page on the talk on Self. Would that help? ~jan

1 0

design patterns in Self
by Michael.Huebner＠PrakInf.TU-Ilmenau.DE 30 Aug '95

30 Aug '95

A time ago I played with Self and was impressed by its way of delegation. Now I'm reading the book "Design Patterns" from Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. They describe wellknown structures in oo programming, like Adapter, Abstract Factory, Wrapper etc. . When I look at the examples in C++ or Smalltalk I think that the often used mechanism of forewarding a message to a component can be done easier with delegation. So my question: Has anybody thought about Design Patterns in Self? Maybe he found in object-based languages different structures of collaborating objects that are often used than those in object-oriented languages. How are the patterns from the book of "the gang of 4" implemented in Self. Are they easier to implement or are there other problems. When I thought about the Wrapper (alias Decorator) pattern, I found that this pattern would look in Self similiar to the solution in Smalltalk. As you might know a wrapper is an object that acts as its component but changes (enriches) the behavior of its component by redefining the original methods of its component. In most cases the original method is called inside this new method implementation. All method calls on methods that haven't been changed are simply forwarded to the component. In oo languages this is done by explicit forwarding: component.selector in ob languages this could be done by delegation: component in a parent slot. It is possible to chain wrappers because the user of a wrapper can't tell the wrapper from its component. My thoughts led to the conlcusion that the delegation solution isn't possible because of the possibility of unwished inferences of private methods of the component with private methods of the wrapper. Example1: works fine +-- Wrapper ----+ +-- Component --+ | component* ...............................> | m = ( ..i.. ) | | | | i = ( A2 ) | { A2 = right for Component } +---------------+ +---------------+ { A2 = false for Wrapper } Example2: unwished inference +-- Wrapper ----+ +-- Component --+ | component* ...............................> | m = ( ..i.. ) | | i = ( A1 ) | | i = ( A2 ) | { A1 = right for Wrapper } +---------------+ +---------------+ { A1 = false for Component } So there is no save use of delegation for the wrapper pattern. A second reason against delegation in this case is that every redefined method must be inside (not be delegated) the wrapperObject to avoid ambiguitious method resolution which leads to big clumsy objects Maybe other patterns gain more from the Self specifics. I would like to hear about it. Michael

1 0

Re: Fun with Self...
by Mario.Wolczko＠Eng.Sun.COM 30 Aug '95

30 Aug '95

Ian Woollard writes: 2. [Self 4.0's] memory footprint is *too* big. - It could *really* do with splitting up. 3. It doesn't run on the same hardware as Self3.0 i.e. Sparc 5 32M The footprint is larger than 3.0 because of the extra functionality. If you build a Snapshot that contains the same stuff as the 3.0 release (i.e., core system and old UI), the object heap is 40% smaller (I did a lot of space engineering over the winter). If you're going to use 4.0 for Self programming (as opposed to merely exploration), then it's straightforward to build a snapshot without the Smalltalk stuff, the Web browser and the tutorial. This will just squeeze onto a 32Mb machine without paging to death. A couple more megs of RAM helps a lot. I'd be happy to put such a snapshot up for ftp if there was demand. Thanks for the other comments. -Mario

1 0

[mff@CS.Princeton.EDU: David Ungar's talk at ECOOP]
by Mario.Wolczko＠Eng.Sun.COM 30 Aug '95

30 Aug '95

From: "Mary F. Fernandez" <mff(a)CS.Princeton.EDU> Date: Tue, 29 Aug 1995 21:55:48 -0400 To: self-interest(a)self.sunlabs.com Subject: David Ungar's talk at ECOOP Does anyone know if a transcript of Ungar's talk is online or whether it will appear elsewhere? Thanks, Mary Fernandez mff(a)cs.princeton.edu

1 0

Fun with Self...
by Mario.Wolczko＠Eng.Sun.COM 29 Aug '95

29 Aug '95

Date: Tue, 29 Aug 1995 20:54:00 +0100 From: "ian (i.r.) woollard" <wolfe(a)bnr.ca> To: self-interest(a)self.sunlabs.com Subject: Fun with Self... I managed to get Self4.0 up and running with only a few problems: 1. It's huge to ftp (the link broke 3 times- start again!) 2. It's memory footprint is *too* big. - It could *really* do with splitting up. 3. It doesn't run on the same hardware as Self3.0 i.e. Sparc 5 32M Anyway enough griping, I managed to borrow a Sparc 10 with 64M, and it then ran very well. The UI is pretty sensational. The folding editor is fantastic and the speed is good on the Sparc 10. I started exploring the language and between that and the manual I learnt: - how block structuring works - that 1000 factorial doesn't work with non tail recursive languages using a recursive algorithm. - that 6 digit accuracy floating point doesn't allow easy implementation of base pi arithmetic very well. - dynamic parents are really *very* fast in Self - state machines are easy to write using dynamic parents - that you can have a parent slot in a method and it has interesting effects(!), e.g. you can simulate common lisp variables, or whatever. - that doesNotUnderstand and send: trick is *really* *really* slow(!) - the rest of the language is *lightning* quick. The smalltalk implementation is a really good idea. I hope that it gets more exposure for the group or members of the group from commercial smalltalks vendros. Anyway congrats to the team on a really neat language.

1 0

Re: types of people
by Randall.Smith＠Eng.Sun.COM 29 Aug '95

29 Aug '95

> [...] > the "types of people" are independent of sex [...] Actually, on the Meyers-Briggs T-F index, there is a strong correlation with gender. More women are F, and more men are T. (T=thinking, F= feeling) The axis Dave mentioned in our talk ( J-P ) apparently is almost gender neutral. Anyway, maybe type F go into human interface stuff, and type T go into OS and language design. Still left with an overall dearth of women in computing, even in interface work. A friend of has edited a book on this "where are the women in computer science?" question. Anyone interested message me for info...

1 0

Just for interest. :-)
by Mario.Wolczko＠Eng.Sun.COM 29 Aug '95

29 Aug '95

Date: Mon, 28 Aug 1995 16:10:02 -0700 From: slengy(a)calcomp.com (Sandor Lengyel x2495) To: self-interest(a)self.sunlabs.com Subject: Just for interest. :-) X-Sun-Charset: US-ASCII One and half year ago, I downloaded Self3 (if I remember well). I played with it a little, and waited with interest for the next revision. It arrived, and it is probably very nice. I say, probably, because I downloaded it, and with a 48M of memory on my Sparc IPC is still veryy sloww. P.S. But I am happy that I am on your mailing list, though for now it is Python and/or Java for me. Sandor

1 0

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

1994

1993

1992

1991

1990

Self-interest August 1995