first Naiad module page created

Posted in Naiad, Spoon on 10 July 2011 by Craig Latta

Naiad is Spoon’s module system. For every Naiad module, there can be a webpage describing it and providing something for Google to crawl. This is the basis of a discovery system for Naiad modules. It includes…

  • a well-known master Naiad module pages ID (so that one can search the web for all Naiad module pages)
  • the module’s name
  • the module’s author’s ID (so that one can search the web for the pages of the modules by that author)
  • the module’s ID
  • a description of the module’s content
  • the module’s current version
  • the module’s latest timestamp
  • the module’s tags
  • the IDs of the module’s prerequisite modules (for which one may search the web)
  • one or more installation links. When clicked, an installation link hits a webserver running in a local Spoon system. The link contains an encoded hostname and port for a remote Spoon system which actually serves the module.

I created the first Naiad module page, for the “fundamental constants” module. I also made a custom search engine for finding Naiad module pages.

1 Comment »

initial Context modularization finished

Posted in Context, Naiad, Spoon with tags on 5 July 2011 by Craig Latta

I’ve finished the initial Context modularization. It’s 32 modules, 179 classes, and 1953 methods. The listing on the linked page above is now machine-generated from the modules.

1 Comment »

next steps

Posted in Naiad, Spoon on 26 June 2011 by Craig Latta

Well, the initial Spoon modularization is coming along nicely. It has taken a form which is both human and machine readable, so I’m going to write code which reads it and creates the modules. Then I’ll check for methods which aren’t mentioned, probably removing some more stuff that hasn’t been used recently. Then I’ll test serving a module to another system, and adapt the remote browsing support to Squeak 4.2. The next Spoon release will consist of minimal history and subject memories and VMs (packaged as host-platform applications), remote browsing changes, VM changes, and VM build environments.

It looks like the first non-bootstrap module will be for printing (printOn: etc.).

Leave a comment »

initial Context modularization

Posted in Context, Naiad, Spoon with tags on 20 June 2011 by Craig Latta

At last! I’ve wanted to see this list ever since I started Smalltalking. Here are the initial modules in Context, including the classes and methods they contain, numbered for reference.

5 Comments »

How would you sort these classes by dependency?

Posted in Naiad, Spoon on 20 June 2011 by Craig Latta

Here are the last 168 classes remaining in Spoon. I’m sorting them into a graph of dependent modules for the next release. How would you do it? Suggestions welcome.

ArrayedCollection
Collection
SequenceableCollection
Array
ByteArray
Interval
LinkedList
OrderedCollection
SharedQueue
SortedCollection

Association
Link
LookupKey
ReadOnlyVariableBinding
WeakKeyAssociation

Character
String
Symbol

Dictionary
IdentityDictionary
IdentitySet
Set
WeakArray
WeakIdentityKeyDictionary
WeakKeyDictionary
WeakRegistry
WeakSet

Behavior
Class
ClassBuilder
ClassDescription
Metaclass

Magnitude
Time

BlockContext
CompiledMethod
ContextPart
InstructionStream
Message
MethodContext
MethodDictionary

Float
Integer
LargeNegativeInteger
LargePositiveInteger
Number
Random
SmallInteger

Boolean
False
Object
True
UndefinedObject

Delay
Process
ProcessorScheduler
Semaphore

HTTPServer
HTTPAction
ExceptionMarker
OtherMarker
RemoteMethod
ClassID
MethodID
Module
ModuleDescription
Version
AuthorEdition
BehavioralEdition
Checkpoint
ClassEdition
CommentEdition
CommentedEdition
Edit
EditHistory
Edition
MetaclassEdition
MethodEdition
ProtoclassEdition
TaggedEdition
TagsEdition

Apache
GPL
GPL3
License
MIT
Squeak

BehavioralLiteralMarker
ClassLiteralMarker
ClassVariableLiteralMarker
GlobalLiteralMarker
IdentityLiteralMarker
MetaSuperSendLiteralMarker
MethodLiteralTransmissionMarker
PublishedVariableLiteralMarker
SharedVariableLiteralMarker
UndeclaredLiteralMarker

Manifest
NegativeManifest
PositiveManifest

DescribeModule
BrowseAvailableModules
EmitFavoritesIcon
InstallRemoteModule
ListInstalledModules
ModuleAction
Quit
RemoteModuleAction
RemoveModule
RunRemoteModule
Snapshot
Welcome

UUID
UUIDGenerator

CounterpartRequest
IncomingMessageExchange
MessageExchange
MessagingServer
MessagingSession
Other
OutgoingMessageExchange
RemoteMessageAnswer

Wormhole
WormholeServer

Scanner

Halt
BlockCannotReturn
Error
Exception
ExceptionAboutToReturn
Notification
ZeroDivide
ConnectionRefused
EncodingMismatch
ExternalResourceError
FailedReadingAttempt
InvalidPositioningAttempt
StreamingError
Timeout

MethodReference
Interpreter
ObjectMemory

PositionableStream
Stream
WritableStream

Correspondent
Server
SocketAddress
SocketAddressResolver
ExternalSemaphoreTable
Client
IncomingClient
IncomingHTTPClient
OutgoingClient
SocketTransport
Transport
ExternalStream
NetStream
SocketStream
TCPStream
ExternalResource
Peer
ClientTCPSocket
IncomingClientTCPSocket
OutgoingClientTCPSocket
ServerTCPSocket
Socket
TCPSocket

4 Comments »

Windows and Linux apps created, initial modularization in progress

Posted in Naiad, Spoon on 14 June 2011 by Craig Latta

I’ve created Windows and Linux apps to go along with the Mac app I made for starting Spoon. Now I’m sorting all the classes and methods of the minimal object memory into modules. Next I’ll test installing a module from one memory to another via Spoon’s webpage interface. Then I’ll adapt the remote browsing support to Squeak 4.2. Then, a release!

Leave a comment »

my favorite text editor editing a Context WebDAV filesystem

Posted in Context, Spoon with tags on 9 June 2011 by Craig Latta

Leave a comment »

Context mounted as WebDAV filesystem

Posted in Context, Spoon with tags on 6 June 2011 by Craig Latta

4 Comments »

proposed WebDAV mapping

Posted in Spoon on 2 June 2011 by Craig Latta

So I’ve got a class called “Spoon” which services requests about Spoon from the rest of the world, via WebDAV. In particular, I provide the illusion of a filesystem that can be mounted by other operating systems. Editing certain of those virtual files invokes behavior within Spoon.

Here’s a summary of that filesystem:

/
  /bin/
    (frequently-used expressions, presented as executable files)
  /classes/
    (all the classes)
    ...
    /classes/<class>/
      (a file for each method of <class>)   
  /do (a file to which one write a method, which is
           then executed, leaving the result as the
           file contents)
  /notes/ (a normal directory, for use as a staging
           area for "do" files, for example)

Here’s what you might see at a shell on a machine which has a mounted Spoon system:

craig@netjam spoon> pwd
/Volumes/spoon
craig@netjam spoon> ls
classes/  notes/  do
craig@netjam spoon> cd classes
craig@netjam classes> ls
Object/
craig@netjam classes> cd Object
craig@netjam Object> ls
Boolean/  Collection/  (etc.)
craig@netjam Object> cd Boolean
craig@netjam Boolean> ls
and:  ifFalse:  ifTrue:  (etc.)
craig@netjam Boolean> more ifTrue:
ifTrue: aBlockClosure
  "If I am true, answer the value of aBlockClosure. Otherwise, answer nil."

  self subclassResponsibility
craig@netjam.org Boolean> cd /Volumes/spoon
craig@netjam.org spoon> echo "3 + 4" >! do
craig@netjam.org spoon> more do
7
craig@netjam.org spoon> cd /bin
craig@netjam.org bin> ls
snapshot  (etc.)
craig@netjam.org bin> snapshot

This seems like the minimal functionality. What else would be nice or fun to have?

10 Comments »

“Can I use my favorite text editor?”

Posted in Spoon on 31 May 2011 by Craig Latta

Yes!

I want to make Spoon as approachable as possible. One of the first things that turned people off about previous Smalltalk systems was that they couldn’t use their favorite text editor to edit source code. This resulted from Smalltalk’s fundamentally different way of structuring and interacting with information, but the recent ubiquity of network protocols for distributed file editing enables a solution.

Traditionally, Smalltalk is a complete model of a virtual computer, including the contents of that computer’s memory. This concept has become familiar on a mass scale through applications like VMWare. Those virtual machines run familiar operating systems, like Windows and Linux. The Smalltalk virtual machine, however, structures its memory entirely as live objects which send messages to each other. This contrasts with the pervasive notion of static files in other operating systems. Also, like VMWare, as far as the host computer is concerned, a running Smalltalk system is a separate machine.

But just as other virtual machine implementors have devised ways of interoperating with the host computer, Smalltalk can too. Smalltalk started as a single-user system, before network protocols like HTTP, or even the networks they use, were widespread. Now, however, a Smalltalk system can speak these protocols and present itself as any other computer would. In particular, it can run a web server that speaks a protocol for distributed file editing, WebDAV. Windows, Linux, and MacOS can mount WebDAV filesystems and interact with them normally. To the WebDAV client, Smalltalk presents a filesystem, and the way it actually structures information becomes irrelevant.

I’m writing WebDAV support for Spoon. One way to interact with Spoon (before one realizes what else is possible :) is to mount its virtual filesystem from the host computer, then edit files within it using your favorite text editor. Spoon can present files which are semantically meaningful (a class hierarchy as a hierarchy of files, for example), and associate various meanings with changes to those files. By choosing that presentation wisely, one could create a complete development environment, operable from that favorite text editor.

Leave a comment »

« Older Entries
Newer Entries »