Re: Spoon 3 alpha 4

Craig,

On 16 August 2012 03:30, Craig Latta <[hidden email]> wrote:
> Please fire it up and let me know that it starts.

the comment in the WormholeServer,

"Connect to the minimal history and subject memories, and connect them
to each other. Before evaluating this, start the 'history' and
'subject' memories.",

suggests that I need to do something about those memories (start them
up) before I evaluate the code following it.

I'm a Spoon newbie. Likely I'm missing something obvious. What do I
need to do? (Just evaluating the code hangs the system.)

Best,

Michael

On 12-08-16 7:25 AM, Michael Haupt wrote: On my Mac I do something like this:

Right click the package on your desktop. Choose "Show Package Contents".
Then open the "Contents" folder. Then "Resources" in which you will find
the subject.image and history.image. Start them by dragging them each
over the Spoon icon in the dock, as you've already double clicked the
main image to start.

Then you can proceed through the commands of the "a WormholeServer"
inspector window to get an "Other Browser" which lets you see the
contents of the subject.image. Unfortunately, when I execute the first
few lines - #self down to #connect - to enage the ports, the image
freezes. I press Command+. to get a user interrupt and I get an error as
well. Or bell rings infinitely. I've attached the SqueakDebug.log
output. Then I start Activity Monitor and force quit all three running
images. I'm on Mac OSX 10.7.4.

HTH,
Chris

FailedReadingAttempt:
16 August 2012 7:54:47.685 am

VM: Mac OS - Smalltalk
Image: Squeak4.2 [latest update: #10966]

SecurityManager state:
Restricted: false
FileAccess: true
SocketAccess: true
Working Dir
/Users/chriscunnington/Desktop/Spoon-3-alpha-4.app/Contents/Resources
Trusted Dir /foobar/tooBar/forSqueak/bogus
Untrusted Dir
/Users/chriscunnington/Library/Preferences/Squeak/Internet/My Squeak

OutgoingClientTCPSocket(TCPSocket)>>next:from:into:startingAt:
     Receiver: an inactive OutgoingClientTCPSocket which was connected
to port 62981 at localhost (127.0....etc...
     Arguments and temporary variables:
         bytesToReadInteger:     4
         tcpSocketHandle:     6828880
         targetByteArray:     #[0 0 0 0]
         targetStartIndex:     1
     Receiver's instance variables:
         handle:     6828880
         readability:     a Semaphore()
         writability:     a Semaphore()
         address:     port 62981 at localhost (127.0.0.1)
         peerClosed:     true

OutgoingClientTCPSocket(Peer)>>next:into:startingAt:timeoutAfter:
     Receiver: an inactive OutgoingClientTCPSocket which was connected
to port 62981 at localhost (127.0....etc...
     Arguments and temporary variables:
         anInteger:     4
         aByteArray:     #[0 0 0 0]
         startIndex:     1
         numberOfMilliseconds:     nil
     Receiver's instance variables:
         handle:     6828880
         readability:     a Semaphore()
         writability:     a Semaphore()
         address:     port 62981 at localhost (127.0.0.1)
         peerClosed:     true

TCPStream(NetStream)>>next:into:startingAt:timeoutAfter:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket
which was connected to port 6298...etc...
     Arguments and temporary variables:
         numberOfElementsRequested:     4
         aSequenceableCollection:     #[0 0 0 0]
         startIndex:     1
         numberOfMilliseconds:     nil
         endIndex:     nil
         numberOfElementsConsumed:     #(0)
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(NetStream)>>next:timeoutAfter:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket
which was connected to port 6298...etc...
     Arguments and temporary variables:
         anInteger:     4
         numberOfMilliseconds:     nil
         elements:     nil
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(NetStream)>>next:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket
which was connected to port 6298...etc...
     Arguments and temporary variables:
         anInteger:     4
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(ExternalStream)>>nextWord
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket
which was connected to port 6298...etc...
     Arguments and temporary variables:
         bytes:     nil
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

Wormhole(MessagingSession)>>nextFrom:
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:
         aStream:     a binary TCPStream on an inactive
OutgoingClientTCPSocket which was co...etc...
         tag:     nil
     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream
connections at port 7...etc...
         processing:     a Process in Debugger
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998,
with no clients
         nextWormhole:     nil

Wormhole(MessagingSession)>>next
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:

     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream
connections at port 7...etc...
         processing:     a Process in Debugger
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998,
with no clients
         nextWormhole:     nil

Wormhole>>greet
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:

     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream
connections at port 7...etc...
         processing:     a Process in Debugger
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998,
with no clients
         nextWormhole:     nil

[] in Wormhole(IncomingClient)>>stream:
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:
<<error during printing>
     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream
connections at port 7...etc...
         processing:     a Process in Debugger
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998,
with no clients
         nextWormhole:     nil

[] in BlockClosure>>newProcess
     Receiver: [closure] in Wormhole(IncomingClient)>>stream:
     Arguments and temporary variables:

     Receiver's instance variables:
         outerContext:     Wormhole(IncomingClient)>>stream:
         startpc:     42
         numArgs:     0


--- The full stack ---
OutgoingClientTCPSocket(TCPSocket)>>next:from:into:startingAt:
OutgoingClientTCPSocket(Peer)>>next:into:startingAt:timeoutAfter:
TCPStream(NetStream)>>next:into:startingAt:timeoutAfter:
TCPStream(NetStream)>>next:timeoutAfter:
TCPStream(NetStream)>>next:
TCPStream(ExternalStream)>>nextWord
Wormhole(MessagingSession)>>nextFrom:
Wormhole(MessagingSession)>>next
Wormhole>>greet
[] in Wormhole(IncomingClient)>>stream:
[] in BlockClosure>>newProcess

> Right click the package on your desktop. Choose "Show Package Contents".
> Then open the "Contents" folder. Then "Resources" in which you will find the
> subject.image and history.image. Start them by dragging them each over the
> Spoon icon in the dock, as you've already double clicked the main image to
> start.

Not sure if this is related, but It sounds like you didn't extract the
package first.  Are you trying to run it from within the zip?