Squeak-dev January 2017

squeak-dev@lists.squeakfoundation.org

34 participants
77 discussions

The Trunk: ToolBuilder-Morphic-topa.190.mcz
by commits＠source.squeak.org 17 Jan '17

17 Jan '17

Tobias Pape uploaded a new version of ToolBuilder-Morphic to project The Trunk: http://source.squeak.org/trunk/ToolBuilder-Morphic-topa.190.mcz ==================== Summary ==================== Name: ToolBuilder-Morphic-topa.190 Author: topa Time: 17 January 2017, 5:57:56.691276 pm UUID: 9b5813db-ef4d-4ef5-ba76-aa5473e98231 Ancestors: ToolBuilder-Morphic-nice.189 re-use settings for multi- and single-selection lists in toolbuilder =============== Diff against ToolBuilder-Morphic-nice.189 =============== Item was changed: ----- Method: MorphicToolBuilder>>buildPluggableList: (in category 'widgets required') ----- buildPluggableList: aSpec | widget listClass getIndex setIndex | aSpec getSelected ifNil:[ listClass := self listClass. getIndex := aSpec getIndex. setIndex := aSpec setIndex. ] ifNotNil:[ listClass := self listByItemClass. getIndex := aSpec getSelected. setIndex := aSpec setSelected. ]. widget := listClass on: aSpec model list: aSpec list selected: getIndex changeSelected: setIndex menu: aSpec menu keystroke: aSpec keyPress. self register: widget id: aSpec name. + widget + dragItemSelector: aSpec dragItem; + dropItemSelector: aSpec dropItem; + wantsDropSelector: aSpec dropAccept; + dragStartedSelector: aSpec dragStarted. + + self setListPropertiesFor: widget spec: aSpec. - "Override default scroll bar policies if needed. Widget will use preference values otherwise." - aSpec hScrollBarPolicy ifNotNil: [:policy | - policy caseOf: { - [#always] -> [widget alwaysShowHScrollBar]. - [#never] -> [widget hideHScrollBarIndefinitely]. - [#whenNeeded] -> [widget showHScrollBarOnlyWhenNeeded]. } ]. - aSpec vScrollBarPolicy ifNotNil: [:policy | - policy caseOf: { - [#always] -> [widget alwaysShowVScrollBar]. - [#never] -> [widget hideVScrollBarIndefinitely]. - [#whenNeeded] -> [widget showVScrollBarOnlyWhenNeeded]. } ]. - - widget getListElementSelector: aSpec listItem. - widget getListSizeSelector: aSpec listSize. - widget getIconSelector: aSpec icon. - widget getHelpSelector: aSpec helpItem. - widget doubleClickSelector: aSpec doubleClick. - - widget dragItemSelector: aSpec dragItem. - widget dropItemSelector: aSpec dropItem. - widget wantsDropSelector: aSpec dropAccept. - widget dragStartedSelector: aSpec dragStarted. - - widget autoDeselect: aSpec autoDeselect. - widget keystrokePreviewSelector: aSpec keystrokePreview. - - aSpec filterableList ifNotNil: [:b | widget filterableList: b]. - aSpec clearFilterAutomatically ifNotNil: [:b | widget clearFilterAutomatically: b]. - - aSpec color ifNotNil: [:c | widget color: c]. - self buildHelpFor: widget spec: aSpec. - - self setFrame: aSpec frame in: widget. - self setLayoutHintsFor: widget spec: aSpec. - - parent ifNotNil:[self add: widget to: parent]. - panes ifNotNil:[ - aSpec list ifNotNil:[panes add: aSpec list]. - ]. ^widget! Item was changed: ----- Method: MorphicToolBuilder>>buildPluggableMultiSelectionList: (in category 'widgets optional') ----- buildPluggableMultiSelectionList: aSpec | widget listClass | aSpec getSelected ifNotNil:[^self error:'There is no PluggableListMorphOfManyByItem']. listClass := self multiSelectListClass. widget := listClass on: aSpec model list: aSpec list primarySelection: aSpec getIndex changePrimarySelection: aSpec setIndex listSelection: aSpec getSelectionList changeListSelection: aSpec setSelectionList menu: aSpec menu. - self register: widget id: aSpec name. widget keystrokeActionSelector: aSpec keyPress. + self register: widget id: aSpec name. + self setListPropertiesFor: widget spec: aSpec. - widget getListElementSelector: aSpec listItem. - widget getListSizeSelector: aSpec listSize. - self buildHelpFor: widget spec: aSpec. - self setFrame: aSpec frame in: widget. - self setLayoutHintsFor: widget spec: aSpec. - parent ifNotNil:[self add: widget to: parent]. - panes ifNotNil:[ - aSpec list ifNotNil:[panes add: aSpec list]. - ]. ^widget! Item was added: + ----- Method: MorphicToolBuilder>>setListPropertiesFor:spec: (in category 'private') ----- + setListPropertiesFor: widget spec: aSpec + + "Override default scroll bar policies if needed. Widget will use preference values otherwise." + aSpec hScrollBarPolicy ifNotNil: [:policy | + policy caseOf: { + [#always] -> [widget alwaysShowHScrollBar]. + [#never] -> [widget hideHScrollBarIndefinitely]. + [#whenNeeded] -> [widget showHScrollBarOnlyWhenNeeded]. } ]. + aSpec vScrollBarPolicy ifNotNil: [:policy | + policy caseOf: { + [#always] -> [widget alwaysShowVScrollBar]. + [#never] -> [widget hideVScrollBarIndefinitely]. + [#whenNeeded] -> [widget showVScrollBarOnlyWhenNeeded]. } ]. + + widget + getListElementSelector: aSpec listItem; + getListSizeSelector: aSpec listSize; + getIconSelector: aSpec icon; + getHelpSelector: aSpec helpItem; + doubleClickSelector: aSpec doubleClick. + + widget + autoDeselect: aSpec autoDeselect; + keystrokePreviewSelector: aSpec keystrokePreview. + + aSpec filterableList ifNotNil: [:b | widget filterableList: b]. + aSpec clearFilterAutomatically ifNotNil: [:b | widget clearFilterAutomatically: b]. + + aSpec color ifNotNil: [:c | widget color: c]. + self buildHelpFor: widget spec: aSpec. + + self setFrame: aSpec frame in: widget. + self setLayoutHintsFor: widget spec: aSpec. + + parent ifNotNil:[self add: widget to: parent]. + (panes notNil and: [aSpec list notNil]) ifTrue: [panes add: aSpec list]. + !

1 0

how to extend a class (add methods) and have the source of the methods be in a category other than the one the class is defined in?
by Louis LaBrunda 13 Jan '17

13 Jan '17

Hi All, How does one extend a class (add methods) and have the source of the methods be in a category other than the one the class is originally defined in? I expect this is simple and I'm just missing something easy. Lou -- Louis LaBrunda Keystone Software Corp. SkypeMe callto://PhotonDemon

3 4

how to see primitive source these days?
by Bob Arning 11 Jan '17

11 Jan '17

I'm was copying a FloatArray and it seems not to be using the primitive to move the data over to the copy. Float>>replaceFrom:to:with:startingAt: says it uses a primitive, but it seem to fallback to the code in SequenceableCollection. How can I see the priitive code to see what the issue may be? This is what it says it does: replaceFrom: start to: stop with: replacement startingAt: repStart "Primitive. This destructively replaces elements from start to stop in the receiver starting at index, repStart, in the collection, replacement. Answer the receiver. Range checks are performed in the primitive only. Optional. See Object documentation whatIsAPrimitive." <primitive: 105> super replaceFrom: start to: stop with: replacement startingAt: repStart This is what I did to see if the prim failed: replaceFrom: start to: stop with: replacement startingAt: repStart "Primitive. This destructively replaces elements from start to stop in the receiver starting at index, repStart, in the collection, replacement. Answer the receiver. Range checks are performed in the primitive only. Optional. See Object documentation whatIsAPrimitive." <primitive: 105> WOOPS ifNil: [ WOOPS _ #WOOPS. self halt ]. super replaceFrom: start to: stop with: replacement startingAt: repStart And it did fail and I'm puzzled as to why: Halt: 10 January 2017 7:46:09.382669 am VM: Mac OS - Smalltalk Image: Squeak5.1 [latest update: #16548] SecurityManager state: Restricted: false FileAccess: true SocketAccess: true Working Dir /Users/bob/squeak/Squeak5.1-16548-64bit-All-in-One/Squeak5.1-16548-64bit-All-in-One.app/Contents/Resources Trusted Dir /Users/bob/Library/Application Support/Squeak/ Untrusted Dir /Users/bob/Documents/Squeak/ FloatArray(Object)>>halt Receiver: a FloatArray(0.0 0.0 0.0) Arguments and temporary variables: Receiver's instance variables: a FloatArray(0.0 0.0 0.0) FloatArray>>replaceFrom:to:with:startingAt: Receiver: a FloatArray(0.0 0.0 0.0) Arguments and temporary variables: start: 1 stop: 3 replacement: a FloatArray(1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1...etc... repStart: 1 Receiver's instance variables: a FloatArray(0.0 0.0 0.0) FloatArray(SequenceableCollection)>>copyFrom:to: Receiver: a FloatArray(1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1...etc... Arguments and temporary variables: start: 1 stop: 3 newSize: 3 Receiver's instance variables: a FloatArray(1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1...etc... ConvolutionalLayer>>forward:isTraining:

5 18

Squeak 5.x on freebsd
by Edwin Ancaer 11 Jan '17

11 Jan '17

hello, is there somewhere a recent VM, Image and Changes file that I can download for use on FreeBSD? Of course I could try and build it myself, and I admit it could be a good exercise, but I would like to start using Squeak this year, so I hoped someone more knowledgeable had already done the job.... Thanks, Edwin Ancaer

2 1

Installing Seaside on Squeak
by Louis LaBrunda 10 Jan '17

10 Jan '17

Hi All, I want to install Seaside on Squeak (on windows for now). The instructions for installing Seaside say to install Metacello first. The instructions for Metacello say to run this snippet: Installer gemsource project: 'metacello'; addPackage: 'ConfigurationOfMetacello'; install. But when I run the above snippet it fails with: UndefinedObject(Object)>>doesNotUnderstand: #binary I don't know how to copy more of the stack or I would include it here. I did use the feature to send a bug report but I'm hoping someone can tell me how to get around this while the bug report is being looked at. Thanks in advance for any and all help. Lou -- Louis LaBrunda Keystone Software Corp. SkypeMe callto://PhotonDemon

4 7

[BUG]UndefinedObject(Object)>>doesNotUnderstand: #binary
by Lou＠Keystone-Software.com 09 Jan '17

09 Jan '17

here insert explanation of what you were doing, suspect changes you've made and so forth. 9 January 2017 10:23:06.096906 am VM: Win32 - Smalltalk Image: Squeak5.1 [latest update: #16548] SecurityManager state: Restricted: false FileAccess: true SocketAccess: true Working Dir C:\Program Files (x86)\Squeak\Resources Trusted Dir C:\Program Files (x86)\Squeak\Resources\Louis Untrusted Dir C:\Users\Louis\Documents\My Squeak UndefinedObject(Object)>>doesNotUnderstand: #binary Receiver: nil Arguments and temporary variables: aMessage: binary exception: MessageNotUnderstood: UndefinedObject>>binary resumeValue: nil Receiver's instance variables: nil ZipArchive>>writeTo: Receiver: a ZipArchive Arguments and temporary variables: stream: nil Receiver's instance variables: members: an OrderedCollection(a ZipStringMember(package) a ZipStringMember(vers...etc... centralDirectorySize: nil centralDirectoryOffsetWRTStartingDiskNumber: nil zipFileComment: '' writeCentralDirectoryOffset: 0 writeEOCDOffset: 0 MCMczWriter>>flush Receiver: a MCMczWriter Arguments and temporary variables: Receiver's instance variables: stream: nil zip: a ZipArchive infoWriter: a MCVersionInfoWriter MCMczWriter class>>fileOut:on: Receiver: MCMczWriter Arguments and temporary variables: aVersion: a MCVersion(ConfigurationOfMetacello-topa.802) aStream: nil inst: a MCMczWriter Receiver's instance variables: superclass: MCWriter methodDict: a MethodDictionary(#addString:at:->(MCMczWriter>>#addString:at: "a CompiledMethod...etc... format: 65539 instanceVariables: #('zip' 'infoWriter') organization: ('accessing' format snapshotWriterClass zip) ('initializing' initialize...etc... subclasses: {MCMcdWriter} name: #MCMczWriter classPool: nil sharedPools: nil environment: Smalltalk category: #'Monticello-Storing' MCVersion>>fileOutOn: Receiver: a MCVersion(ConfigurationOfMetacello-topa.802) Arguments and temporary variables: aStream: nil Receiver's instance variables: package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) snapshot: a MCSnapshot dependencies: #() [] in MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aMCVersionOrConfiguration: nil s: a MCVersion(ConfigurationOfMetacello-topa.802) Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCCacheRepository(MCDirectoryRepository)>>writeStreamForFileNamed:replac e:do: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aString: 'ConfigurationOfMetacello-topa.802.mcz' aBoolean: false aBlock: [closure] in MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion:...etc... file: nil sel: #newFileNamed: Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCCacheRepository(MCFileBasedRepository)>>writeStreamForFileNamed:do: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aString: 'ConfigurationOfMetacello-topa.802.mcz' aBlock: [closure] in MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion:...etc... Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aMCVersionOrConfiguration: a MCVersion(ConfigurationOfMetacello-topa.802) Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCCacheRepository>>basicStoreVersion: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aVersion: a MCVersion(ConfigurationOfMetacello-topa.802) Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCCacheRepository(MCRepository)>>storeVersion: Receiver: a MCCacheRepository(C:\Program Files (x86)\Squeak\Resources\package-cache) Arguments and temporary variables: aMCVersionOrConfiguration: a MCVersion(ConfigurationOfMetacello-topa.802) Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: nil allFileNamesCache: nil allVersionNamesCache: nil directory: DosFileDirectory on 'C:\Program Files (x86)\Squeak\Resources\package...etc... packageCaches: nil seenFiles: nil MCVersion>>addToCache Receiver: a MCVersion(ConfigurationOfMetacello-topa.802) Arguments and temporary variables: Receiver's instance variables: package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) snapshot: a MCSnapshot dependencies: #() MCVersion>>initializeWithPackage:info:snapshot:dependencies: Receiver: a MCVersion(ConfigurationOfMetacello-topa.802) Arguments and temporary variables: aPackage: a MCPackage(ConfigurationOfMetacello) aVersionInfo: a MCVersionInfo(ConfigurationOfMetacello-topa.802) aSnapshot: a MCSnapshot aCollection: #() Receiver's instance variables: package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) snapshot: a MCSnapshot dependencies: #() MCVersion class>>package:info:snapshot:dependencies: Receiver: MCVersion Arguments and temporary variables: aPackage: a MCPackage(ConfigurationOfMetacello) aVersionInfo: a MCVersionInfo(ConfigurationOfMetacello-topa.802) aSnapshot: a MCSnapshot aCollection: #() Receiver's instance variables: superclass: Object methodDict: a MethodDictionary(#addToCache->(MCVersion>>#addToCache "a CompiledMethod...etc... format: 65540 instanceVariables: #('package' 'info' 'snapshot' 'dependencies') organization: ('accessing' changes dependencies fileName info package snapshot summary...etc... subclasses: {MCDiffyVersion} name: #MCVersion classPool: nil sharedPools: nil environment: Smalltalk category: #'Monticello-Versioning' MCMczReader(MCVersionReader)>>basicVersion Receiver: a MCMczReader Arguments and temporary variables: Receiver's instance variables: stream: a RWBinaryOrTextStream package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) definitions: {a MCOrganizationDefinition(#(#ConfigurationOfMetacello)) . a MCClassDefinition...etc... dependencies: #() stepChildren: nil zip: a ZipArchive infoCache: a Dictionary(size 800) MCMczReader(MCVersionReader)>>version Receiver: a MCMczReader Arguments and temporary variables: Receiver's instance variables: stream: a RWBinaryOrTextStream package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) definitions: {a MCOrganizationDefinition(#(#ConfigurationOfMetacello)) . a MCClassDefinition...etc... dependencies: #() stepChildren: nil zip: a ZipArchive infoCache: a Dictionary(size 800) [] in MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed: Receiver: a MCHttpRepository(http://seaside.gemtalksystems.com/ss/metacello) Arguments and temporary variables: <<error during printing> Receiver's instance variables: creationTemplate: nil storeDiffs: nil cache: a Dictionary() allFileNamesCache: nil allVersionNamesCache: nil location: 'http://seaside.gemtalksystems.com/ss/metacello' user: '' password: '' readerCache: a Dictionary('ConfigurationOfMetacello-topa.802.mcz'->a MCMczReader...etc... indexed: nil BlockClosure>>cull: Receiver: [closure] in MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed: Arguments and temporary variables: firstArg: a MCMczReader Receiver's instance variables: outerContext: MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed:...etc ... startpc: 27 numArgs: 1 MCMczReader(ProtoObject)>>ifNotNil: Receiver: a MCMczReader Arguments and temporary variables: ifNotNilBlock: [closure] in MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed:...etc ... Receiver's instance variables: stream: a RWBinaryOrTextStream package: a MCPackage(ConfigurationOfMetacello) info: a MCVersionInfo(ConfigurationOfMetacello-topa.802) definitions: {a MCOrganizationDefinition(#(#ConfigurationOfMetacello)) . a MCClassDefinition...etc... dependencies: #() stepChildren: nil zip: a ZipArchive infoCache: a Dictionary(size 800) --- The full stack --- UndefinedObject(Object)>>doesNotUnderstand: #binary ZipArchive>>writeTo: MCMczWriter>>flush MCMczWriter class>>fileOut:on: MCVersion>>fileOutOn: [] in MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion: MCCacheRepository(MCDirectoryRepository)>>writeStreamForFileNamed:replac e:do: MCCacheRepository(MCFileBasedRepository)>>writeStreamForFileNamed:do: MCCacheRepository(MCFileBasedRepository)>>basicStoreVersion: MCCacheRepository>>basicStoreVersion: MCCacheRepository(MCRepository)>>storeVersion: MCVersion>>addToCache MCVersion>>initializeWithPackage:info:snapshot:dependencies: MCVersion class>>package:info:snapshot:dependencies: MCMczReader(MCVersionReader)>>basicVersion MCMczReader(MCVersionReader)>>version [] in MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed: BlockClosure>>cull: MCMczReader(ProtoObject)>>ifNotNil: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - MCHttpRepository>>versionReaderForFileNamed:do: MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed: [] in [] in MCHttpRepository(MCFileBasedRepository)>>versionNamed: BlockClosure>>on:do: [] in MCHttpRepository(MCFileBasedRepository)>>versionNamed: Dictionary>>at:ifAbsent: MCHttpRepository(MCFileBasedRepository)>>versionNamed: [] in InstallerMonticello>>mcThing OrderedCollection>>do: InstallerMonticello>>mcThing [] in InstallerMonticello>>basicInstall BlockClosure>>on:do: BlockClosure>>valueSupplyingAnswers: BlockClosure>>valueSuppressingMessages:supplyingAnswers: InstallerMonticello(Installer)>>withAnswersDo: InstallerMonticello>>basicInstall [] in InstallerMonticello(Installer)>>installLogging InstallerMonticello(Installer)>>logErrorDuring: InstallerMonticello(Installer)>>installLogging InstallerMonticello(Installer)>>install UndefinedObject>>DoIt Compiler>>evaluateCue:ifFail: Compiler>>evaluateCue:ifFail:logged: Compiler>>evaluate:in:to:notifying:ifFail:logged: [] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: BlockClosure>>on:do: SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: SmalltalkEditor(TextEditor)>>evaluateSelection [] in PluggableTextMorphPlus(PluggableTextMorph)>>doIt TextMorphForEditView(TextMorph)>>handleEdit: PluggableTextMorphPlus(PluggableTextMorph)>>handleEdit: PluggableTextMorphPlus(PluggableTextMorph)>>doIt Workspace(StringHolder)>>perform:orSendTo: [] in MenuItemMorph>>invokeWithEvent: BlockClosure>>ensure: CursorWithMask(Cursor)>>showWhile: MenuItemMorph>>invokeWithEvent: MenuItemMorph>>mouseUp: MenuItemMorph>>handleMouseUp: MouseButtonEvent>>sentTo: MenuItemMorph(Morph)>>handleEvent: MorphicEventDispatcher>>dispatchEvent:withHandler:withMorph: -- and more not shown --

2 1

Integer arithmetic and bit operations in Squeak and Pharo (32bit & 64bit)
by Benoit St-Jean 09 Jan '17

09 Jan '17

Hello guys, A few questions/comments/remarks about integer arithmetic and bit operations. And I guess many of my interrogations most likely concern the guys building the VM/primitives... I'm working on a chess engine that will rely heavily on bitboard manipulations, i.e. lots of integer arithmetic with bit operations. I was comparing the 32bit & 64bit Spur VM for Squeak & Pharo (I want the chess engine to be portable on Squeak & Pharo). As I pointed out earlier on on the Squeak-dev mailing list in october 2016, there are a few things that look strange to me and/or that I do not understand. 1) #bitXor: performs the same on the 32bit & 64bit VM for LargePositiveInteger. BUT, on average, #bitXor: is 15 (fifteen) times *slower* on LargePositiveInteger than with SmallInteger, for both 32 & 64 bit VM/Image. Besides, with SmallInteger, #bitXor: is 4.5 faster on 32bit as compared to 64bit!! You can test (on 32bit & 64bit) that with the following snippet: | small1 small2 small3 large1 large2 n timeSmall timeLarge | small1 := 2r1111111111111111. "65535, (1<<16)-1" small2 := (1 << 30) - 1. "Largest SmallInteger on 32bit VM/Image, SmallInteger maxVal" small3 := 1152921504606846975. "Largest Integer on 64bit VM/Image, SmallInteger maxVal" large1 := (1 << 64)-1. "64 bits set to 1" large2 := (1 << 80)-1. "80 bits set to 1" n := 100000000. timeSmall := Time millisecondsToRun: [n timesRepeat: [ small1 bitXor: small2]]. timeLarge := Time millisecondsToRun: [n timesRepeat: [ large1 bitXor: large2]]. Transcript cr;show: 'Time LargePositiveInteger : ', timeLarge printString. Transcript cr;show: 'Time SmallInteger : ', timeSmall printString. As was pointed out by Nicolas Cellier in a private communication, one workaround is to add the method #bitXor: in the class LargePositiveInteger to get a 3x performance boost. Nicolas recommended the following code: LargePositiveInteger>>bitXor: arg <primitive:36> ^super bitXor: arg It's all good and nice (and I do get a 3x speedup, in 32&64 bit) but then I wonder in which respect primitive 36 is different from the one LargePositiveInteger usually inherits from Integer : (Integer>>bitXor:) <primitive: 'primDigitBitXor' module:'LargeIntegers'> Why does Nicolas' workaround is able to do the job (calling primitive 36) when there is already a primitive for the exact thing (<primitive: 'primDigitBitXor' module:'LargeIntegers'>) ? Is this duplicate code or there is a reason for this? And why is the primDigitBitXor primitive so slow as compared to primitive 36? 2) One would normally expect the 64bit VM to be faster than the 32bit VM. That's true in all cases except... Well, first, some numbers (Test case attached to this email if you want to reproduce) 32bit Number of #allMask: per second : 6.20M Number of #anyMask: per second : 7.17M Number of #bitAnd: per second : 8.45M Number of #bitAt: per second : 55.15M Number of #bitAt:put: per second : 37.22M Number of #bitClear: per second : 5.18M Number of #bitInvert per second : 6.53M Number of #bitOr: per second : 9.18M Number of #bitXor: per second : 8.97M Number of #highBit per second : 43.23M Number of #<< per second : 11.34M Number of #lowBit per second : 69.44M Number of #noMask: per second : 7.40M Number of #>> per second : 12.36M 64bit Number of #allMask: per second : 10.26M Number of #anyMask: per second : 10.37M Number of #bitAnd: per second : 17.00M Number of #bitAt: per second : 15.89M Number of #bitAt:put: per second : 10.36M Number of #bitClear: per second : 6.44M Number of #bitInvert per second : 9.11M Number of #bitOr: per second : 18.45M Number of #bitXor: per second : 15.38M Number of #highBit per second : 7.66M Number of #<< per second : 10.50M Number of #lowBit per second : 13.49M Number of #noMask: per second : 11.47M Number of #>> per second : 10.52M There are a few surprises here. First, #bitAt:, #bitAt:put:, #highBit and #lowBit are a *lot faster* on the 32bit VM than on the 64bit VM! Does anyone have an explanation for this? Is this normal? The other surprise is that #>> and #<< seem to be about the same speed on both VM. Any reason why the 64bit version isn't faster than the 32bit one? 3) I was surprised to find out that SmallInteger>>#maxVal wasn't a constant (or the same on both VM). It's (1<<60)-1 on the 64bit VM and (1<<30)-1 on the 32bit VM. So, be warned if your code depends on SmallInteger>>#maxVal for some reason! 4) Is there any rationale/reason/explanation as to why, in Pharo, LargePositiveInteger inherits from the class LargeInteger (which doesn't exist in Squeak) ? Thanks in advance. ----------------- Benoît St-Jean Yahoo! Messenger: bstjean Twitter: @BenLeChialeux Pinterest: benoitstjean Instagram: Chef_Benito IRC: lamneth Blogue: endormitoire.wordpress.com "A standpoint is an intellectual horizon of radius zero". (A. Einstein)

3 3

Plumbing' rises again!
by tim Rowledge 08 Jan '17

08 Jan '17

I was tidying up my swiki page on drag/drop and realised that the Plumbin’ demo really ought to be moved to squeaksource - so I did it. See http://www.squeaksource.com/PlumbingDemo.html tim -- tim Rowledge; tim(a)rowledge.org; http://www.rowledge.org/tim Strange OpCodes: HAL: Murder Operator

2 2

UK Smalltalk User Group Meeting - Monday, January 30th.
by Giovanni Corriga 07 Jan '17

07 Jan '17

Happy New Year! The first 2017 meeting of the UK Smalltalk User Group Meeting will be on Monday, January 30th. We'll meet at our usual venue The Counting House ( http://www.the-counting-house.com/) at 7pm. If you'd like to join us, you can just show up at the pub. You can also sign up in advance at the meeting's Meetup page: *https://www.meetup.com/UKSTUG/events/236496717/ <https://www.meetup.com/UKSTUG/events/236496717/>* . See you there! Giovanni

1 0

<Programming> 2017: Call for workshop, symposium & poster submissions
by Tim Molderez 06 Jan '17

06 Jan '17

----------------------------------------------------------------------- <Programming> 2017 : The Art, Science, and Engineering of Programming April 3-6, 2017, Brussels, Belgium http://2017.programming-conference.org ----------------------------------------------------------------------- We are excited to announce there will be 10 co-located events at the <Programming> 2017 conference (and more to come!): - ELS 2017 - 10th European Lisp Symposium - Modularity 2017 Invited talks - International Symposium on Modularity - ACM Student Research Competition / <Programming> 2017 Posters - LASSY 2017 - 2nd Workshop on Live Adaptation of Software SYstems - MOMO 2017 - 2nd Workshop on Modularity in Modelling - MoreVMs 2017 - 1st Workshop on Modern Language Runtimes, Ecosystems, and VMs - PASS 2017 - 1st Workshop on Programming Across the System Stack - PX 2017 - 2nd Workshop on Programming Experience - ProWeb 2017 - 1st Workshop on Programming Technology for the Future Web - Salon des Refusés 2017 - 1st edition of the Salon des Refusés workshop All co-located events will take place during April 3-4 2017. CFPs for each of these events are listed below. (apart from Modularity 2017, which is invitation-based) **************************************************************** ELS 2017 - 10th European Lisp Symposium Submissions: Mon 30 Jan 2017 Notifications: Mon 27 Feb 2017 http://2017.programming-conference.org/track/els-2017 **************************************************************** The purpose of the European Lisp Symposium is to provide a forum for the discussion and dissemination of all aspects of design, implementation and application of any of the Lisp and Lisp-inspired dialects, including Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, ECMAScript, Racket, SKILL, Hop and so on. We encourage everyone interested in Lisp to participate. The 10th European Lisp Symposium invites high quality papers about novel research results, insights and lessons learned from practical applications and educational perspectives. We also encourage submissions about known ideas as long as they are presented in a new setting and/or in a highly elegant way. Topics include but are not limited to: * Context-, aspect-, domain-oriented and generative programming * Macro-, reflective-, meta- and/or rule-based development approaches * Language design and implementation * Language integration, inter-operation and deployment * Development methodologies, support and environments * Educational approaches and perspectives * Experience reports and case studies ******************************************************************** ACM Student Research Competition / <Programming> 2017 Posters Submissions: Mon 16 Jan 2017 http://2017.programming-conference.org/track/programming-posters ******************************************************************** The ACM Student Research Competition (SRC), sponsored by Microsoft Research, offers a unique forum for ACM student members at the undergraduate and graduate levels to present their original research before a panel of judges and conference attendees. The SRC gives visibility to up-and-coming young researchers, and offers them an opportunity to discuss their research with experts in their field, get feedback, and to help sharpen communication and networking skills. ACM’s SRC program covers expenses up to $500 for all students invited to an SRC. Please see our website for requirements and further details. ****************************************************************** LASSY 2017 - 2nd Workshop on Live Adaptation of Software SYstems Submissions: Fri 3 Feb 2017 Notifications: Fri 3 Mar 2017 http://2017.programming-conference.org/track/LASSY-2017-papers ****************************************************************** When developing current-day software systems, their deployment and usage environments should be considered carefully, in order to understand the adaptations those systems might need to undergo to interact with other systems and with their environment. Moreover, due to the portability, mobility and increasingly evolutionary nature of software systems, such adaptations should be enacted even while the system is running. Developing such software systems can prove challenging, and many seemingly different techniques to address this concern have been proposed over the last couple of years. The intention of the LASSY workshop is to congregate all topics relevant to dynamic adaptation and run-time evolution of software systems, ranging from a computer science perspective covering the domains of programming languages, model-driven software development, software and service composition, context-aware databases, software variability, requirements engineering, UI adaptation and other domains, to a human perspective covering sociological or ethical implications of dynamic software systems. The workshop provides a space for discussion and collaboration between researchers working on the problem of enabling live adaptations to software systems, across the development stack. Topics of Interest: * Design and Implementation of Live Adaptive Software Systems * Context-, aspect-, feature-, role- and agent-oriented programming * Context representation and discovery * Context-aware model-driven software development * Context-aware data management * Software variability and dynamic product lines * Self-adaptive, self-explanatory systems * Inconsistency management, verification, and validation * Middleware and Runtime of Live Adaptive Software Systems * Dynamic software evolution, upgrades and configuration * Dynamic software and service composition mechanisms * Dynamic software architecture and middleware approaches * Dynamic user interface adaptation and multimodal user interfaces * Impact and Assessment of Live Adaptive Software Systems * User acceptance and usability issues * Human, sociological, ethical and legal aspects * Privacy and security aspects of dynamic adaptability * Live adaptation in smart environments (e.g. smart rooms, smart robot cells, smart factories, smart cities) * Self-adaptation and emergence in SoS and CPSoS **************************************************************** MOMO 2017 - 2nd Workshop on Modularity in Modelling Abstract submissions (optional): Sun Jan 29 2017 Paper submissions: Sun Feb 5 2017 Notifications: Wed Feb 22 2017 http://www.momo2017.ece.mcgill.ca/cfp.htm **************************************************************** Extending the time-honored practice of separation of concerns, Model-Driven Engineering (MDE) promotes the use of separate models to address the various concerns in the development of complex software-intensive systems. The main objective is to choose the right level of abstraction to modularize a concern, specify its properties and reason about the system under development depending on stakeholder and development needs. While some of these models can be defined with a single modelling language, a variety of heterogeneous models and languages are typically used in the various phases of software development. Furthermore, Domain-Specific Modelling Languages designed to address particular concerns are also increasingly used. Despite the power of abstraction of modelling, models of real-world problems and systems quickly grow to such an extent that managing the complexity by using proper modularization techniques becomes necessary. As a result, many (standard) modelling notations have been extended with aspect-oriented mechanisms and advanced composition operators to support advanced separation of concerns, to combine (possibly heterogeneous) models modularizing different concerns, to execute an application based on modularized models, and to reason over global properties of modularized models. The Second International Modularity in Modelling Workshop brings together researchers and practitioners interested in the theoretical and practical challenges resulting from applying modularity, advanced separation of concerns, and advanced composition at the modelling level. It is intended to provide a forum for presenting new ideas and discussing the impact of the use of modularization in the context of MDE at different levels of abstraction. We are interested in submissions on all topics related to modularity and modelling including but not limited to: * Modularization Support in Modelling Languages and Tools * Model Interfaces * Homogeneous Model Composition Operators * Heterogeneous Model Composition Operators * Visualization of Modularized and Composed Models * Effects of Using Modularization and Composition in Modelling * On Verification and Validation * On Reuse * On the Model-Driven Software Development Process (Requirements Engineering, Software Architecture, Software Design, Implementation) * On Maintenance * Experience Reports / Empirical Evaluations of Applying Modularization and Composition in Modelling * Feature-Oriented, Aspect-Oriented and Concern-Oriented Modelling * Modularization support and composition operators for specific modelling notations * Modelling essential characteristics of specific (crosscutting) concerns * Multi-View Modelling: avoiding inconsistencies, avoiding Redundancies * Support for Detecting and/or Resolution of Feature Interactions * Domain-Specific Modelling * Modularization for Domain-Specific Languages * Composition for Domain-Specific Languages * Domain-specific Aspect Models ****************************************************************************** MoreVMs 2017 - 1st Workshop on Modern Language Runtimes, Ecosystems, and VMs Submissions: Wed 15 Feb 2017 Notifications: Wed 1 Mar 2017 http://2017.programming-conference.org/track/MoreVMs-2017-papers ****************************************************************************** The main goal of the workshop is to bring together both researchers and practitioners and facilitate effective sharing of their respective experiences and ideas on how languages and runtimes are utilized and where they need to improve further. We welcome presentation proposals in the form of extended abstracts discussing experiences, work-in-progress, as well as future visions from the academic as well as industrial perspective. Relevant topics include, but are definitely not limited to, the following: * Extensible VM design (compiler- or interpreter-based VMs) * Reusable runtime components (e.g. interpreters, garbage collectors, intermediate representations) * Static and dynamic compiler techniques * Techniques for compilation to high-level languages such as JavaScript * Runtimes and mechanisms for interoperability between languages * Tooling support (e.g. debugging, profiling, etc.) * Programming language development environments and virtual machines * Case studies of existing language implementations, virtual machines, and runtime components (e.g. design choices, tradeoffs, etc.) * Language implementation challenges and trade-offs (e.g. performance, completeness, etc.) * Surveys and applications usage reports to understand runtime usage in the wild * Surveys on frameworks and their impact on runtime usage * New research ideas on how we want to build languages in the future ************************************************************************** PASS 2017 - 1st Workshop on Programming Across the System Stack Submissions: Mon 13 Feb 2017 Notifications: Mon 27 Feb 2017 http://2017.programming-conference.org/track/PASS-2017#Call-for-Papers ************************************************************************** The landscape of computation platforms has changed dramatically in recent years. Emerging systems - such as wearable devices, smartphones, unmanned aerial vehicles, Internet of things, cloud computing servers, heterogeneous clusters, and data centers - pose a distinct set of system-oriented challenges ranging from data throughput, energy efficiency, security, real-time guarantees, to high performance. In the meantime, code quality, such as modularity or extensibility, remains a cornerstone in modern software engineering, bringing in crucial benefits such as modular reasoning, program understanding, and collaborative software development. Current methodologies and software development technologies should be revised in order to produce software to meet system-oriented goals, while preserving high internal code quality. The role of the Software Engineer is essential, having to be aware of the implications that each design, architecture and implementation decision has on the application system ecosystem. This workshop is driven by one fundamental question: How does internal code quality interact with system-oriented goals? We welcome both positive and negative responses to this question. An example of the former would be modular reasoning systems specifically designed to promote system-oriented goals, whereas an example of the latter would be anti-patterns against system-oriented goals during software development. Areas of interest include but are not limited to: * Energy-aware software engineering (e.g. energy efficiency models, energy efficiency as a quality attribute) * Modularity support (e.g., programming language design, development tools or verification) for applications in resource-constrained or real-time systems * Emerging platforms (e.g., Internet of Things and wearable devices) * Security support (e.g., compositional information flow, compositional program analysis) * Software architecture for reusability and adaptability in systems and their interactions with applications * Empirical studies (patterns and anti-patterns) on the relationship between internal code quality and system-oriented goals * Software engineering techniques to balance the trade-off between internal code quality and efficiency * Memory bloats and long-tail performance problems across modular boundaries * Program optimization across modular boundaries * Internal code quality in systems software * Reasoning across applications, compilers, and virtual machines **************************************************************** PX 2017 - 2nd Programming Experience Workshop Submissions: Sat 4 Feb 2017 Notifications: Mon 27 Feb 2017 http://programming-experience.org/px17 **************************************************************** Imagine a software development task: some sort of requirements and specification including performance goals and perhaps a platform and programming language. A group of developers head into a vast workroom. In that room they discover they need to explore the domain and the nature of potential solutions—they need exploratory programming. The Programming Experience Workshop is about what happens in that room when one or a couple of programmers sit down in front of computers and produce code, especially when it’s exploratory programming. Do they create text that is transformed into running behavior (the old way), or do they operate on behavior directly (“liveness”); are they exploring the live domain to understand the true nature of the requirements; are they like authors creating new worlds; does visualization matter; is the experience immediate, immersive, vivid and continuous; do fluency, literacy, and learning matter; do they build tools, meta-tools; are they creating languages to express new concepts quickly and easily; and curiously, is joy relevant to the experience? Correctness, performance, standard tools, foundations, and text-as-program are important traditional research areas, but the experience of programming and how to improve and evolve it are the focus of this workshop, and in this edition we would like to focus on exploratory programming. The technical topics include: * Exploratory programming * Live programming * Authoring * Representation of active content * Visualization * Navigation * Modularity mechanisms * Immediacy * Literacy * Fluency * Learning * Tool building * Language engineering ************************************************************************* ProWeb 2017 - 1st Workshop on Programming Technology for the Future Web Submissions: Wed 15 Feb 2017 Notifications: Wed 1 Mar 2017 http://2017.programming-conference.org/track/proweb-2017-papers ************************************************************************* Full-fledged web applications have become ubiquitous on desktop and mobile devices alike. Whereas “responsive” web applications already offered a more desktop-like experience, there is an increasing demand for “rich” web applications (RIAs) that offer collaborative and even off-line functionality —Google docs being the prototypical example. Long gone are the days that web servers merely had to answer incoming HTTP request with a block of static HTML. Today’s servers react to a continuous stream of events coming from JavaScript applications that have been pushed to clients. As a result, application logic and data is increasingly distributed. Traditional dichotomies such as “client vs. server” and “offline vs. online” are fading. The 1st International Workshop on Programming Technology for the Future Web, or ProWeb17, is a forum for researchers and practitioners to share and discuss new technology for programming these and future evolutions of the web. We welcome submissions introducing programming technology (i.e., frameworks, libraries, programming languages, program analyses and development tools) for implementing web applications and for maintaining their quality over time, as well as experience reports about the use of state-of-the-art programming technology. Relevant topics include, but are not limited to: * Quality on the new web: static and dynamic program analyses; code, design test and process metrics; development and migration tools; automated testing and test generation; contract systems, type systems, and web service API conformance checking; … * Hosting languages on the web: new runtimes; transpilation or compilation to JavaScript, WebAssembly, asm.js, … * Designing languages for the web: multi-tier (or tierless) programming; reactive programming; frameworks for multi-tier or reactive programming on the web; … * Distributed data sharing, replication and consistency: cloud types, CRDTs, eventual consistency, offline storage, peer-to-peer communication, … * Security on the web: client-side and server-side security policies; policy enforcement; proxies and membranes; vulnerability detection; dynamic patching, … * Surveys and case studies using state-of-the-art web technology (e.g., WebAssembly, WebSocket, LocalStorage, AppCache, ServiceWorkers, Meteor, deepstream.io, Angular.js, React and React Native, Swarm.js, Caja, TypeScript, Proxies, ClojureScript, Amber Smalltalk, Scala.js, …) * Ideas on and experience reports about: how to reconcile the need for quality with the need for agility on the web; how to master and combine the myriad of tier-specific technologies required to develop a web application, … * Position statements on what the future of the web will look like **************************************************************** Salon des Refusés 2017 Submissions: Wed 1 Feb 2017 Notifications: Fri 17 Feb 2017 https://refuses.github.io **************************************************************** Salon des Refusés (“exhibition of rejects”) was an 1863 exhibition of artworks rejected from the official Paris Salon. The jury of Paris Salon required near-photographic realism and classified works according to a strict genre hierarchy. Paintings by many, later famous, modernists such as Édouard Manet were rejected and appeared in what became known as the Salon des Refusés. This workshop aims to be the programming language research equivalent of Salon des Refusés. We provide a venue for exploring new ideas and new ways of doing computer science. Many interesting ideas about programming might struggle to find space in the modern programming language research community, often because they are difficult to evaluate using established evaluation methods (be it proofs, measurements or controlled user studies). As a result, new ideas are often seen as “unscientific”. This workshop provides a venue where such interesting and thought-provoking ideas can be exposed to critical evaluation. Submissions that provoke interesting discussion among the program committee members will be published together with an attributed review that presents an alternative position, develops additional context or summarizes discussion from the workshop. This means of engaging with papers not just enables explorations of novel programming ideas, but also encourages new ways of doing computer science. Topics of interest The scope of the workshop is determined more by the format of submissions than by the specific area of programming language or computer science research that we are interested in. We welcome submissions in a format that makes it possible to think about programming in a new way, including, but not limited to: * Thought experiments – we believe that thought experiments, analogies and illustrative metaphors can provide novel insights and inspire fruitful programming language ideas. * Experimentation – we find prejudices in favour of theory, as far back as there is institutionalized science, but programming can often be seen more as experimentation than as theorizing. We welcome interesting experiments even if there is yet no overarching theory that explains why they happened. * Paradigms – all scientific work is rooted in a scientific paradigm that frame what questions can be asked. We encourage submissions that reflect on existing paradigms or explore alternative scientific paradigms. * Metaphors, myths and analogies – any description of formal, mathematical, quantitative or even poetical nature still represents just an analogy. We believe that fruitful ideas can be learned from less common forms of analogies as well as from the predominant, formal and mathematical ones. * From jokes to science fiction – a story or an artistic performance may explore ideas and spark conversations that provide crucial inspiration for development of new computer science thinking.

1 0