Pharo-dev
By thread
pharo-dev@lists.pharo.org
By month
Messages by month
- ----- 2026 -----
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2025 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2024 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- 3 participants
- 144636 messages
get.pharo.org/travis+vm failing: Package 'pharo-vm-core:i386' has no installation candidate
by Dale Henrichs
It looks like the following script started failing within the last 5
days sometime:
wget --quiet -O - get.pharo.org/travis+vm | bash
getting this error (on ubunutu12.04):
Fetched 18.5 kB in 4s (4,028 B/s)
Reading package lists... Done
Reading package lists... Done
Building dependency tree
Reading state information... Done
Package pharo-vm-core:i386 is not available, but is referred to by
another package.
This may mean that the package is missing, has been obsoleted, or
is only available from another source
E: Package 'pharo-vm-core:i386' has no installation candidate
5 days ago this is what the same log section looked like[1]:
Fetched 15.6 kB in 1s (9,597 B/s)
Reading package lists... Done
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following package was automatically installed and is no longer required:
libgeos-3.2.2
Use 'apt-get autoremove' to remove them.
Suggested packages:
pharo-vm-desktop:i386
The following NEW packages will be installed:
pharo-vm-core:i386
0 upgraded, 1 newly installed, 0 to remove and 174 not upgraded.
Need to get 14.5 MB of archives.
Then 2 days ago, the above error started happening[2]:
Fetched 18.5 kB in 4s (4,214 B/s)
Reading package lists... Done
Reading package lists... Done
Building dependency tree
Reading state information... Done
Package pharo-vm-core:i386 is not available, but is referred to by
another package.
This may mean that the package is missing, has been obsoleted, or
is only available from another source
E: Package 'pharo-vm-core:i386' has no installation candidate
Presumably something change in the last week to break things....pretty
much depend upon this working to do much of my testing on travis-ci:(
Dale
[1] https://travis-ci.org/dalehenrich/tode/jobs/49400710
[2] https://travis-ci.org/dalehenrich/tode/jobs/49776435
Feb. 9, 2015
Re: [Pharo-dev] ||
by Hernán Morales Durand
2015-02-08 19:46 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>
>
> On Sun, Feb 8, 2015 at 1:26 PM, Hernán Morales Durand <
> hernan.morales(a)gmail.com> wrote:
>
>> Hi Eliot,
>>
>> 2015-02-08 12:50 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>>
>>> Hi Hernan,
>>>
>>>
>>> On Feb 7, 2015, at 12:55 PM, Hernán Morales Durand <
>>> hernan.morales(a)gmail.com> wrote:
>>>
>>> Hi Eliot,
>>>
>>> 2015-02-07 14:48 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>>>
>>>> Hi Hernan,
>>>>
>>>> On Sat, Feb 7, 2015 at 7:41 AM, Hernán Morales Durand <
>>>> hernan.morales(a)gmail.com> wrote:
>>>>
>>>>>
>>>>> 2015-02-07 5:59 GMT-03:00 kilon alios <kilon.alios(a)gmail.com>:
>>>>>
>>>>>> Personally I don't like Pragmas, they have not convinced me so far
>>>>>> that they fit the style of Smalltalk syntax. I have to confess though I
>>>>>> never liked descriptive elements and languages .
>>>>>>
>>>>>>
>>>>> Me neither. Actually the pragma idea is not wrong per se, it is the
>>>>> tag syntax to write them which bothers me. Because the world can be
>>>>> described with tags if you start that path.
>>>>>
>>>>
>>>> How exactly is the syntax wrong?
>>>>
>>>
>>> I am not saying syntax is wrong, I just don't like it because:
>>>
>>> 1) Adds another level of representation inside an already reflective
>>> system.
>>>
>>>
>>> What do you mean exactly? I don't have clear recollection of whether
>>> they were in Squeak in 08 or if I ported then, but at that time
>>> CompiledMethod had a properties object, and pragmas were merged into this.
>>> What I did do was save a lot of space getting rid if the properties object
>>> unless a method needed it. And IIRC I changed the implementing class from
>>> MethodProperties to AdditionalMethodState. So there was no additional
>>> level of representation. a) the syntax was already there fir primitives
>>> and b) the state was already there in methods.
>>>
>>>
>> The place where pragmas are located internally are not an issue for me.
>> The fact that special tags are not following the message pattern template
>> is. It says there is a special collector, parser, validator, etc. a whole
>> mechanism because something is - supposedly - not easily expressible with
>> plain reflective messages.
>>
>
> I don't understand. Pragmas are literal message patterns, period. There
> is an exception for the primitive pragma so that the variable name for a
> primitive's error code can be introduced, but that's part of primitive
> parsing, not general pragma parsing. At least in Squeak here's the code:
>
> Parser>>pragmaSequence
> "Parse a sequence of method pragmas."
> [
> (self matchToken: #<)
> ifFalse: [ ^ self ].
> self pragmaStatement.
> (self matchToken: #>)
> ifFalse: [ ^ self expected: '>' ] ] repeat
>
> pragmaStatement
> "Read a single pragma statement. Parse all generic pragmas in the form of:
> <key1: val1 key2: val2 ...> and remember them, including primitives."
> | selector arguments words index keyword |
> (hereType = #keyword or: [ hereType = #word or: [ hereType = #binary ] ])
> ifFalse: [ ^ self expected: 'pragma declaration' ].
>
> " This is a ugly hack into the compiler of the FFI package. FFI should be
> changed to use propre pragmas that can be parsed with the code here. "
> (here = #apicall: or: [ here = #cdecl: ])
> ifTrue: [ ^ self externalFunctionDeclaration ].
>
> selector := String new.
> arguments := OrderedCollection new.
> words := OrderedCollection new.
> [ hereType = #keyword or: [ (hereType = #word or: [ hereType = #binary ])
> and: [ selector isEmpty ] ] ] whileTrue: [
> index := self startOfNextToken + requestorOffset.
> selector := selector , self advance.
> words add: (index to: self endOfLastToken + requestorOffset).
> (selector last = $: or: [ selector first isLetter not ])
> ifTrue: [ arguments add: (self pragmaLiteral: selector) ] ].
> selector numArgs ~= arguments size
> ifTrue: [ ^ self expected: 'pragma argument' ].
> (Symbol hasInterned: selector
> ifTrue: [ :value | keyword := value])
> ifFalse: [
> keyword := self
> correctSelector: selector wordIntervals: words
> exprInterval: (words first first to: words last last)
> ifAbort: [ ^ self fail ] ].
> self addPragma: (Pragma keyword: keyword arguments: arguments asArray).
> ^ true
>
> I can't speak for how its been implemented in Opal but I'd be surprised if
> it is using separate machinery. The Squeak code above is different from
> the normal message parsing precisely so that it can insist that arguments
> are only literals (pragmaLiteral: above).
>
>
Ok, I will stop here because I see contradictions and no way we can agree
on them.
Amazing code BTW.
>
>> 2) It could be done with plain common message sends.
>>>
>>>
>>> No it can't. Common sends are executable and we don't want pragmas
>>> executed when the method is run, we want the pragma executed when the
>>> method is added, or analysed. That was what was ugly about the use of plain
>>> sends in e.f. VMMaker, that there had to be lots of empty implementations
>>> of the messages used for metadata.
>>>
>>
>>> So using normal sends
>>> - prevents the metadata from being directly executed because executing
>>> them when the method is run is wrong
>>> - confuses meta level and normal level, putting them at the same level,
>>> and hence...
>>> - confusing for the programmer because its not obvious what's metadata
>>> and what's a normal send
>>> - makes analysis harder for the same reason
>>>
>>>
>> We are talking about different worlds here.
>>
>
> So let;s stop talking because I;m getting frustrated. I make a valid
> point about the inability to use normal selectors and you ignore my point.
>
>
>> Theoretically I could mark methods this way:
>>
>> (Pragma
>> for: (ASTBlockClosure >> #value:)
>> selector: #primitive:
>> arguments: (Array with: 60)) addPragma.
>>
>
>> So the annotations could be written with normal message sends.
>> And they could be tool supported, so no one gets confused.
>>
>
> So this is embedded in a method? So it gets evaluated every time the
> method is executed? Surely you're not serious.
>
>
Precisely that is what should happens behind the curtains. I cannot believe
why is so hard to understand.
>
>>
>>> 3) Should be (to me) "hidden" from method pane, and displayed by a
>>> specific tool inside the system browser.
>>>
>>>
>>> I disagree. I want to see the pragma. It has essential information
>>> that shouldn't be hidden. I want to edit it easily.
>>>
>>
>> I want to see and edit the pragma too, when I am really interested. Just
>> like with the bytecodes.
>>
>>
>>> And how can you in the one hand say it can be implemented as a normal
>>> message send a d at the same time want it hidden? Be consistent :-)
>>>
>>>
>> There is no inconsistency. I am saying they should be hidden from the
>> method body.
>>
>> The method pane you see in the browser should be used to send messages to
>> your modeling domain (which already imposes its own difficulty), not being
>> exploited to add meta information where meta could belong to
>> instrumentation analysis (lint, profiling) or UI building (keymap, menu) or
>> whatever excuse found to add more tags.
>>
>> I wonder how one could refactor this method:
>>
>> Greetings>>helloWorld
>> <year: 2015>
>> <status: #toDo>
>> <author: 'Hernán'>
>> <scope: #private>
>>
>> <soapOperationName: #HelloWorld>
>> <soapDocumentation: #'Returns Hello World'>
>> <soapResult: #String>
>> <soapStyle: #RPC>
>>
>> <rmiOperationName: #HelloWorld>
>> <rmiDocumentation: #'Returns Hello World'>
>> <rmiResult: #String>
>>
>> <asn1OperationName: #HelloWorld>
>> <asn1Documentation: #'Returns Hello World'>
>> <asn1Result: #UTF8String>
>>
>> <dcomOperationName: #HelloWorld>
>> <dcomDocumentation: #'Returns Hello World'>
>> <dcomResult: #String>
>>
>> ^'Hello World'
>>
>
> Thus:
>
> first, date & author can be recovered from the method source via
> timestamp, but if you want to separate the author of the text from the last
> editor of the method then...
>
> Greetings>>helloWorld
> <addDocPage: #Greetings year: 2015 status: #toDo author: 'Hernán' scope:
> #private>
> <soapOperation: #HelloWorld documentation: #'Returns Hello World' resultType:
> #String style: #RPC>
> <rmiOperation: #HelloWorld documentation: #'Returns Hello World' resultType:
> #String>
> <asn1OperationOperation: #HelloWorld documentation: #'Returns Hello
> World' resultType:#UTF8String>
> <dcomOperation: #HelloWorld documentation: #'Returns Hello World' resultType:
> #String>
>
> ^'Hello World'
>
> and then have implementations of e.g.
> SoapInterfaceBuilder>>soapOperation:documentation:returnType:style:,
> ASN1InterfaceBuilder>> asn1Operation:documentation:returnType:style:,
> etc, that add the method to the interface they're building.
>
> So, assuming your interface methods are in a class hierarchy from
> SomeSoapInterfaceSubclass up to SomeSoapInterfaceBaseClass building looks
> like, e.g.:
>
> | builder |
> builder := SoapInterfaceBuilder new.
> (Pragma
> allNamed: #soapOperation:documentation:returnType:style:
> from: SomeSoapInterfaceSubclass
> to: SomeSoapInterfaceBaseClass) do:
> [:pragma|
> builder method: pragma method.
> pragma message sendTo: builder]
>
> But if you're able you'll do it just like this:
>
> Greetings>>helloWorld
> <addDocPage: #Greetings year: 2015 status: #toDo author: 'Hernán' scope:
> #private>
> <externalOperation: #HelloWorld documentation: #'Returns Hello World'
> resultType: #UTF8String style: #RPC>
>
> ^'Hello World'
>
> implement the same method in the various builders, and coerce UTF8String
> to String in those that only handle simple notions of string type.
>
> Why on _earth_ are people writing 17 pragmas where I see only two?
>
>
Not the point I wanted to address, but thanks for the example and answering
the questions patiently
Cheers,
Hernán
Feb. 8, 2015
Re: [Pharo-dev] ||
by Nicolai Hess
2015-02-08 22:26 GMT+01:00 Hernán Morales Durand <hernan.morales(a)gmail.com>:
>
> It could be broken because I pressed Alt+M in <gtInspectorAction> and
> nothing happens:
>
> gtInspectorActionBrowse
> <gtInspectorAction>
> ^ GLMGenericAction new
> action: [ self browse ];
> icon: GLMUIThemeExtraIcons glamorousBrowse;
> title: 'Browse'
>
selecting the word gtInspectorAction and pressing Alt+n works, it
opens the "Senders or Users" MessageBrowser.
Feb. 8, 2015
Re: [Pharo-dev] ||
by Eliot Miranda
On Sun, Feb 8, 2015 at 1:26 PM, Hernán Morales Durand <
hernan.morales(a)gmail.com> wrote:
> Hi Eliot,
>
> 2015-02-08 12:50 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>
>> Hi Hernan,
>>
>>
>> On Feb 7, 2015, at 12:55 PM, Hernán Morales Durand <
>> hernan.morales(a)gmail.com> wrote:
>>
>> Hi Eliot,
>>
>> 2015-02-07 14:48 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>>
>>> Hi Hernan,
>>>
>>> On Sat, Feb 7, 2015 at 7:41 AM, Hernán Morales Durand <
>>> hernan.morales(a)gmail.com> wrote:
>>>
>>>>
>>>> 2015-02-07 5:59 GMT-03:00 kilon alios <kilon.alios(a)gmail.com>:
>>>>
>>>>> Personally I don't like Pragmas, they have not convinced me so far
>>>>> that they fit the style of Smalltalk syntax. I have to confess though I
>>>>> never liked descriptive elements and languages .
>>>>>
>>>>>
>>>> Me neither. Actually the pragma idea is not wrong per se, it is the tag
>>>> syntax to write them which bothers me. Because the world can be described
>>>> with tags if you start that path.
>>>>
>>>
>>> How exactly is the syntax wrong?
>>>
>>
>> I am not saying syntax is wrong, I just don't like it because:
>>
>> 1) Adds another level of representation inside an already reflective
>> system.
>>
>>
>> What do you mean exactly? I don't have clear recollection of whether
>> they were in Squeak in 08 or if I ported then, but at that time
>> CompiledMethod had a properties object, and pragmas were merged into this.
>> What I did do was save a lot of space getting rid if the properties object
>> unless a method needed it. And IIRC I changed the implementing class from
>> MethodProperties to AdditionalMethodState. So there was no additional
>> level of representation. a) the syntax was already there fir primitives
>> and b) the state was already there in methods.
>>
>>
> The place where pragmas are located internally are not an issue for me.
> The fact that special tags are not following the message pattern template
> is. It says there is a special collector, parser, validator, etc. a whole
> mechanism because something is - supposedly - not easily expressible with
> plain reflective messages.
>
I don't understand. Pragmas are literal message patterns, period. There
is an exception for the primitive pragma so that the variable name for a
primitive's error code can be introduced, but that's part of primitive
parsing, not general pragma parsing. At least in Squeak here's the code:
Parser>>pragmaSequence
"Parse a sequence of method pragmas."
[
(self matchToken: #<)
ifFalse: [ ^ self ].
self pragmaStatement.
(self matchToken: #>)
ifFalse: [ ^ self expected: '>' ] ] repeat
pragmaStatement
"Read a single pragma statement. Parse all generic pragmas in the form of:
<key1: val1 key2: val2 ...> and remember them, including primitives."
| selector arguments words index keyword |
(hereType = #keyword or: [ hereType = #word or: [ hereType = #binary ] ])
ifFalse: [ ^ self expected: 'pragma declaration' ].
" This is a ugly hack into the compiler of the FFI package. FFI should be
changed to use propre pragmas that can be parsed with the code here. "
(here = #apicall: or: [ here = #cdecl: ])
ifTrue: [ ^ self externalFunctionDeclaration ].
selector := String new.
arguments := OrderedCollection new.
words := OrderedCollection new.
[ hereType = #keyword or: [ (hereType = #word or: [ hereType = #binary ])
and: [ selector isEmpty ] ] ] whileTrue: [
index := self startOfNextToken + requestorOffset.
selector := selector , self advance.
words add: (index to: self endOfLastToken + requestorOffset).
(selector last = $: or: [ selector first isLetter not ])
ifTrue: [ arguments add: (self pragmaLiteral: selector) ] ].
selector numArgs ~= arguments size
ifTrue: [ ^ self expected: 'pragma argument' ].
(Symbol hasInterned: selector
ifTrue: [ :value | keyword := value])
ifFalse: [
keyword := self
correctSelector: selector wordIntervals: words
exprInterval: (words first first to: words last last)
ifAbort: [ ^ self fail ] ].
self addPragma: (Pragma keyword: keyword arguments: arguments asArray).
^ true
I can't speak for how its been implemented in Opal but I'd be surprised if
it is using separate machinery. The Squeak code above is different from
the normal message parsing precisely so that it can insist that arguments
are only literals (pragmaLiteral: above).
> 2) It could be done with plain common message sends.
>>
>>
>> No it can't. Common sends are executable and we don't want pragmas
>> executed when the method is run, we want the pragma executed when the
>> method is added, or analysed. That was what was ugly about the use of plain
>> sends in e.f. VMMaker, that there had to be lots of empty implementations
>> of the messages used for metadata.
>>
>
>> So using normal sends
>> - prevents the metadata from being directly executed because executing
>> them when the method is run is wrong
>> - confuses meta level and normal level, putting them at the same level,
>> and hence...
>> - confusing for the programmer because its not obvious what's metadata
>> and what's a normal send
>> - makes analysis harder for the same reason
>>
>>
> We are talking about different worlds here.
>
So let;s stop talking because I;m getting frustrated. I make a valid point
about the inability to use normal selectors and you ignore my point.
> Theoretically I could mark methods this way:
>
> (Pragma
> for: (ASTBlockClosure >> #value:)
> selector: #primitive:
> arguments: (Array with: 60)) addPragma.
>
> So the annotations could be written with normal message sends.
> And they could be tool supported, so no one gets confused.
>
So this is embedded in a method? So it gets evaluated every time the
method is executed? Surely you're not serious.
>
>
>> 3) Should be (to me) "hidden" from method pane, and displayed by a
>> specific tool inside the system browser.
>>
>>
>> I disagree. I want to see the pragma. It has essential information that
>> shouldn't be hidden. I want to edit it easily.
>>
>
> I want to see and edit the pragma too, when I am really interested. Just
> like with the bytecodes.
>
>
>> And how can you in the one hand say it can be implemented as a normal
>> message send a d at the same time want it hidden? Be consistent :-)
>>
>>
> There is no inconsistency. I am saying they should be hidden from the
> method body.
>
> The method pane you see in the browser should be used to send messages to
> your modeling domain (which already imposes its own difficulty), not being
> exploited to add meta information where meta could belong to
> instrumentation analysis (lint, profiling) or UI building (keymap, menu) or
> whatever excuse found to add more tags.
>
> I wonder how one could refactor this method:
>
> Greetings>>helloWorld
> <year: 2015>
> <status: #toDo>
> <author: 'Hernán'>
> <scope: #private>
>
> <soapOperationName: #HelloWorld>
> <soapDocumentation: #'Returns Hello World'>
> <soapResult: #String>
> <soapStyle: #RPC>
>
> <rmiOperationName: #HelloWorld>
> <rmiDocumentation: #'Returns Hello World'>
> <rmiResult: #String>
>
> <asn1OperationName: #HelloWorld>
> <asn1Documentation: #'Returns Hello World'>
> <asn1Result: #UTF8String>
>
> <dcomOperationName: #HelloWorld>
> <dcomDocumentation: #'Returns Hello World'>
> <dcomResult: #String>
>
> ^'Hello World'
>
Thus:
first, date & author can be recovered from the method source via timestamp,
but if you want to separate the author of the text from the last editor of
the method then...
Greetings>>helloWorld
<addDocPage: #Greetings year: 2015 status: #toDo author: 'Hernán' scope:
#private>
<soapOperation: #HelloWorld documentation: #'Returns Hello World'
resultType:
#String style: #RPC>
<rmiOperation: #HelloWorld documentation: #'Returns Hello World'
resultType:
#String>
<asn1OperationOperation: #HelloWorld documentation: #'Returns Hello
World' resultType:#UTF8String>
<dcomOperation: #HelloWorld documentation: #'Returns Hello World'
resultType:
#String>
^'Hello World'
and then have implementations of e.g.
SoapInterfaceBuilder>>soapOperation:documentation:returnType:style:,
ASN1InterfaceBuilder>> asn1Operation:documentation:returnType:style:, etc,
that add the method to the interface they're building.
So, assuming your interface methods are in a class hierarchy from
SomeSoapInterfaceSubclass up to SomeSoapInterfaceBaseClass building looks
like, e.g.:
| builder |
builder := SoapInterfaceBuilder new.
(Pragma
allNamed: #soapOperation:documentation:returnType:style:
from: SomeSoapInterfaceSubclass
to: SomeSoapInterfaceBaseClass) do:
[:pragma|
builder method: pragma method.
pragma message sendTo: builder]
But if you're able you'll do it just like this:
Greetings>>helloWorld
<addDocPage: #Greetings year: 2015 status: #toDo author: 'Hernán' scope:
#private>
<externalOperation: #HelloWorld documentation: #'Returns Hello
World' resultType:
#UTF8String style: #RPC>
^'Hello World'
implement the same method in the various builders, and coerce UTF8String to
String in those that only handle simple notions of string type.
Why on _earth_ are people writing 17 pragmas where I see only two?
Until we have discussed this I'm not going to waste effort responding to
the points below. I think we're talking past each other. I don't see your
Greetings example displaying any understanding of what pragma syntax is, or
how pragmas can, or should be used. So let's look at the above. Perhaps
we can both be less exhausted.
The <literalMessagePattern> syntax predates pragmas. It was used first for
>>> numeric primitives in Smalltalk-76 or Smalltalk-80. Squeak extended it
>>> with primitive:module:. I and others extended it to include arbitrary
>>> literal message patterns. The syntax of a literal message pattern is the
>>> syntax of a send with no receiver and only literal arguments.
>>>
>> The use of this syntax means
>>> a) no new syntax
>>> b) each pragma is potentially executable
>>> c) methods using specific pragmas can be found using "find senders"
>>> d) the execution side of a pragma can be found using "find implementors"
>>>
>>> So what's wrong with that? How is it wrong to use a common Smalltalk
>>> object, a Message, that is well-supported in the system, for method
>>> metadata?
>>>
>>>
>> I get that pragmas are messages, but they assume an implicit receiver,
>> which actually depends on context. If I understood right with pragmas
>> always receiver = destination?
>>
>>
>> Not for pragmas that are just labels. And what's destination? In the
>> menu building example above the destination"is the menu but the receiver is
>> the menu builder. So I think that what the receiver is depends on usage.
>>
>> If you change things in the communication model (receiver, sender,
>> message, etc.), by removing or adding elements, you have a loss in the
>> message because it gets harder to reconstruct the message send.
>>
>>
>> I don't understand this. Can you expand?
>>
>>
> Now I realize how far we are from understanding. But I start to feel tired
> to write about communication models here.
>
>
>>
>> Consider
>>
>> <eventRegistration>
>> | eventRegistration |
>> { eventRegistration }.
>> self eventRegistration.
>>
>> which of them "it sounds like" you cannot infer their purpose?
>>
>>
>> I don't get the example, because of the confusion of meta layers.
>>
>>
> Now you understand me :)
>
>
>> <eventRegistration>
>> says "this is metadata"
>>
>>
> yes, but not what type of metadata is. Is metadata for instrumentation? is
> for documentation?
>
>
>> | eventRegistration |
>>
>> says "this is a bug in the method because the variable isn't used, and eg
>> Opal will remove it so it won't be there".
>>
>>
> but you get this is a local variable supposed to be used in the current
> method. You can get the scope easily.
>
>
>
>> { eventRegistration }.
>> I guess you mean { #eventRegistration }. If so this is the same. An
>> optimizing compiler will delete it.
>>
>>
> Yes. The idea there is the same, you would associate the eventRegistration
> as an Array element to be accessed in the current method for example.
>
>
>> self eventRegistration.
>> says "send myself eventRegustration". Which /isn't/ what's wanted.
>>
>> So for me only the pragma implies "this method is to be registered with
>> the event system". The middle two say "I am a bug, or syntax error". The
>> last one says "I am a normal send".
>>
>>
> To me says "this method contains code which defines an event". Where the
> event is defined should need more metadata until explicit semantics are
> enough complete.
>
>>
>>
>> To me the first because you need the context MyClass>>methodName
>> and you need to browse the pragma to get its purpose.
>>
>>
>>
>>>
>>>> There are other ways to add metadata to methods. Without tagging.
>>>>
>>>
>>> Haven't we discussed that? Putting metadata off to the side introduces
>>> a bookkeeping problem. It is a bad idea.
>>>
>>
>> Yes, but I still have a lot of doubts about feedback with pragmas (I hope
>> you view them as constructive criticism).
>>
>>
>> I'm finding this whole conversation exhausting.
>>
>>
> Me too :(
>
>
>> Is like pragmas assume there is always a perfect message transaction.
>> How can I halt the execution of a specific pragma?
>>
>>
>> By putting a break point in its implementations.
>>
>> Can I write <myPragma halt>?
>>
>>
>> No. But you can out a conditional breakpoint in
>> CompiledMethod>>pragmaAt: or in the pragma's implementation.
>>
> How do I know if it will get executed?
>>
>>
>> By reading the broader system or adding break pints as just described.
>>
>> Is <shortcut> a functional pragma?
>> How do I distinguis any pragma from being functional or "documentation"?
>>
>>
>> Using "implementors" and "senders" you can find out where it may be
>> used. One if the problems of late-bound systems is figuring out what binds
>> to what. Pragmas are more difficult to figure out unless pragmas have
>> clearly commented implementations.
>>
>>
> It could be broken because I pressed Alt+M in <gtInspectorAction> and
> nothing happens:
>
> gtInspectorActionBrowse
> <gtInspectorAction>
> ^ GLMGenericAction new
> action: [ self browse ];
> icon: GLMUIThemeExtraIcons glamorousBrowse;
> title: 'Browse'
>
>
>>
>>
>>>
>>>
>>>> And they don't need to be in the method pane itself.
>>>>
>>>
>>> For some kinds of metadata, for metadata with semantics, not just a
>>> documentary function, it is important for the metadata to be obvious.
>>>
>>
>> I think this depends on context. Because your work could be towards
>> low-level machinery details or software reenginering, doesn't mean that we
>> all need to view compiler directives, functional and structural
>> annotations, etc.
>>
>>
>> That's a mischaracterisation. Most of their uses are for pluggable
>> GUIs. And if this is so onerous why weren't you protesting <primitive:
>> 123>?
>>
>>
> Pluggable GUIs in systems without GUI builders.
>
> But yes, the same applies to the <primitive: 123> artifact. If we would
> have a Primitives Browser, what would be the point of accessing them
> through the normal browser?
>
>
>>
>> And if I can write some prediction... When someone invents automatic
>> annotation (like happens now with genomes) and decides it will be cool to
>> have them in the image (because you will gain performance, more reflective
>> capabilitites, etc) methods could explode with pragmas to the point gets to
>> be annoying to browse any method. Then the tool will have to be built by
>> need.
>>
>>
>>> No one has argued for hiding the primitive specification
>>> off-to-the-side. "Need" is a poor criticism here because using turing
>>> equivalence lots of things don't "need" to be the way they are. Instead
>>> why not ask what are the pros and cons?
>>>
>>>
>> Ok, many of us knows the pros. I have been using pragmas for a while.
>> But if we stop discussing then it will never adapt to new ideas.
>> So you may want to share your view of cons too :)
>>
>>
>> The cons are that for years, and at length, one has to defend a good idea
>> ;-).
>>
>
>
> Ok, I am starting to think pragmas with tags are the best thing possibly
> ever created and the final word of evolution in this area ;)
>
> Seriously, I am not saying is a bad idea at all. I say they could be
> visualized in other ways.
> I cannot believe people accept happily that < ... > is the best way of
> representing annotations.
>
>
>
>> Pragmas were a new idea and here in thus conversation we see how
>> resistant we are to new ideas. I've seen nothing against the need for
>> per-method metadata and a lot on how it can be done with other mechanisms.
>> But the existing mechanisms don't do one of two things
>> - separate normal from meta levels
>> - obviously associate metadata with methods.
>>
>>
> I don't have the final answer but I suspect that because we used to see
> Smalltlak meta-levels through tools, we also "demand" that new meta-objects
> should cope well with our toolset.
>
>
>
>> So what I'm missing in this conversation is addressing the issues:
>> - how in a componentised loadable system do we decouple component loads
>> where components collide in areas like global menu definitions, inspectors,
>> etc?
>> - how do we associate metadata with methods so that
>> - the metadata is of a form that fits well with the host system?
>> - the metadata is clearly associated with the method it is data of?
>> - the bookkeeping is managed?
>>
>> You could add good questions here. But these are the questions I was
>> thinking of when we added pragmas to VW.
>>
>>
>>
> I have more questions about having a controlled vocabulary for metadata
> and annotations, and how we could visualize them better. How could we add
> meta-annotations and if descriptive declarative programming could be
> avoided with sequential OO.
> Naturally they could fit as bad questions for anyone.
>
> Cheers,
>
> Hernán
>
>
>> It is like having to specify protocol because there is no list pane to
>>>> create them.
>>>>
>>>
>>> I disagree. When the pragma is specifying type information, specifying
>>> that the method is an action on a specific menu, is a pane in an inspector,
>>> and many other uses, it is essential that that information be represented,
>>> and putting it in a one-off bookkeeping system is a bad idea. We're not
>>> talking about simple documentary metadata like author, category etc.
>>>
>>
>> Well, I think documentary metadata is tremendously complex.
>>
>>
>>
>>> We're using pragmas for semantics, semantics of the method that are
>>> outside of its execution semantics, semantics about how the method fits in
>>> the broader system. And putting that in non-obvious places is a bad idea.
>>>
>>>
>> I agree. But obvious could be a place where can be located by a method
>> though not necessarily visible.
>>
>> Cheers,
>>
>> Hernán
>>
>>
>>
>>>
>>>>
>>>> Hernán
>>>>
>>>>>
>>>>> About python decorators I disagree that are similar to pragmas.
>>>>> Pragmas are focused on being descriptive , python decorators are
>>>>> descriptive as by product. The main focus of python decorators is to
>>>>> shorten code by introducing syntactic sugar.
>>>>>
>>>>
>>> Kilon, pragmas are not limited to being descriptive.
>>>
>>>
>>>>
>>>>> I agree though this is a very interesting discussion and I dont
>>>>> understand most of the things stated here so I leave an open door and mind
>>>>> for pragmas. Maybe one day I will "get it".
>>>>>
>>>>
>>> That would be nice :)
>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>>
>>>>> On Sat, Feb 7, 2015 at 10:02 AM, Thierry Goubier <
>>>>> thierry.goubier(a)gmail.com> wrote:
>>>>>
>>>>>>
>>>>>>
>>>>>> 2015-02-06 22:00 GMT+01:00 stepharo <stepharo(a)free.fr>:
>>>>>>
>>>>>>> Really interesting discussion. I like pragmas but this is
>>>>>>> interesting to see them challenged.
>>>>>>>
>>>>>>
>>>>>> Thanks. It's a pleasure to discuss that way :)
>>>>>>
>>>>>>
>>>>>>> Yes, but there end up being lots of naming conventions and they are
>>>>>>>> non-obvious. Whereas pragmas, because they are in-your-face in the methods
>>>>>>>> in question, don't need conventions. They just need documenting ;-).
>>>>>>>>
>>>>>>> Thierry I'm skeptical that multiple protocol will save the problem
>>>>>>> because you will rely on coding conventions.
>>>>>>>
>>>>>>
>>>>>> Pragma as well: just explain the conventions behind the gtInspector
>>>>>> pragmas, for example.
>>>>>>
>>>>>> But give me multiple protocols and I'll show you the same conventions
>>>>>> rewritten in less lines (and a slightly more efficient code).
>>>>>>
>>>>>>
>>>>>>> And pragma is a clever tagging.
>>>>>>>
>>>>>>
>>>>>> Then maybe we should remove protocols and replace them with pragmas :)
>>>>>>
>>>>>> Thierry
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Stef
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>>
>>> --
>>> best,
>>> Eliot
>>>
>>
>>
>
--
best,
Eliot
Feb. 8, 2015
Re: [Pharo-dev] ||
by Hernán Morales Durand
Hi Eliot,
2015-02-08 12:50 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
> Hi Hernan,
>
>
> On Feb 7, 2015, at 12:55 PM, Hernán Morales Durand <
> hernan.morales(a)gmail.com> wrote:
>
> Hi Eliot,
>
> 2015-02-07 14:48 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>
>> Hi Hernan,
>>
>> On Sat, Feb 7, 2015 at 7:41 AM, Hernán Morales Durand <
>> hernan.morales(a)gmail.com> wrote:
>>
>>>
>>> 2015-02-07 5:59 GMT-03:00 kilon alios <kilon.alios(a)gmail.com>:
>>>
>>>> Personally I don't like Pragmas, they have not convinced me so far that
>>>> they fit the style of Smalltalk syntax. I have to confess though I never
>>>> liked descriptive elements and languages .
>>>>
>>>>
>>> Me neither. Actually the pragma idea is not wrong per se, it is the tag
>>> syntax to write them which bothers me. Because the world can be described
>>> with tags if you start that path.
>>>
>>
>> How exactly is the syntax wrong?
>>
>
> I am not saying syntax is wrong, I just don't like it because:
>
> 1) Adds another level of representation inside an already reflective
> system.
>
>
> What do you mean exactly? I don't have clear recollection of whether they
> were in Squeak in 08 or if I ported then, but at that time CompiledMethod
> had a properties object, and pragmas were merged into this. What I did do
> was save a lot of space getting rid if the properties object unless a
> method needed it. And IIRC I changed the implementing class from
> MethodProperties to AdditionalMethodState. So there was no additional
> level of representation. a) the syntax was already there fir primitives
> and b) the state was already there in methods.
>
>
The place where pragmas are located internally are not an issue for me. The
fact that special tags are not following the message pattern template is.
It says there is a special collector, parser, validator, etc. a whole
mechanism because something is - supposedly - not easily expressible with
plain reflective messages.
2) It could be done with plain common message sends.
>
>
> No it can't. Common sends are executable and we don't want pragmas
> executed when the method is run, we want the pragma executed when the
> method is added, or analysed. That was what was ugly about the use of plain
> sends in e.f. VMMaker, that there had to be lots of empty implementations
> of the messages used for metadata.
>
> So using normal sends
> - prevents the metadata from being directly executed because executing
> them when the method is run is wrong
> - confuses meta level and normal level, putting them at the same level,
> and hence...
> - confusing for the programmer because its not obvious what's metadata and
> what's a normal send
> - makes analysis harder for the same reason
>
>
We are talking about different worlds here.
Theoretically I could mark methods this way:
(Pragma
for: (ASTBlockClosure >> #value:)
selector: #primitive:
arguments: (Array with: 60)) addPragma.
So the annotations could be written with normal message sends.
And they could be tool supported, so no one gets confused.
> 3) Should be (to me) "hidden" from method pane, and displayed by a
> specific tool inside the system browser.
>
>
> I disagree. I want to see the pragma. It has essential information that
> shouldn't be hidden. I want to edit it easily.
>
I want to see and edit the pragma too, when I am really interested. Just
like with the bytecodes.
> And how can you in the one hand say it can be implemented as a normal
> message send a d at the same time want it hidden? Be consistent :-)
>
>
There is no inconsistency. I am saying they should be hidden from the
method body.
The method pane you see in the browser should be used to send messages to
your modeling domain (which already imposes its own difficulty), not being
exploited to add meta information where meta could belong to
instrumentation analysis (lint, profiling) or UI building (keymap, menu) or
whatever excuse found to add more tags.
I wonder how one could refactor this method:
Greetings>>helloWorld
<year: 2015>
<status: #toDo>
<author: 'Hernán'>
<scope: #private>
<soapOperationName: #HelloWorld>
<soapDocumentation: #'Returns Hello World'>
<soapResult: #String>
<soapStyle: #RPC>
<rmiOperationName: #HelloWorld>
<rmiDocumentation: #'Returns Hello World'>
<rmiResult: #String>
<asn1OperationName: #HelloWorld>
<asn1Documentation: #'Returns Hello World'>
<asn1Result: #UTF8String>
<dcomOperationName: #HelloWorld>
<dcomDocumentation: #'Returns Hello World'>
<dcomResult: #String>
^'Hello World'
>
>> The <literalMessagePattern> syntax predates pragmas. It was used first
>> for numeric primitives in Smalltalk-76 or Smalltalk-80. Squeak extended it
>> with primitive:module:. I and others extended it to include arbitrary
>> literal message patterns. The syntax of a literal message pattern is the
>> syntax of a send with no receiver and only literal arguments.
>>
> The use of this syntax means
>> a) no new syntax
>> b) each pragma is potentially executable
>> c) methods using specific pragmas can be found using "find senders"
>> d) the execution side of a pragma can be found using "find implementors"
>>
>> So what's wrong with that? How is it wrong to use a common Smalltalk
>> object, a Message, that is well-supported in the system, for method
>> metadata?
>>
>>
> I get that pragmas are messages, but they assume an implicit receiver,
> which actually depends on context. If I understood right with pragmas
> always receiver = destination?
>
>
> Not for pragmas that are just labels. And what's destination? In the
> menu building example above the destination"is the menu but the receiver is
> the menu builder. So I think that what the receiver is depends on usage.
>
> If you change things in the communication model (receiver, sender,
> message, etc.), by removing or adding elements, you have a loss in the
> message because it gets harder to reconstruct the message send.
>
>
> I don't understand this. Can you expand?
>
>
Now I realize how far we are from understanding. But I start to feel tired
to write about communication models here.
>
> Consider
>
> <eventRegistration>
> | eventRegistration |
> { eventRegistration }.
> self eventRegistration.
>
> which of them "it sounds like" you cannot infer their purpose?
>
>
> I don't get the example, because of the confusion of meta layers.
>
>
Now you understand me :)
> <eventRegistration>
> says "this is metadata"
>
>
yes, but not what type of metadata is. Is metadata for instrumentation? is
for documentation?
> | eventRegistration |
>
> says "this is a bug in the method because the variable isn't used, and eg
> Opal will remove it so it won't be there".
>
>
but you get this is a local variable supposed to be used in the current
method. You can get the scope easily.
> { eventRegistration }.
> I guess you mean { #eventRegistration }. If so this is the same. An
> optimizing compiler will delete it.
>
>
Yes. The idea there is the same, you would associate the eventRegistration
as an Array element to be accessed in the current method for example.
> self eventRegistration.
> says "send myself eventRegustration". Which /isn't/ what's wanted.
>
> So for me only the pragma implies "this method is to be registered with
> the event system". The middle two say "I am a bug, or syntax error". The
> last one says "I am a normal send".
>
>
To me says "this method contains code which defines an event". Where the
event is defined should need more metadata until explicit semantics are
enough complete.
>
>
> To me the first because you need the context MyClass>>methodName
> and you need to browse the pragma to get its purpose.
>
>
>
>>
>>> There are other ways to add metadata to methods. Without tagging.
>>>
>>
>> Haven't we discussed that? Putting metadata off to the side introduces a
>> bookkeeping problem. It is a bad idea.
>>
>
> Yes, but I still have a lot of doubts about feedback with pragmas (I hope
> you view them as constructive criticism).
>
>
> I'm finding this whole conversation exhausting.
>
>
Me too :(
> Is like pragmas assume there is always a perfect message transaction.
> How can I halt the execution of a specific pragma?
>
>
> By putting a break point in its implementations.
>
> Can I write <myPragma halt>?
>
>
> No. But you can out a conditional breakpoint in CompiledMethod>>pragmaAt:
> or in the pragma's implementation.
>
How do I know if it will get executed?
>
>
> By reading the broader system or adding break pints as just described.
>
> Is <shortcut> a functional pragma?
> How do I distinguis any pragma from being functional or "documentation"?
>
>
> Using "implementors" and "senders" you can find out where it may be used.
> One if the problems of late-bound systems is figuring out what binds to
> what. Pragmas are more difficult to figure out unless pragmas have clearly
> commented implementations.
>
>
It could be broken because I pressed Alt+M in <gtInspectorAction> and
nothing happens:
gtInspectorActionBrowse
<gtInspectorAction>
^ GLMGenericAction new
action: [ self browse ];
icon: GLMUIThemeExtraIcons glamorousBrowse;
title: 'Browse'
>
>
>>
>>
>>> And they don't need to be in the method pane itself.
>>>
>>
>> For some kinds of metadata, for metadata with semantics, not just a
>> documentary function, it is important for the metadata to be obvious.
>>
>
> I think this depends on context. Because your work could be towards
> low-level machinery details or software reenginering, doesn't mean that we
> all need to view compiler directives, functional and structural
> annotations, etc.
>
>
> That's a mischaracterisation. Most of their uses are for pluggable GUIs.
> And if this is so onerous why weren't you protesting <primitive: 123>?
>
>
Pluggable GUIs in systems without GUI builders.
But yes, the same applies to the <primitive: 123> artifact. If we would
have a Primitives Browser, what would be the point of accessing them
through the normal browser?
>
> And if I can write some prediction... When someone invents automatic
> annotation (like happens now with genomes) and decides it will be cool to
> have them in the image (because you will gain performance, more reflective
> capabilitites, etc) methods could explode with pragmas to the point gets to
> be annoying to browse any method. Then the tool will have to be built by
> need.
>
>
>> No one has argued for hiding the primitive specification off-to-the-side.
>> "Need" is a poor criticism here because using turing equivalence lots of
>> things don't "need" to be the way they are. Instead why not ask what are
>> the pros and cons?
>>
>>
> Ok, many of us knows the pros. I have been using pragmas for a while.
> But if we stop discussing then it will never adapt to new ideas.
> So you may want to share your view of cons too :)
>
>
> The cons are that for years, and at length, one has to defend a good idea
> ;-).
>
Ok, I am starting to think pragmas with tags are the best thing possibly
ever created and the final word of evolution in this area ;)
Seriously, I am not saying is a bad idea at all. I say they could be
visualized in other ways.
I cannot believe people accept happily that < ... > is the best way of
representing annotations.
> Pragmas were a new idea and here in thus conversation we see how resistant
> we are to new ideas. I've seen nothing against the need for per-method
> metadata and a lot on how it can be done with other mechanisms. But the
> existing mechanisms don't do one of two things
> - separate normal from meta levels
> - obviously associate metadata with methods.
>
>
I don't have the final answer but I suspect that because we used to see
Smalltlak meta-levels through tools, we also "demand" that new meta-objects
should cope well with our toolset.
> So what I'm missing in this conversation is addressing the issues:
> - how in a componentised loadable system do we decouple component loads
> where components collide in areas like global menu definitions, inspectors,
> etc?
> - how do we associate metadata with methods so that
> - the metadata is of a form that fits well with the host system?
> - the metadata is clearly associated with the method it is data of?
> - the bookkeeping is managed?
>
> You could add good questions here. But these are the questions I was
> thinking of when we added pragmas to VW.
>
>
>
I have more questions about having a controlled vocabulary for metadata and
annotations, and how we could visualize them better. How could we add
meta-annotations and if descriptive declarative programming could be
avoided with sequential OO.
Naturally they could fit as bad questions for anyone.
Cheers,
Hernán
> It is like having to specify protocol because there is no list pane to
>>> create them.
>>>
>>
>> I disagree. When the pragma is specifying type information, specifying
>> that the method is an action on a specific menu, is a pane in an inspector,
>> and many other uses, it is essential that that information be represented,
>> and putting it in a one-off bookkeeping system is a bad idea. We're not
>> talking about simple documentary metadata like author, category etc.
>>
>
> Well, I think documentary metadata is tremendously complex.
>
>
>
>> We're using pragmas for semantics, semantics of the method that are
>> outside of its execution semantics, semantics about how the method fits in
>> the broader system. And putting that in non-obvious places is a bad idea.
>>
>>
> I agree. But obvious could be a place where can be located by a method
> though not necessarily visible.
>
> Cheers,
>
> Hernán
>
>
>
>>
>>>
>>> Hernán
>>>
>>>>
>>>> About python decorators I disagree that are similar to pragmas. Pragmas
>>>> are focused on being descriptive , python decorators are descriptive as by
>>>> product. The main focus of python decorators is to shorten code by
>>>> introducing syntactic sugar.
>>>>
>>>
>> Kilon, pragmas are not limited to being descriptive.
>>
>>
>>>
>>>> I agree though this is a very interesting discussion and I dont
>>>> understand most of the things stated here so I leave an open door and mind
>>>> for pragmas. Maybe one day I will "get it".
>>>>
>>>
>> That would be nice :)
>>
>>>
>>>
>>>
>>>
>>>
>>>>
>>>> On Sat, Feb 7, 2015 at 10:02 AM, Thierry Goubier <
>>>> thierry.goubier(a)gmail.com> wrote:
>>>>
>>>>>
>>>>>
>>>>> 2015-02-06 22:00 GMT+01:00 stepharo <stepharo(a)free.fr>:
>>>>>
>>>>>> Really interesting discussion. I like pragmas but this is interesting
>>>>>> to see them challenged.
>>>>>>
>>>>>
>>>>> Thanks. It's a pleasure to discuss that way :)
>>>>>
>>>>>
>>>>>> Yes, but there end up being lots of naming conventions and they are
>>>>>>> non-obvious. Whereas pragmas, because they are in-your-face in the methods
>>>>>>> in question, don't need conventions. They just need documenting ;-).
>>>>>>>
>>>>>> Thierry I'm skeptical that multiple protocol will save the problem
>>>>>> because you will rely on coding conventions.
>>>>>>
>>>>>
>>>>> Pragma as well: just explain the conventions behind the gtInspector
>>>>> pragmas, for example.
>>>>>
>>>>> But give me multiple protocols and I'll show you the same conventions
>>>>> rewritten in less lines (and a slightly more efficient code).
>>>>>
>>>>>
>>>>>> And pragma is a clever tagging.
>>>>>>
>>>>>
>>>>> Then maybe we should remove protocols and replace them with pragmas :)
>>>>>
>>>>> Thierry
>>>>>
>>>>>
>>>>>>
>>>>>> Stef
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>
>>
>> --
>> best,
>> Eliot
>>
>
>
Feb. 8, 2015
[pharo-project/pharo-core]
by GitHub
Branch: refs/tags/40483
Home: https://github.com/pharo-project/pharo-core
Feb. 8, 2015
[pharo-project/pharo-core] fa4a01: 40483
by GitHub
Branch: refs/heads/4.0
Home: https://github.com/pharo-project/pharo-core
Commit: fa4a01127f4608de39c1610370e5374c2421b469
https://github.com/pharo-project/pharo-core/commit/fa4a01127f4608de39c16103…
Author: Jenkins Build Server <board(a)pharo-project.org>
Date: 2015-02-08 (Sun, 08 Feb 2015)
Changed paths:
M Kernel.package/Date.class/instance/deprecated/leap.st
A Kernel.package/Date.class/instance/testing/isLeapYear.st
M KernelTests.package/DateTest.class/instance/tests/testAccessing.st
M KernelTests.package/DateTest.class/instance/tests/testLeap.st
M Manifest-CriticBrowser.package/SelectRuleBrowser.class/instance/initialization/initialize.st
M Manifest-CriticBrowser.package/SelectRuleBrowser.class/instance/protocol/removeItems.st
A ScriptLoader40.package/ScriptLoader.class/instance/pharo - scripts/script483.st
A ScriptLoader40.package/ScriptLoader.class/instance/pharo - updates/update40483.st
M ScriptLoader40.package/ScriptLoader.class/instance/public/commentForCurrentUpdate.st
R System-Support.package/SmalltalkImage.class/instance/printing/printElementsOn_.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/class/defaults/defaultAvailableRepositories.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/accessing/repository_.st
A Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/actions/defineAllRepositoriesInMCBrowser.st
A Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/actions/defineRepositoryInMCBrowser.st
A Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/actions/repositoryObjectFromURLString_.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/menu/configurationListMenu_.st
A Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserPane.class/instance/private/explicitTitleFromURLString_.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserToolbar.class/instance/initialization/initializeWidgets.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserToolbar.class/instance/initialization/installModel.st
M Tool-ConfigurationBrowser.package/MetacelloConfigurationBrowserToolbar.class/instance/initialization/loadModel.st
Log Message:
-----------
40483
14879 CodeCritics does not allow to remove a critic when selecting the critics to be run
https://pharo.fogbugz.com/f/cases/14879
14884 Add a menu to define the metaRepository as repository in MCBrowser
https://pharo.fogbugz.com/f/cases/14884
14871 Date >> leap answer 1 or 0 and we want true or false
https://pharo.fogbugz.com/f/cases/14871
14887 SmalltalkImage>>printOnElements: is dead code
https://pharo.fogbugz.com/f/cases/14887
http://files.pharo.org/image/40/40483.zip
Feb. 8, 2015
Re: [Pharo-dev] ||
by kilon alios
"I disagree. I want to see the pragma. It has essential information that
shouldn't be hidden. I want to edit it easily. And how can you in the one
hand say it can be implemented as a normal message send a d at the same
time want it hidden? Be consistent :-)"
I agree with you Eliot, I definitely would not want for pragmas to be
hidden. They are an important part of the code they should be visible with
the rest of the code. It would lead to confusion otherwise . Opening 10
tools to be able to view code is also not ideal.
Feb. 8, 2015
Re: [Pharo-dev] ||
by Eliot Miranda
Hi Hernan,
On Feb 7, 2015, at 12:55 PM, Hernán Morales Durand <hernan.morales(a)gmail.com> wrote:
> Hi Eliot,
>
> 2015-02-07 14:48 GMT-03:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>> Hi Hernan,
>>
>> On Sat, Feb 7, 2015 at 7:41 AM, Hernán Morales Durand <hernan.morales(a)gmail.com> wrote:
>>>
>>> 2015-02-07 5:59 GMT-03:00 kilon alios <kilon.alios(a)gmail.com>:
>>>> Personally I don't like Pragmas, they have not convinced me so far that they fit the style of Smalltalk syntax. I have to confess though I never liked descriptive elements and languages .
>>>
>>> Me neither. Actually the pragma idea is not wrong per se, it is the tag syntax to write them which bothers me. Because the world can be described with tags if you start that path.
>>
>> How exactly is the syntax wrong?
>
> I am not saying syntax is wrong, I just don't like it because:
>
> 1) Adds another level of representation inside an already reflective system.
What do you mean exactly? I don't have clear recollection of whether they were in Squeak in 08 or if I ported then, but at that time CompiledMethod had a properties object, and pragmas were merged into this. What I did do was save a lot of space getting rid if the properties object unless a method needed it. And IIRC I changed the implementing class from MethodProperties to AdditionalMethodState. So there was no additional level of representation. a) the syntax was already there fir primitives and b) the state was already there in methods.
> 2) It could be done with plain common message sends.
No it can't. Common sends are executable and we don't want pragmas executed when the method is run, we want the pragma executed when the method is added, or analysed. That was what was ugly about the use of plain sends in e.f. VMMaker, that there had to be lots of empty implementations of the messages used for metadata.
So using normal sends
- prevents the metadata from being directly executed because executing them when the method is run is wrong
- confuses meta level and normal level, putting them at the same level, and hence...
- confusing for the programmer because its not obvious what's metadata and what's a normal send
- makes analysis harder for the same reason
> 3) Should be (to me) "hidden" from method pane, and displayed by a specific tool inside the system browser.
I disagree. I want to see the pragma. It has essential information that shouldn't be hidden. I want to edit it easily. And how can you in the one hand say it can be implemented as a normal message send a d at the same time want it hidden? Be consistent :-)
>
>> The <literalMessagePattern> syntax predates pragmas. It was used first for numeric primitives in Smalltalk-76 or Smalltalk-80. Squeak extended it with primitive:module:. I and others extended it to include arbitrary literal message patterns. The syntax of a literal message pattern is the syntax of a send with no receiver and only literal arguments.
>> The use of this syntax means
>> a) no new syntax
>> b) each pragma is potentially executable
>> c) methods using specific pragmas can be found using "find senders"
>> d) the execution side of a pragma can be found using "find implementors"
>>
>> So what's wrong with that? How is it wrong to use a common Smalltalk object, a Message, that is well-supported in the system, for method metadata?
>
> I get that pragmas are messages, but they assume an implicit receiver, which actually depends on context. If I understood right with pragmas always receiver = destination?
Not for pragmas that are just labels. And what's destination? In the menu building example above the destination"is the menu but the receiver is the menu builder. So I think that what the receiver is depends on usage.
> If you change things in the communication model (receiver, sender, message, etc.), by removing or adding elements, you have a loss in the message because it gets harder to reconstruct the message send.
I don't understand this. Can you expand?
>
> Consider
>
> <eventRegistration>
> | eventRegistration |
> { eventRegistration }.
> self eventRegistration.
>
> which of them "it sounds like" you cannot infer their purpose?
I don't get the example, because of the confusion of meta layers.
<eventRegistration>
says "this is metadata"
| eventRegistration |
says "this is a bug in the method because the variable isn't used, and eg Opal will remove it so it won't be there".
{ eventRegistration }.
I guess you mean { #eventRegistration }. If so this is the same. An optimizing compiler will delete it.
self eventRegistration.
says "send myself eventRegustration". Which /isn't/ what's wanted.
So for me only the pragma implies "this method is to be registered with the event system". The middle two say "I am a bug, or syntax error". The last one says "I am a normal send".
>
> To me the first because you need the context MyClass>>methodName
> and you need to browse the pragma to get its purpose.
>
>
>>
>>> There are other ways to add metadata to methods. Without tagging.
>>
>> Haven't we discussed that? Putting metadata off to the side introduces a bookkeeping problem. It is a bad idea.
>
> Yes, but I still have a lot of doubts about feedback with pragmas (I hope you view them as constructive criticism).
I'm finding this whole conversation exhausting.
> Is like pragmas assume there is always a perfect message transaction.
> How can I halt the execution of a specific pragma?
By putting a break point in its implementations.
> Can I write <myPragma halt>?
No. But you can out a conditional breakpoint in CompiledMethod>>pragmaAt: or in the pragma's implementation.
> How do I know if it will get executed?
By reading the broader system or adding break pints as just described.
> Is <shortcut> a functional pragma?
> How do I distinguis any pragma from being functional or "documentation"?
Using "implementors" and "senders" you can find out where it may be used. One if the problems of late-bound systems is figuring out what binds to what. Pragmas are more difficult to figure out unless pragmas have clearly commented implementations.
>
>>
>>> And they don't need to be in the method pane itself.
>>
>> For some kinds of metadata, for metadata with semantics, not just a documentary function, it is important for the metadata to be obvious.
>
> I think this depends on context. Because your work could be towards low-level machinery details or software reenginering, doesn't mean that we all need to view compiler directives, functional and structural annotations, etc.
That's a mischaracterisation. Most of their uses are for pluggable GUIs. And if this is so onerous why weren't you protesting <primitive: 123>?
> And if I can write some prediction... When someone invents automatic annotation (like happens now with genomes) and decides it will be cool to have them in the image (because you will gain performance, more reflective capabilitites, etc) methods could explode with pragmas to the point gets to be annoying to browse any method. Then the tool will have to be built by need.
>
>> No one has argued for hiding the primitive specification off-to-the-side. "Need" is a poor criticism here because using turing equivalence lots of things don't "need" to be the way they are. Instead why not ask what are the pros and cons?
>
> Ok, many of us knows the pros. I have been using pragmas for a while.
> But if we stop discussing then it will never adapt to new ideas.
> So you may want to share your view of cons too :)
The cons are that for years, and at length, one has to defend a good idea ;-). Pragmas were a new idea and here in thus conversation we see how resistant we are to new ideas. I've seen nothing against the need for per-method metadata and a lot on how it can be done with other mechanisms. But the existing mechanisms don't do one of two things
- separate normal from meta levels
- obviously associate metadata with methods.
So what I'm missing in this conversation is addressing the issues:
- how in a componentised loadable system do we decouple component loads where components collide in areas like global menu definitions, inspectors, etc?
- how do we associate metadata with methods so that
- the metadata is of a form that fits well with the host system?
- the metadata is clearly associated with the method it is data of?
- the bookkeeping is managed?
You could add good questions here. But these are the questions I was thinking of when we added pragmas to VW.
>>> It is like having to specify protocol because there is no list pane to create them.
>>
>> I disagree. When the pragma is specifying type information, specifying that the method is an action on a specific menu, is a pane in an inspector, and many other uses, it is essential that that information be represented, and putting it in a one-off bookkeeping system is a bad idea. We're not talking about simple documentary metadata like author, category etc.
>
> Well, I think documentary metadata is tremendously complex.
>
>> We're using pragmas for semantics, semantics of the method that are outside of its execution semantics, semantics about how the method fits in the broader system. And putting that in non-obvious places is a bad idea.
>
> I agree. But obvious could be a place where can be located by a method though not necessarily visible.
>
> Cheers,
>
> Hernán
>
>
>>>
>>>
>>> Hernán
>>>
>>>>
>>>> About python decorators I disagree that are similar to pragmas. Pragmas are focused on being descriptive , python decorators are descriptive as by product. The main focus of python decorators is to shorten code by introducing syntactic sugar.
>>
>> Kilon, pragmas are not limited to being descriptive.
>>
>>>>
>>>> I agree though this is a very interesting discussion and I dont understand most of the things stated here so I leave an open door and mind for pragmas. Maybe one day I will "get it".
>>
>> That would be nice :)
>>>
>>>
>>>
>>>
>>>>
>>>> On Sat, Feb 7, 2015 at 10:02 AM, Thierry Goubier <thierry.goubier(a)gmail.com> wrote:
>>>>>
>>>>>
>>>>> 2015-02-06 22:00 GMT+01:00 stepharo <stepharo(a)free.fr>:
>>>>>> Really interesting discussion. I like pragmas but this is interesting to see them challenged.
>>>>>
>>>>> Thanks. It's a pleasure to discuss that way :)
>>>>>
>>>>>>> Yes, but there end up being lots of naming conventions and they are non-obvious. Whereas pragmas, because they are in-your-face in the methods in question, don't need conventions. They just need documenting ;-).
>>>>>> Thierry I'm skeptical that multiple protocol will save the problem because you will rely on coding conventions.
>>>>>
>>>>> Pragma as well: just explain the conventions behind the gtInspector pragmas, for example.
>>>>>
>>>>> But give me multiple protocols and I'll show you the same conventions rewritten in less lines (and a slightly more efficient code).
>>>>>
>>>>>> And pragma is a clever tagging.
>>>>>
>>>>> Then maybe we should remove protocols and replace them with pragmas :)
>>>>>
>>>>> Thierry
>>>>>
>>>>>>
>>>>>> Stef
>>
>>
>>
>> --
>> best,
>> Eliot
>
Feb. 8, 2015
Re: [Pharo-dev] Howto create a new configuration?
by Juraj Kubelka
Hi,
> 8. 2. 2015 v 8:26, Nicolai Hess <nicolaihess(a)web.de>:
>
> 2015-02-07 13:17 GMT+01:00 Nicolai Hess <nicolaihess(a)web.de <mailto:nicolaihess@web.de>>:
>
>
> 2015-02-06 22:02 GMT+01:00 Juraj Kubelka <juraj.kubelka(a)gmail.com <mailto:juraj.kubelka@gmail.com>>:
> I have changed two methods of the configuration:
>
> -=-=-
> stable: spec
> <symbolicVersion: #stable>
>
> spec for: #'pharo2.x' version: '2.1'.
> "after some modification in NB made it incompatible with 3.0"
> spec for: #'pharo3.x' version: '2.3'.
> spec for: #'pharo4.x' version: '2.7â. â<<== added, maybe instead of pharo4.x could be common"
> -=-=-
> development: spec
> <symbolicVersion: #'development'>
>
> spec for: #'common' version: '2.3-baselineâ. â<<== it is likely not necessary"
> -=-=-
>
> I have changed it, because I think there should be two lines in Versioner: one with development label, second with stable label.
> Then everything works.
> Let me know if it helps.
> Juraj
>
> Thank you Juraj,
> that works .... better, but now, commiting the new configuration
> shows a bunch of "Critical Issues"
> Critical Warning missing recommend field...
> Critcal Warning The name of package x does not match file name x.7
> Critical Warning No Version specified.
> ....
>
> Not that easy. Maybe, the ConfigurationOfAthens was only written and updated by hand, does not work with Versionner?
>
>
>
>
> I think, for now I will try to change the Configuration by hand without versionner.
>
>
There three warnings revealed by: (MetacelloToolBox validateConfiguration: ConfigurationOfAthens).
It is easy to fix, well I guess. The one is a misspelling, two are about missing #versionString: and I suppose there should be versionString: #âstableâ.
It is fixed in ConfigurationOfAthens-JurajKubelka.46.mcz.
Then I have created by hand version 2.8. The âstrangeâ think is that development do not point to the latest version. Is the 2.8 supposed to be stable or development version? ConfigurationOfAthens-JurajKubelka.46.mcz contains the 2.8 version as development version.
Cheers,
Juraj
Feb. 8, 2015