Squeak-dev October 1998

squeak-dev@lists.squeakfoundation.org

107 participants
209 discussions

Re: Software Visualization....
by Hugh Fisher 22 Oct '98

22 Oct '98

>Hi, > >Here is a zipped copy of the paper. Randy Giffen wrote the program as >his MSc project and then extended it. It's a great program. Could people please mail URLs rather than the actual archives? As someone a) with a Macintosh and b) reading mail over a dial up line I'm not too enthused about massive ZIPs Hugh

2 1

Re: Software Visualization....
by Mark Wai 22 Oct '98

22 Oct '98

Warning: Long message.... Dwight - Maybe you have already seen it or know about it. But never mind I repeat here. Since version 4.0, VisualAge has a new add on tool (free of charge) called 'Visualization Tools' that I believe people are rarely use or even know about it. Anyway, VT provides three basic tools for object visualization within VAST environment. ------------------------------------------------------------ As quoted from the manual (in case the reader do not have access to VAST manual): 1) Object Visualizer The Object Visualizer is a tool that enables you to analyze object activity and interaction. With this tool, you can visualize objects in your application, which enables you to do the following: o See how many instances of a class exist at any time during application execution o Watch a visual representation of message traffic between objects o Identify which objects are busiest, and which are most idle o Determine which clusters of objects are closely related to one another, based on the amount of message traffic between them. These tools can help you understand your application in order to correct problems or improve performance. By analyzing the message traffic in your application, you can identify potential trouble spots or bottlenecks. The Object Visualizer provides two views that you can use to visually analyze your application performance: o The main Object Visualizer window is a visual representation of object instances. For each visualized class, the Object Visualizer displays an icon representing each instance of that class. This view also provides several indicators you can use to track the level of message traffic between the instances. o The Cluster View is a dynamic visual representation of the relationships between objects. The Cluster View measures the level of interaction between objects, visually arranging the objects to show which objects are closely related (based upon the amount of message traffic between them). You can use the Cluster View to analyze either classes or instances. 2) Widget Scope A tool that reveals objects "behind the scenes" of an interactive Smalltalk application. A user simply clicks anywhere on the screen, and the Widget Scope lists the widget objects that produce that part of the display, as well as other objects that implement the function provided by the application. Widget scoping in onjunction with visualizing and snooping (pages 3 and 19), constitutes an extremely powerful, yet practical and convenient, means of "getting to the bottom" of behavior of unfamiliar applications and frameworks. Without these tools, a programmer trying to gain an understanding of how an application works (to fix it, to extend it, or to reuse parts of it) is faced with roundabout schemes involving searching for classes by pattern matching on their names, guessing at how to launch an application, and trying to get a debugger to open at opportune times. 3) and The Snoope The Snooper is a powerful tool that provides a hierarchical textual view of a hierarchy of objects. Individual objects discovered using the Snooper may then be added directly into the views provided by the Object Visualizer (page 3). The Snooper also includes a set of buttons that provide a simple and direct means for opening other tools of the IBM Smalltalk environment, such as visualizers, browsers, and inspectors, on objects of interest. In addition, the Snooper provides a code evaluation facility, a workspace, object searching, and limited views of its own. The Snooper can be used in combination with the other tools of the environment to provide a powerful facility for investigating object structures and quickly gaining an understanding of program behavior. -------------------------------------------------------------- > My primary >interest is in capturing and presenting dynamic code (and data) behavior >in a clean, efficient manner. I don't know whether VA's Visualization tool is what you consider clean and efficient but certainly worth to take a look, based on all the features that it provides. >As a zero-th approximation of what I am >initially shooting for, take a look at "Bridging the Gulf Between Code >and Behavior in Programming" by Henry Lieberman and Christopher Fry, >which describes the ZStep 94 debugger (for Macintosh Common Lisp) - see: > >http://lieber.www.media.mit.edu/people/lieber/Lieberary/ZStep/ZStep.html I took a quick peek at ZStep. To be honest, I don't see anything that is different or new (in terms of ideas, concepts and implementation) from standard ST debugger. I probably missed something and maybe I should read more carefully. Disclaimer: I don't work for IBM or sale VAST -- Mark Wai Wator Innovision mailto: mwai(a)ibm.net or:[ mwai(a)frontiersa.com ] __

3 2

Continuations (was: The State of Exceptions)
by Vassili Bykov 22 Oct '98

22 Oct '98

I am attaching the "real" (AFAIK) image level implementation of continuations, just like in Scheme, but a comment is due first. Ian Piumarta writes: > This was for 1.21, but it probably still works in 2.2... > > ftp://alix.inria.fr/pub/squeak/goodies/continuations.5Augu602pm.cs > > Ian This implementation is incorrect in the same sense the attempt at continuations in VW I described on c.l.s. was (and possibly the approach Allen Wirfs-Brock described). They all share the same idea of copying and reinstalling the original sender chain each time a continuation is invoked. Each new invocation rolls back over a fresh copy of the original stack, so the variables of the contexts of the sender chain are not shared between the invocations. With the "real" continuations they should be. Dybvig's example you use does not illustrate this point. Here is one that does. After evaluating: | sum | sum _ 0. sum _ [:k | Undeclared at: #K put: k. 0] callCC + sum. Transcript show: sum printString; cr we are supposed to be able to evaluate: (Undeclared at: #K) value: <...aNumber...> multiple times and see the sum of the numbers so far passed to the continuation printed on the Transcript. An implementation that always uses a fresh copy of the original sender chain actually prints only the current continuation argument (since it always uses the original value of sum = 0). The key to the correct implementation is to reuse the original sender chain. A continuation holds onto the original chain as well as onto its copy. Before each execution, it refers to the copy to undo the damage done to the original chain's contexts by the previous execution, then uses the original chain. The damage includes the sender, the pc, the stackp, and the indexed variables that are not the context's temps (the stack). --Vassili ---------------- Continuation.st ------------------- 'From Squeak 2.2 of Sept 23, 1998 on 21 October 1998 at 10:25:18 pm'! Object subclass: #Continuation instanceVariableNames: 'topContext copiedStack ' classVariableNames: '' poolDictionaries: '' category: 'Kernel-Methods'! !Continuation methodsFor: 'initialize-release' stamp: 'vb 10/20/1998 23:10'! initialize: returnContext self captureSenderChain: returnContext! ! !Continuation methodsFor: 'invocation' stamp: 'vb 10/20/1998 23:00'! value: anObject self restoreSenderChain. thisContext swapSender: topContext. ^anObject! ! !Continuation methodsFor: 'private' stamp: 'vb 10/21/1998 20:22'! captureSenderChain: aContext | chainCopy currentSender copiedContext | topContext _ aContext. copiedStack _ OrderedCollection new: 16. chainCopy _ aContext copySenderChain. currentSender _ topContext sender. copiedContext _ chainCopy. [copiedContext == nil] whileFalse: [copiedStack add: copiedContext. copiedContext _ copiedContext swapSender: currentSender. currentSender _ currentSender ifNotNil: [currentSender sender]]! ! !Continuation methodsFor: 'private' stamp: 'vb 10/21/1998 20:22'! restoreSenderChain | currentContext | currentContext _ topContext. copiedStack do: [:contextCopy | currentContext method: contextCopy sender pc: contextCopy pc; copyStackFrom: contextCopy. currentContext _ currentContext sender]! ! "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "! Continuation class instanceVariableNames: ''! !Continuation class methodsFor: 'instance creation' stamp: 'vb 10/21/1998 20:23'! returningTo: aContext ^self new initialize: aContext! ! !Continuation class methodsFor: 'testing' stamp: 'vb 10/20/1998 23:09'! testAccumulator "Continuation testAccumulator" "(Undeclared at: #K) value: 2" "(Undeclared at: #K) value: 5" "(Undeclared at: #K) value: 13" "Undeclared removeKey: #K" | sum | sum _ 0. sum _ [:k | Undeclared at: #K put: k. 0] valueWithCurrentContinuation + sum. Transcript show: sum printString; cr! ! !BlockContext methodsFor: 'continuations' stamp: 'vb 10/20/1998 23:31'! valueWithCC ^self value: (Continuation returningTo: thisContext sender)! ! !BlockContext methodsFor: 'continuations' stamp: 'vb 10/20/1998 23:07'! valueWithCurrentContinuation ^self value: (Continuation returningTo: thisContext sender)! ! !ContextPart methodsFor: 'continuation support' stamp: 'vb 10/20/1998 20:41'! copySenderChain ^sender == nil ifTrue: [self copy] ifFalse: [self copy swapSender: sender copySenderChain; yourself]! ! !ContextPart methodsFor: 'continuation support' stamp: 'vb 10/21/1998 20:09'! copyStackFrom: myCopy self method numTemps + 1 to: self size do: [:index | self at: index put: (myCopy at: index)]. stackp _ myCopy stackPtr ! ! ---------------- eof ------------------

1 0

Re: Software Visualization....
by Mark Wai 22 Oct '98

22 Oct '98

At 09:46 AM 10/22/98 +0800, Matthew McDonald wrote: >I'm new to smalltalk and therefore don't know much about standard >smalltalk debuggers, but doesn't ZStep have reversible execution (or >some sort of simulation of it)? > >Can standard smalltalk debuggers (or the squeak debugger) do this? I don't think Squeak debugger has this feature or something similar (I could be wrong). VAST debugger provides a similar feature in that you can restart a selected stack frame in your execution stack. All the temporaries within the selected method context are completely reset. In other words, during debugging, you can select an arbitrary point to restart (e.g. go back to a frame that has been executed) and restart it with a 'clean' environment. This is an extremely useful feature in my (and I guess to many) everyday work. -- Mark Wai Wator Innovision mailto: mwai(a)ibm.net or:[ mwai(a)frontiersa.com ] __

1 0

Re: Software Visualization....
by Dwight Hughes 21 Oct '98

21 Oct '98

Looks great! (By the way, to anyone else who might want to look at the paper: it is a MS Word document.) Thanks a lot! -- Dwight Ivan Tomek wrote: > > Hi, > > Here is a zipped copy of the paper. Randy Giffen wrote the program as > his MSc project and then extended it. It's a great program. > > Ivan > > Ivan Tomek, > Jodrey School of Computer Science > Acadia University > Nova Scotia, Canada > fax: (902) 585-1067 > voice: (902) 585-1467

2 1

Re: The State of Exceptions
by Ian Piumarta 21 Oct '98

21 Oct '98

This was for 1.21, but it probably still works in 2.2... ftp://alix.inria.fr/pub/squeak/goodies/continuations.5Augu602pm.cs Ian

1 0

Re: http://squeak.cs.uiuc.edu/ not found?!?!?!
by Les Tyrrell 20 Oct '98

20 Oct '98

Try this instead... http://st-www.cs.uiuc.edu/squeak/

1 0

Re: The State of Exceptions
by Michael S. Klein 20 Oct '98

20 Oct '98

> A block with a return in it is what I was thinking of > as a continuation. A block is a first-class object. A block with a return it only captures the most common usage of continuations... that of an exit function which is called at most once, and has no reference outside of the environment of the initial call-cc. In Smalltalk, you can do this for blocks by: Block(Context/Closure) >> valueWithExit ^self value: [:answer | ^answer] So, result := [:exit| exit value: 3+4] valueWithExit. assigns 7 to result, whereas result := [ ^3 + 4 ] value. does a non-local return which never assigns to result. > >3. independent of implementation. Some dialects > >provide direct access to the sender and home pointers > >upon which ^ depends; others don't. The meaning > >of continuations is fixed across Scheme implementations. I think the semantics of call-cc underwent subtle changes between R4RS & R5RS, due to dynamic-wind. But you'd have to talk to a Scheme expert to know for sure.

1 0

Squeak for Win32 and long file names
by Jesse Welton 20 Oct '98

20 Oct '98

The Win32 download information says the Win32 version of Squeak will not work with Windows 3.1 because of the lack of long filename support. I know some of the dependence on long file names is in the image, where I can cheerfully modify it; but is it all confined to the image, or is some of that dependence compiled into the VM? Also, is the lack of long file support the only things that would cause a problem running the Win32 VM under Windows 3.11 (with 32 bit support)? I'd rather not try to hack the VM at this point in my career. I've played around with the DOS port, but I'd like to be able to use some Windows capabilities like networking. For historical reasons, my work computers still run (and will likely continue to run) Windows 3.11 for Workgroups. Any suggestions would be appreciated. -Jesse Welton I jammed my mouse in the drawer with an ever-so-crisp squeaking sound.

1 0

Re: [squeak] Pretty Formatter.
by John (Zhijiang) Han 20 Oct '98

20 Oct '98

Thanks Ivan, That does help. So what should I do if my own startup code gets erred and my temporary var's get lost? They are still in the change file, right? -- John (Zhijiang)

1 0

← Newer
1
...
6
7
8
9
10
11
12
...
21
Older →

Jump to page: