Dear Moose community,
In the past two years, I have been working on 3D visualization of
software. During this time I developed a tool called CodeCity, built
on top of Moose.
In CodeCity, software systems are represented as cities. Some of you
may have seen a demo of CodeCity during ESUG 2007 or at the Moose Dojo.
However, not many of you have played with it yet. Let's change that!
You can download CodeCity at:
http://www.inf.unisi.ch/phd/wettel/codecity.html
I would appreciate your feedback and use it to make the next release
of CodeCity better.
Cheers,
Ricky
Hi,
We are pleased to announce that a new edition of FAMOOSr (Workshop on
FAMIX and Moose in Reengineering) is going to be organized together
with TOOLS 2008.
The workshop will be a 1 day event and will take place at the end of
June or beginning of July. The exact day will be announced later.
The deadline for submissions of either experience reports (4 pages) or
position papers (2 pages) is: May 5.
More information can be found at:
http://moose.unibe.ch/events/famoosr2008
Cheers,
Doru, Orla and Michele
stef,
My question means that : how can i extract the informations from mse
file? Is it possible to use this format like a moose model in
implementation? Is it possible to do something like: anMseFile allClasses?
thanks,
Azadeh
Hi,
I would to use ArrowShape for some edges but I did not succeed yet :-(
I specified the edges shape like that:
...
using: (ArrowShape goofy)
but that did not work, how we can visualizing edges as arrow and how
we can specifying the direction of the arrow (ex: #atEnd #atStart).
thanks,
hani
Hi,
In some visualization I need the CircleLayout. But the pb in the
actual implementation of this layout that some nodes could appear over
(or very very near of) some other nodes; while some other nodes
appear with a very high distance from the rest (see the attached
picture). This way visualizations does not scale well and we have the
pb of overheads.
In the attached picture I specified the layout as following: view
circleLayout scaleBy: 50.
If I increase the number of scale the view will be very very large and
if I decrease it we will have a lot of overheads.
Could we do something for ameliorating this layout?
do you know an another layout that work well for cases that we could
have ad-hoc edges between a large number of nodes? (I tested the
ForceBasedLayout and unfortunately it does not work well for such a
case as in the attached picture)
best wishes,
hani
Hi
I have two question, thanks to help me.
1)
I know that the MSE format allows to specify models for import and
export with Moose. My question is that how I can import the MSE format
as a model in the code not in Moose tool. I need to import different
versions of Moose as an input model in my system that is based on Moose
and my model is a MooseModel. I import my Moose model as the bundles
like this:
^ Model5 addEntity: (SCG.Moose.PundleImporter new model: model5;
addBundleNamed: 'Moose';run).
2)
Is there any possibility to understand, in existed Moose architecture,
what are the classes or packages in the different components. For
example, what are the classes in Meta Description or in Meta Model?
Do you know any work on Moose Architecture that explain the notion of
entities in the components?
Thanks,
Azadeh
Helo,
I would use Mondrian.DistributionMap that you have recently
implemented, but the pb that I had is:
-each distributed entity has at less two properties (let us imagine:
'first property'->'fill color darkness' and 'second property'->'border
color darkness').
-in some models may be we will have more than two properties to map:
we can have 4, 5, etc. of properties but in the same time any given
entity could not be attached to more than two properties (in other
words we need to mapping different properties to different colors).
-could we have the possibility to use different shapes for the
distributed entities (some entities are boxes while some others are
ovals).
Now could you, please, tell me how to improve the actual
implementation of distribution map? may be we should implement a new
distribution map, what you think about the time cost?
any help is appreciated, i should going on very fast :-)
best wishes,
hani
hello,
two bugs:
Collection>#union: and Collection>#collectUnion:
the first pb is where the receiver is a set,
and the second one is that (#(1 2 3) union: #(1 2 3 4))-->#(1 2 3
4), but (#(#(1 2) #(2 3) #(3 4)) collectUnion: [:each])-->#(1 2 2 3
3 4).
I have added some new asserts inside CollectionTest>>#testCollectUnion
(actually there is two red tests in this class) and published a new
version of CodeFooDevelopment.
best wishes,
hani
Hi all
azadeh would like to study the evolution of the architecture of Moose.
So do you think that this is possible to load old versions of Moose?
Are the configurations correct (I mean will load the associated bundle)?
Do you have a suggestion of five versions that are working with MSE
savings?
Thanks
Hi,
Does anyone here knows a good solution for embedding high resolution
movies in a webpage? Perhaps something like YouTube, but with higher
resolution.
Cheers,
Doru
--
www.tudorgirba.comwww.tudorgirba.com/blog
"Be rather willing to give than demanding to get."
Hi
Once I build an mse exporter in Squeak and today I tried to load the
file and I got an Hapax exception :(
I would like to know if this is my exporter that I have to change and
also if I have to perlify all the mse models that I exported back then
Stef
I tried to load an old mse file into moose and I got this error.
I found strange that EMOF has to do something with HapaxModle
I sent the zipped file but it is blocked by the moderator.
Stef
Unhandled exception: Import error: unknwon EMOF class
'Smalltalk.Hapax.HapaxModel'.
SCG.Moose.MooseImporter(Meta.Importer)>>elementNotFound:
optimized [] in Meta.Importer>>newInstanceOf:
Dictionary>>at:ifAbsent:
Meta.Repository>>atQualifiedName:ifAbsent:
SCG.Moose.MooseImporter(Meta.Importer)>>newInstanceOf:
SCG.Moose.MooseImporter>>newInstanceOf:
Meta.FirstPass>>visitElementHead:with:
Meta.ElementSpec>>mseAccept:
optimized [] in Meta.AttributeSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.AttributeSpec>>mseAccept:
optimized [] in Meta.ElementSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.ElementSpec>>attributesDo:
Meta.ElementSpec>>mseAccept:
optimized [] in Meta.ExtentSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.ExtentSpec>>elementsDo:
Meta.ExtentSpec>>mseAccept:
Meta.FirstPass(Meta.MSESpecVisitor)>>basicRunOn:
Meta.FirstPass(Meta.MSESpecVisitor)>>runOn:
Meta.FirstPass class>>on:visit:
SCG.Moose.MooseImporter(Meta.Importer)>>importMSE:
SCG.Moose.MooseImporter(Meta.Importer)>>importStream:
SCG.Moose.MooseImporter(Meta.Importer)>>taskRun
TaskHolder>>basicRun
optimized [] in [] in Task>>runWithProgress
optimized [] in [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
BlockClosure>>ensure:
Cursor>>showWhile:
optimized [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in [] in [] in Notice
class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in [] in Notice class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in Notice class>>showNotice:complete:while:title:
BlockClosure>>ensure:
Notice class>>showNotice:complete:while:title:
optimized [] in Task>>runWithProgress
BlockClosure>>ensure:
TaskHolder(Task)>>runWithProgress
optimized [] in SCG.Moose.MooseModel>>importMSEFromFile
Time class>>microsecondsToRun:
Time class>>millisecondsToRun:
BlockClosure>>millisecondsToRun
SCG.Moose.MooseModel>>importMSEFromFile
SCG.Moose.MooseBrowser>>importMSEFromFile
optimized [] in ApplicationModel>>actionFor:
optimized [] in ActionButtonSpec>>typeConvert:
PluggableAdaptor>>setValue:
PluggableAdaptor(ValueModel)>>value:
TriggerButtonController>>pressAction
TriggerButtonTracker(BasicButtonTracker)>>finishSelectionFor:
TriggerButtonTracker>>finishSelectionFor:
TriggerButtonTracker(SelectionTracker)>>redButtonReleasedEvent:
RedButtonReleasedEvent>>dispatchTo:
TriggerButtonTracker(SelectionTracker)>>handleEvent:
EventDispatcher>>dispatch:to:
EventDispatcher>>dispatchEvent:
RedButtonReleasedEvent(Event)>>dispatch
RedButtonReleasedEvent(Event)>>dispatchForWindowManager:
optimized [] in WindowManager>>safelyDispatchForWindowManager:
BlockClosure>>on:do:
WindowManager>>safelyDispatchForWindowManager:
WindowManager>>processNextEvent
optimized [] in [] in WindowManager>>newProcess
BlockClosure>>on:do:
optimized [] in WindowManager>>newProcess
BlockClosure>>on:do:
optimized [] in Process class>>forBlock:priority:
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>elementNotFound:
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Arguments:
aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 7
----------------------------------------------------------------------
optimized [] in Meta.Importer>>newInstanceOf:
Receiver:
an UndefinedObject
Temporaries:
.self = a SCG.Moose.MooseImporter[396]
.aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 7
----------------------------------------------------------------------
Dictionary>>at:ifAbsent:
Receiver:
a Dictionary
Instance Variables:
tally = 830
Arguments:
key = #{Smalltalk::Hapax::HapaxModel}
aBlock = BlockClosure [] in Meta.Importer>>newInstanceOf:
Temporaries:
index = 157
obj = nil
Context PC = 17
----------------------------------------------------------------------
Meta.Repository>>atQualifiedName:ifAbsent:
Receiver:
a Meta.Repository
Instance Variables:
elements = an IdentitySet[830]
name = 'Default metamodel'
pathMap = a Dictionary[830]
smalltalkMap = an IdentityDictionary[136]
metaRepository = a Meta.Repository[63]
Arguments:
qualifiedName = #{Smalltalk::Hapax::HapaxModel}
aBlock = BlockClosure [] in Meta.Importer>>newInstanceOf:
Context PC = 6
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>newInstanceOf:
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Arguments:
aName = 'Smalltalk.Hapax.HapaxModel'
Temporaries:
metaClass = nil
Context PC = 11
----------------------------------------------------------------------
SCG.Moose.MooseImporter>>newInstanceOf:
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Arguments:
aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 22
----------------------------------------------------------------------
Meta.FirstPass>>visitElementHead:with:
Receiver:
a Meta.FirstPass
Instance Variables:
elementStack = an CodeFoo.ArrayList[1]
propertyStack = an CodeFoo.ArrayList[1]
specStack = an CodeFoo.ArrayList[2]
context = a SCG.Moose.MooseImporter[396]
Arguments:
className = 'Smalltalk.Hapax.HapaxModel'
uniqueID = 399
Temporaries:
element = nil
Context PC = 4
----------------------------------------------------------------------
Meta.ElementSpec>>mseAccept:
Receiver:
an Meta.ElementSpec
Instance Variables:
content = an Array[0]
name = 'Smalltalk.Hapax.HapaxModel'
uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
visitor = a Meta.FirstPass
Temporaries:
element = nil
Context PC = 18
----------------------------------------------------------------------
optimized [] in Meta.AttributeSpec>>mseAccept:
Receiver:
an UndefinedObject
Arguments:
each = a Meta.ElementSpec
Temporaries:
value = nil
.visitor = a Meta.FirstPass
.values = an OrderedCollection[395]
Context PC = 9
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
an Array
Arguments:
aBlock = BlockClosure [] in Meta.AttributeSpec>>mseAccept:
Temporaries:
i = 396
Context PC = 19
----------------------------------------------------------------------
Meta.AttributeSpec>>mseAccept:
Receiver:
an Meta.AttributeSpec
Instance Variables:
content = an Array[12130]
name = 'entity'
Arguments:
visitor = a Meta.FirstPass
Temporaries:
values = an OrderedCollection[395]
property = 'entity'
Context PC = 32
----------------------------------------------------------------------
optimized [] in Meta.ElementSpec>>mseAccept:
Receiver:
an UndefinedObject
Arguments:
each = a Meta.AttributeSpec
Temporaries:
.visitor = a Meta.FirstPass
Context PC = 9
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
an Array
Arguments:
aBlock = BlockClosure [] in Meta.ElementSpec>>mseAccept:
Temporaries:
i = 3
Context PC = 19
----------------------------------------------------------------------
Meta.ElementSpec>>attributesDo:
Receiver:
an Meta.ElementSpec
Instance Variables:
content = an Array[5]
name = 'Moose.Model'
uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
aBlock = BlockClosure [] in Meta.ElementSpec>>mseAccept:
Context PC = 5
----------------------------------------------------------------------
Meta.ElementSpec>>mseAccept:
Receiver:
an Meta.ElementSpec
Instance Variables:
content = an Array[5]
name = 'Moose.Model'
uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
visitor = a Meta.FirstPass
Temporaries:
element = 'Moose.Model'->1
Context PC = 38
----------------------------------------------------------------------
optimized [] in Meta.ExtentSpec>>mseAccept:
Receiver:
an UndefinedObject
Arguments:
each = a Meta.ElementSpec
Temporaries:
.visitor = a Meta.FirstPass
result = nil
Context PC = 6
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
an Array
Arguments:
aBlock = BlockClosure [] in Meta.ExtentSpec>>mseAccept:
Temporaries:
i = 1
Context PC = 19
----------------------------------------------------------------------
Meta.ExtentSpec>>elementsDo:
Receiver:
an Meta.ExtentSpec
Instance Variables:
content = an Array[1]
Arguments:
aBlock = BlockClosure [] in Meta.ExtentSpec>>mseAccept:
Context PC = 5
----------------------------------------------------------------------
Meta.ExtentSpec>>mseAccept:
Receiver:
an Meta.ExtentSpec
Instance Variables:
content = an Array[1]
Arguments:
visitor = a Meta.FirstPass
Temporaries:
result = nil
Context PC = 15
----------------------------------------------------------------------
Meta.FirstPass(Meta.MSESpecVisitor)>>basicRunOn:
Receiver:
a Meta.FirstPass
Instance Variables:
elementStack = an CodeFoo.ArrayList[1]
propertyStack = an CodeFoo.ArrayList[1]
specStack = an CodeFoo.ArrayList[2]
context = a SCG.Moose.MooseImporter[396]
Arguments:
extentSpec = a Meta.ExtentSpec
Context PC = 4
----------------------------------------------------------------------
Meta.FirstPass(Meta.MSESpecVisitor)>>runOn:
Receiver:
a Meta.FirstPass
Instance Variables:
elementStack = an CodeFoo.ArrayList[1]
propertyStack = an CodeFoo.ArrayList[1]
specStack = an CodeFoo.ArrayList[2]
context = a SCG.Moose.MooseImporter[396]
Arguments:
extentSpec = a Meta.ExtentSpec
Context PC = 5
----------------------------------------------------------------------
Meta.FirstPass class>>on:visit:
Receiver:
a Meta.FirstPass class
Instance Variables:
superclass = Meta.MSESpecVisitor
methodDict = a MethodDictionary[3]
format = 16388
subclasses = an Array[1]
instanceVariables = an Array[1]
organization = ('accessing' #context #context:)
('visiting' #visitElementHead:with:)
name = #FirstPass
classPool = a NameSpaceOfClass[0]
environment = a NameSpace[105]
Arguments:
anImporter = a SCG.Moose.MooseImporter[396]
anArray = a Meta.ExtentSpec
Context PC = 10
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>importMSE:
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Arguments:
aSpecification = a Meta.ExtentSpec
Temporaries:
length = 12131
Context PC = 16
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>importStream:
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Arguments:
aStream = a TaskStream
Context PC = 8
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>taskRun
Receiver:
a SCG.Moose.MooseImporter
Instance Variables:
elements = an IdentitySet[396]
numberMap = a CodeFoo.LargeIndexDictionary[396]
nameMap = a Dictionary[0]
metaRepository = a Meta.Repository[830]
stream = an ExternalReadStream on '/Users/ducasse/Workspace/
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
settingResolveDanglingIds = true
typesToImport = a Set[0]
Context PC = 10
----------------------------------------------------------------------
TaskHolder>>basicRun
Receiver:
a TaskHolder
Instance Variables:
runnable = a SCG.Moose.MooseImporter[396]
Context PC = 3
----------------------------------------------------------------------
optimized [] in [] in Task>>runWithProgress
Receiver:
an UndefinedObject
Temporaries:
.self = a TaskHolder
result = nil
Context PC = 6
----------------------------------------------------------------------
optimized [] in [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in [] in Task>>runWithProgress
increment = 8.24334e-5
res = nil
newValue = 0.032726
Context PC = 5
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
outerContext = nil
copiedValues = an Array[2]
Arguments:
aBlock = BlockClosure [] in Cursor>>showWhile:
Temporaries:
result = nil
Context PC = 4
----------------------------------------------------------------------
Cursor>>showWhile:
Receiver:
a Cursor
Instance Variables:
errorCode = 0
handle = a ByteArray[8]
image = Depth1Image(extent: 16@16 depth: 1)
mask = Depth1Image(extent: 16@16 depth: 1)
hotSpot = 0@0
name = 'wait'
Arguments:
aBlock = BlockClosure [] in [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Temporaries:
oldcursor = Cursor normal
Context PC = 23
----------------------------------------------------------------------
optimized [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in [] in Task>>runWithProgress
increment = 8.24334e-5
res = nil
newValue = 0.032726
Context PC = 13
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
outerContext = nil
copiedValues = an Array[2]
Arguments:
anExceptionSelector = IncrementNotification
handlerBlock = BlockClosure [] in [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in [] in Task>>runWithProgress
increment = 8.24334e-5
res = nil
newValue = 0.032726
.noticeModel = a Notice
.progress = a ValueHolder on: 0.032726
.title = 'Please wait : <1s>%% done'
Context PC = 18
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in [] in [] in Notice
class>>showNotice:complete:while:title:
outerContext = nil
copiedValues = an Array[5]
Arguments:
anExceptionSelector = MessageNotification
handlerBlock = BlockClosure [] in [] in [] in Notice
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in [] in Notice class>>showNotice:complete:while:title:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in [] in Task>>runWithProgress
increment = 8.24334e-5
res = nil
newValue = 0.032726
.noticeModel = a Notice
.progress = a ValueHolder on: 0.032726
.title = 'Please wait : <1s>%% done'
Context PC = 18
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in [] in Notice
class>>showNotice:complete:while:title:
outerContext = nil
copiedValues = an Array[5]
Arguments:
anExceptionSelector = ResetIncrementNotification
handlerBlock = BlockClosure [] in [] in Notice
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in Notice class>>showNotice:complete:while:title:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in [] in Task>>runWithProgress
increment = 8.24334e-5
res = nil
newValue = 0.032726
.noticeModel = a Notice
.progress = a ValueHolder on: 0.032726
.title = 'Please wait : <1s>%% done'
Context PC = 21
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in Notice
class>>showNotice:complete:while:title:
outerContext = nil
copiedValues = an Array[5]
Arguments:
aBlock = BlockClosure [] in Notice
class>>showNotice:complete:while:title:
Temporaries:
result = nil
Context PC = 4
----------------------------------------------------------------------
Notice class>>showNotice:complete:while:title:
Receiver:
a Notice class
Instance Variables:
superclass = ApplicationModel
methodDict = a MethodDictionary[9]
format = 16390
subclasses = nil
instanceVariables = an Array[2]
organization = ('interface opening' #postOpenWith:)
('aspects' #message: #notice #show: #textView)
('updating' #changedMessages)
('private' #invokePostOpen #on:)
('interface closing' #requestForWindowClose)
name = #Notice
classPool = a NameSpaceOfClass[0]
environment = a NameSpace[577]
savedWindowInformation = an IdentityDictionary[0]
Arguments:
aString = 'Importing model from MSE format...'
anInteger = 0
aBlock = BlockClosure [] in [] in Task>>runWithProgress
titleString = 'Please wait'
Temporaries:
noticeModel = a Notice
int = 1
increment = 8.24334e-5
progress = a ValueHolder on: 0.032726
res = nil
title = 'Please wait : <1s>%% done'
newValue = 0.032726
Context PC = 125
----------------------------------------------------------------------
optimized [] in Task>>runWithProgress
Receiver:
an UndefinedObject
Temporaries:
.self = a TaskHolder
result = nil
Context PC = 24
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in Task>>runWithProgress
outerContext = nil
copiedValues = an Array[2]
Arguments:
aBlock = BlockClosure [] in Task>>runWithProgress
Temporaries:
result = nil
Context PC = 4
----------------------------------------------------------------------
TaskHolder(Task)>>runWithProgress
Receiver:
a TaskHolder
Instance Variables:
runnable = a SCG.Moose.MooseImporter[396]
Temporaries:
result = nil
Context PC = 15
----------------------------------------------------------------------
optimized [] in SCG.Moose.MooseModel>>importMSEFromFile
Receiver:
an UndefinedObject
Temporaries:
moosemodel = nil
loader = a SCG.Moose.MooseImporter[396]
.fileName = '/Users/ducasse/Workspace/Firs...earch/Coding/
MorphicGame.mse'
Context PC = 20
----------------------------------------------------------------------
Time class>>microsecondsToRun:
Receiver:
a Time class
Instance Variables:
superclass = Magnitude
methodDict = a MethodDictionary[24]
format = 16387
subclasses = nil
instanceVariables = an Array[3]
organization = ('comparing' #< #= #hash)
('accessing' #hours #milliseconds #minutes #seconds)
('arithmetic' #addTime: #subtractTime:)
('printing' #glorpPadToTwoDigits: #glorpPrintSQLOn: #longPrintString
#printOn: #shortPrintString #storeOn:)
('converting' #asSeconds #asTimestamp)
('private' #hours: #hours:minutes:seconds: #literalArrayEncoding
#printOn:policy:format:)
('private-spin-button' #decrementBy:boundedBy:highValue:wrapAround:
#incrementBy:boundedBy:lowValue:wrapAround:)
('private-oracle' #oracleConversion)
name = #Time
classPool = a NameSpaceOfClass[0]
environment = a NameSpace[224]
Arguments:
timedBlock = BlockClosure [] in SCG.Moose.MooseModel>>importMSEFromFile
Temporaries:
initialMicroseconds = 3381740218566122
Context PC = 7
----------------------------------------------------------------------
Time class>>millisecondsToRun:
Receiver:
a Time class
Instance Variables:
superclass = Magnitude
methodDict = a MethodDictionary[24]
format = 16387
subclasses = nil
instanceVariables = an Array[3]
organization = ('comparing' #< #= #hash)
('accessing' #hours #milliseconds #minutes #seconds)
('arithmetic' #addTime: #subtractTime:)
('printing' #glorpPadToTwoDigits: #glorpPrintSQLOn: #longPrintString
#printOn: #shortPrintString #storeOn:)
('converting' #asSeconds #asTimestamp)
('private' #hours: #hours:minutes:seconds: #literalArrayEncoding
#printOn:policy:format:)
('private-spin-button' #decrementBy:boundedBy:highValue:wrapAround:
#incrementBy:boundedBy:lowValue:wrapAround:)
('private-oracle' #oracleConversion)
name = #Time
classPool = a NameSpaceOfClass[0]
environment = a NameSpace[224]
Arguments:
timedBlock = BlockClosure [] in SCG.Moose.MooseModel>>importMSEFromFile
Context PC = 5
----------------------------------------------------------------------
BlockClosure>>millisecondsToRun
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in SCG.Moose.MooseModel>>importMSEFromFile
outerContext = nil
copiedValues = an Array[2]
Context PC = 4
----------------------------------------------------------------------
SCG.Moose.MooseModel>>importMSEFromFile
Receiver:
a SCG.Moose.MooseModel
Instance Variables:
mooseID = nil
state = a SCG.Moose.DefaultEntityState
storage = a SCG.Moose.SetupStorage[10]
sourceLanguage = nil
name = 'Root'
Temporaries:
fileName = '/Users/ducasse/Workspace/Firs...earch/Coding/
MorphicGame.mse'
moosemodel = nil
loader = a SCG.Moose.MooseImporter[396]
millis = nil
Context PC = 35
----------------------------------------------------------------------
SCG.Moose.MooseBrowser>>importMSEFromFile
Receiver:
a SCG.Moose.MooseBrowser
Instance Variables:
dependents = nil
builder = an UIBuilder
uiSession = a ControlManager
eventHandlers = nil
browser = nil
viewSubcanvas = a SCG.Moose.MooseIconUI
favoriteList = nil
modelList = a SelectionInList
entityList = a SelectionInList
selectedEntity = a SCG.Moose.MooseModel #'LAN sample model'(685)
Context PC = 7
----------------------------------------------------------------------
optimized [] in ApplicationModel>>actionFor:
Receiver:
an UndefinedObject
Temporaries:
.self = a SCG.Moose.MooseBrowser
.aKey = #importMSEFromFile
Context PC = 7
----------------------------------------------------------------------
optimized [] in ActionButtonSpec>>typeConvert:
Receiver:
an UndefinedObject
Arguments:
b = a ValueHolder on: nil
v = true
Temporaries:
.aValue = BlockClosure [] in ApplicationModel>>actionFor:
Context PC = 5
----------------------------------------------------------------------
PluggableAdaptor>>setValue:
Receiver:
a PluggableAdaptor
Instance Variables:
dependents = nil
model = a ValueHolder on: nil
getBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
putBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
updateBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
Arguments:
newValue = true
Context PC = 6
----------------------------------------------------------------------
PluggableAdaptor(ValueModel)>>value:
Receiver:
a PluggableAdaptor
Instance Variables:
dependents = nil
model = a ValueHolder on: nil
getBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
putBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
updateBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
Arguments:
newValue = true
Context PC = 5
----------------------------------------------------------------------
TriggerButtonController>>pressAction
Receiver:
a TriggerButtonController
Instance Variables:
model = a PluggableAdaptor
view = a Win95ActionButtonView
sensor = a TranslatingSensor
keyboardProcessor = a KeyboardProcessor
keyboardHook = nil
dispatcher = nil
Context PC = 17
----------------------------------------------------------------------
TriggerButtonTracker(BasicButtonTracker)>>finishSelectionFor:
Receiver:
a TriggerButtonTracker
Instance Variables:
controller = a TriggerButtonController
inside = true
Arguments:
aPoint = 16@15
Context PC = 8
----------------------------------------------------------------------
TriggerButtonTracker>>finishSelectionFor:
Receiver:
a TriggerButtonTracker
Instance Variables:
controller = a TriggerButtonController
inside = true
Arguments:
aPoint = 16@15
Context PC = 11
----------------------------------------------------------------------
TriggerButtonTracker(SelectionTracker)>>redButtonReleasedEvent:
Receiver:
a TriggerButtonTracker
Instance Variables:
controller = a TriggerButtonController
inside = true
Arguments:
aMouseButtonEvent = a RedButtonReleasedEvent
Context PC = 13
----------------------------------------------------------------------
RedButtonReleasedEvent>>dispatchTo:
Receiver:
a RedButtonReleasedEvent
Instance Variables:
time = 1696571547
initiator = an EventDispatcher
window = an ApplicationWindow nil
state = 0
x = 42
y = 15
gx = 262
gy = 226
buttonNumber = 1
Arguments:
anObject = a TriggerButtonTracker
Context PC = 4
----------------------------------------------------------------------
TriggerButtonTracker(SelectionTracker)>>handleEvent:
Receiver:
a TriggerButtonTracker
Instance Variables:
controller = a TriggerButtonController
inside = true
Arguments:
anEvent = a RedButtonReleasedEvent
Context PC = 4
----------------------------------------------------------------------
EventDispatcher>>dispatch:to:
Receiver:
an EventDispatcher
Instance Variables:
windowController = an ApplicationStandardSystemController
currentMouseConsumer = nil
grabbingMouse = false
keyboardProcessor = a KeyboardProcessor
lastControlObject = a TriggerButtonController
trapList = nil
state = nil
repairDamageWhenDebugging = true
flushQueueAfterError = true
distributeEventsWhenDebugging = true
dragDropInProgress = false
dragDropTracker = nil
dispatchUnknownEvents = false
Arguments:
event = a RedButtonReleasedEvent
object = a TriggerButtonTracker
Temporaries:
tmp = nil
Context PC = 10
----------------------------------------------------------------------
EventDispatcher>>dispatchEvent:
Receiver:
an EventDispatcher
Instance Variables:
windowController = an ApplicationStandardSystemController
currentMouseConsumer = nil
grabbingMouse = false
keyboardProcessor = a KeyboardProcessor
lastControlObject = a TriggerButtonController
trapList = nil
state = nil
repairDamageWhenDebugging = true
flushQueueAfterError = true
distributeEventsWhenDebugging = true
dragDropInProgress = false
dragDropTracker = nil
dispatchUnknownEvents = false
Arguments:
event = a RedButtonReleasedEvent
Temporaries:
objectWantingControl = nil
targetKeyboardProcessor = nil
Context PC = 60
----------------------------------------------------------------------
RedButtonReleasedEvent(Event)>>dispatch
Receiver:
a RedButtonReleasedEvent
Instance Variables:
time = 1696571547
initiator = an EventDispatcher
window = an ApplicationWindow nil
state = 0
x = 42
y = 15
gx = 262
gy = 226
buttonNumber = 1
Context PC = 16
----------------------------------------------------------------------
RedButtonReleasedEvent(Event)>>dispatchForWindowManager:
Receiver:
a RedButtonReleasedEvent
Instance Variables:
time = 1696571547
initiator = an EventDispatcher
window = an ApplicationWindow nil
state = 0
x = 42
y = 15
gx = 262
gy = 226
buttonNumber = 1
Arguments:
aWinMgr = a WindowManager
Context PC = 4
----------------------------------------------------------------------
optimized [] in WindowManager>>safelyDispatchForWindowManager:
Receiver:
an UndefinedObject
Temporaries:
.event = a RedButtonReleasedEvent
.self = a WindowManager
Context PC = 6
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in
WindowManager>>safelyDispatchForWindowManager:
outerContext = nil
copiedValues = an Array[2]
Arguments:
anExceptionSelector = BadControllerError
handlerBlock = BlockClosure [] in
WindowManager>>safelyDispatchForWindowManager:
Context PC = 18
----------------------------------------------------------------------
WindowManager>>safelyDispatchForWindowManager:
Receiver:
a WindowManager
Instance Variables:
windows = an OrderedCollection[1]
activeController = nil
interruptLock = false
outstandingMetaOrDamage = false
openInProgress = false
eventQueue = an EventQueue
baseProcess = a Process in Semaphore>>wait
dontFilterEvents = false
Arguments:
event = a RedButtonReleasedEvent
Context PC = 13
----------------------------------------------------------------------
WindowManager>>processNextEvent
Receiver:
a WindowManager
Instance Variables:
windows = an OrderedCollection[1]
activeController = nil
interruptLock = false
outstandingMetaOrDamage = false
openInProgress = false
eventQueue = an EventQueue
baseProcess = a Process in Semaphore>>wait
dontFilterEvents = false
Temporaries:
event = a RedButtonReleasedEvent
Context PC = 9
----------------------------------------------------------------------
optimized [] in [] in WindowManager>>newProcess
Receiver:
an UndefinedObject
Temporaries:
.self = a WindowManager
Context PC = 13
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in [] in WindowManager>>newProcess
outerContext = nil
copiedValues = a WindowManager
Arguments:
anExceptionSelector = TerminateException
handlerBlock = BlockClosure [] in [] in WindowManager>>newProcess
Context PC = 18
----------------------------------------------------------------------
optimized [] in WindowManager>>newProcess
Receiver:
an UndefinedObject
Temporaries:
.self = a WindowManager
Context PC = 15
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
a BlockClosure
Instance Variables:
method = CompiledBlock [] in WindowManager>>newProcess
outerContext = nil
copiedValues = a WindowManager
Arguments:
anExceptionSelector = TerminateException
handlerBlock = BlockClosure [] in [] in Process
class>>forBlock:priority:
Context PC = 18
----------------------------------------------------------------------
optimized [] in Process class>>forBlock:priority:
Receiver:
an UndefinedObject
Temporaries:
.aBlock = BlockClosure [] in WindowManager>>newProcess
Context PC = 9
Hi,
At the moment googling "moose" puts moose.unibe.ch on the third page.
I would be nice if we could get a better rank. So, I would kindly ask
all those that use Moose to provide a link from your page to the moose
website.
For other searches we already ok:
"moose analysis" -> rank 1
"moose visualization" -> rank 2
If you have suggestions for how to improve the ranking of
moose.unibe.ch please share it with us.
Cheers,
Doru
--
www.tudorgirba.comwww.tudorgirba.com/blog
"What we can governs what we wish."
> D:\iplasma\iPlasma\tools\mcc>mcc
> This is an experimental tool property of Loose Reserch Group.
> The usage of this tool outside of LRG is prohibited.
>
> Mc'C. Model capture tool for C++
> Copyright (c) 2004 Loose Research Group
> Version 1.5
Hmm, I see a problem here. Anyone know how to join Loose Reserch Group?
Stephan
Hi Toon,
Adrian told me he would like to play a more passive role because of
his PhD. I will start next week, this week end I am on travel. Have
you done already something where I could help ?
I am on Skype as hnbecktel
Greetings
Hans
p.s. Wie sieht es bei Dir mit Deutsch aus ?
On Feb 15, 2008, at 4:07 PM, Toon Verwaest wrote:
> Me and Adrian are planning a paired "sprint" to implement Fame in
> Squeak. (This includes FM3, codegeneration, MSE importer/exporter etc)
Nice. What size of codebase should Moose be able to handle? I have
over 5000 file dependencies (per version).
Stephan
I've been doing some code analysis of one of our legacy c++ projects
in squeak (a commercial one), and would be interested in experimenting
with Moose. VW non-commercial doesn't seem to be an option then.
What would be needed to get Moose running on squeak, and does the
license allow that?
Stephan Eggermont
Hi,
This week some of us participated in the Seminar on Advanced Tools &
Techniques for Software Evolution (SATTOSE). The seminar was quite
interesting and rather dense. Several people have presented tools and
it is encouraging to see the growing interest in building tools to
support research.
Here are some things related to Moose that I remember from the seminar:
- There will be a working group around building tools in research. The
idea is to try to build a European consortium for promoting tool-based
collaboration between research groups and for raising the awareness of
software evolution in industry.
- FAMIX and Fame was briefly presented by Adrian.
- There will be interaction between the SOUL community and the Moose
community. As a first step, we worked on having loaders in each
other's Store. So, if you want to load SOUL from the SCG Store, you
can try to load IntensiVESuiteLoader (I still have errors with the
automatic connection to their store).
- Adrian implemented a parser for Java (I have no idea when :)).
- Several people played with Mondrian and I eventually managed to
implement a couple of more constructors for building edges
(edges:from:toAll:, edges:fromAll:to:, edges:fromAll:toAll:).
- Stef and me implemented Distribution Map visualization using Mondrian.
- Marco worked on integrating the Evolution Radar with Chronia and
with the Moose UI.
- I presented Moose and argued for collaborative research
- Adrian demoed Chronia
- Marco demoed Churrasco
- I demoed Mondrian, and a bit of CodeCity :)
Cheers,
Doru
--
www.tudorgirba.comwww.tudorgirba.com/blog
"Every thing should have the right to be different."
http://smallwiki.unibe.ch/adriankuhn/javacompiler/exportfamix/
Am easy to use javac plugin. Simple extend your Ant file with 4 lines
to export your whole project to Moose!
Jamix currenlty exports
-Package
-Namespace
-Class
-Inheritance
-Method
-Invocation
should load with the latest version of Moose. Please report errors
and feedback!
cheers,
AA
Hi
I wanted to thank doru for the 3 hours coding session we did together
- he typed ;)
We did several iterations in XP style was fun.
We have now a good start of a generic distribution map in mondrian.
The clustering of parts is not optimal but this is excellent to see
that.
Next step:
- we should be able to specify color with a default spec (10 min)
- we should be able to specify flybyhelp (that I do not know).
Stef
