StepTalk

Polishing the project

2006-06-06T00:01:00.000-07:00

Rainer Keller has polished the StepTalk XCode project:

fixed some absolute paths to sources
corrected plist files and their locations
adjusted the project settings appropriately
created a Debug.xcconfig and a Release.xcconfig file which serves as the
basis for all targets Debug and Release configurations respectvely
removed all project-global settings as they are in the xcconfigs now
minimalized all settings for the individual targets (removed all the ones
that are in the xcconfigs already)
added missing depencies
removed the meta-uber target because there are proper dependencies now

Release 0.12 (updated 2)

2006-05-30T15:33:00.000-07:00

New StepTalk release 0.12 is available for download here (Disk Image, 1.6MB). It contains all previously mentioned changes, and new StepTalking application that uses StepTalkKit framework:

Sources in ZIP archive can be found here (405KB).

Reusable Conversation Panel (edited)

2006-05-29T17:00:00.000-07:00

I have finished a prototype of reusable conversation ~~panel~~ window in the StepTalkKit framework. This is how it looks:

Features:

default context, if not provided any
customisable toolbar
script history - recall previous scripts either from toolbar or by keyboard
language selection

And this is how you will be able to use it in your applications.
~~STContext *context; /* Assume this exists and is set up */ STConversationPanel *panel; panel = [[STConversationPanel alloc] init]; [panel setContext:context]; [panel makeKeyAndOrderFront:nil];~~
STContext *context; /* Assume this exists and is set up */ STConversationWindow *window; window = [[STConversationWindow alloc] init]; [window setContext:context]; [window makeKeyAndOrderFront:nil];
If you do not set the ~~panel's~~ window's context, default one is used - local to the ~~panel~~ window.

What do you think?

Wanted: StepTalk Maintainer for GNUstep

2006-05-26T01:35:00.000-07:00

As the StepTalk is now being developed on Mac OS X, a maintaner for the GNUstep version is needed. Taks is simple: synchronise sources and maintaing GNUstep-Cocoa compatibility. If anyone is interested, just let me know and I will provide him with all needed information. Do not worry if you do not know about StepTalk too much, you will learn... :-)

May progress

2006-05-25T05:08:00.000-07:00

What is going on?

StepTalkKit framework is being created
AppKit bundle is included
source is reorganised into more logical groups
Foundation and AppKit now advertise all public Cocoa classes
constants from Foundation and AppKit are generated from simple constants list file instead of .m source file (the .m file is being generated)

The StepTalkKit framework will provide user iterface elements for integrating StepTalk into any application. It will contain:

conversation panel similar to the one in StepTalking application that can be reused in any application
views for custom script input/output: script input view, transcript view (implemented)
actor builder panel - panel for creating actors, editing their methods and attributes

By using the combination of script input view and transcript view one can create instant-messenger like interface (similar to Adium) for 'chatting' with objects. Basic 'object chat' window is provided with the conversation panel class in the framework.

If you have other ideas or questions, do not hesitate to share them.

IO language bundle

2006-05-25T05:01:00.000-07:00

Yen-Ju Chen has created IO language bundle for StepTalk. The bundle is not available now for download, as it is just firt release that proves that it works. More information can be found here.

Updated try

2006-05-16T14:27:00.000-07:00

I have updated the application and fixed some issues. The StepTalking application now supports Adium-like history recall with Alt+Up and Ald+Down keys. Also I have added the language selection menu (Note that the default installation contains only one language bundle).

Download the new disk image here. XCode projects for both, the framework and the application are included.

Finally talking on OS X

2006-05-15T05:58:00.000-07:00

After few months of silence, while developing new application with code name GridCells, I have updated StepTalk for OS X. New application was created as well:

Noteworthy changes in StepTalk are:

New application called StepTalking - simple instant-messenger like interface for talking to objects in StepTalk languages.
Bundled default bundles (modules and the Smalltalk language) inside the framework - not polluting Library directory any more with default installation
"Traits" in the Actors (STActor)

You can download the disk image with OS X Tiger binaries here. There is the framework, application, installation instructions (two steps) and some documentation-in-pictures. I hope to upload cleaned XCode project soon.

Enjoy!

P.S.: If you have any problems, do not hesitate to contact me.

OS X Port Progress

2005-09-21T23:56:00.000-07:00

Yesterday, I have received a patch that makes StepTalk work on OS X from Stefan Kleine Stegemann. The patch would allow one to compile and use StepTalk with native Cocoa frameworks without GNUstep. We hope to create a release next week if things will go well, so stay tuned.

StepTalk 0.10.0

2005-09-05T13:47:00.000-07:00

StepTalk 0.10.0 was released. Get it from here. What is new:

introduced new language management (STLanguageManager)
introduced remote scripting (STRemoteConversation)
new tool for semi-persistent environments: stenvironment
added reading from stdin to stexec
added remote scripting to stshell and stexec
new conversation methods
removed tools: stalk, stupdate_languages
removed depreciated methods from STEnvironment
removed class STLanguage

Of Scripting Languages and Language Engines

2005-08-31T00:09:00.000-07:00

Scripting language - a communication tool for of telling objects on a computer what to do. You may ask: "What objects?" and I would answer: "Objects you see on the screen or objects you know are there."

"How does the computer know, what objects I mean?"

"You name them."

"Will the computer understant if I would like to do something with object I call 'document'?"

"Usualy yes - if the developer of the application would name the object you can think of as of 'document' by the same name"

"If we both agree on the name, then I can just use it in my script, right?"

"Yes. "

Now we see, that the language and scripting is about two main things: communication system (tool) and objects the tool is working with. In other words, the system is put into a small world called scripting context. It is the same with our natural language where we are allways in some context: office, restaurant, opera or disco. If I am in context 'office' and I will talk about object named 'table', then it would be obvious what table I mean by default - it would be the office table, not the table down in the cantine. The context links object names to real entities.

The language is represented by an engine (interpreter) that interprets scripts. As interpretation of all scripts is done in a context, the engine should take that fact into account. How? Primarily by consulting the context for object names. That means that when an object name (also can be called identifier, variable, constant...) is found in a script, the engine should bind it to real object through the contex.

To sum it up: there are two sides where context is considered and they are an application and a language. The application is context provider and the language is context user. While the application is responsible for giving object names that a user would expect to be, the language is responsible for resolving names in scripts to the same objects that applocation defines.

Language Manager

2005-08-30T23:35:00.000-07:00

Language Manager was added to StepTalk. This new class allows easier language and language bundle handling. Main functionality of the class is:

maintain list of available languages
provide language engines and language information
handle language registration and removal
maintain a map of file type to language associations

This addition obsoletes old STLanguage class, several STEngine methods and the stupdate_languages tool.

What needs to be improved is StepTalk method interpretation either of the methods themselves or of the methods in an actor. One possibility is to cache engine class after first method execution.

Prototype with the language manager addition can be found here.

Remote scripting

2005-08-26T00:53:00.000-07:00

Prototype of shared semi-persistant environments is done. With this addition the remote scripting is reality:
For more information see small presentation here (PDF document). You can download the prototype here (306kb .tar.gz).

Environments

2005-08-10T04:51:00.000-07:00

I have started working on StepTalk semi-persistent environments. By semi-persistent I mean, that they are persistent from point of view of processes. On the other hand, the environments being processes themselves, they are destroyed between computer restarts.

Scripting environment, as mentioned, is a process of the stenvironment tool. The process creates a scripting environment object and wraps it in a Distributed Objects (DO) server that represents the process. To "talk" inside the environment, one has to create a distant conversation (STDistantConversation) with the named server.

To get better picture, very simplified analogy is a database server (= scripting environment), database connection (= conversation) and a SQL script (= StepTalk script).

Actors

2005-08-05T04:24:00.000-07:00

New class for actors was added to StepTalk. What are actors in this context? They are objects with own attributes and methods written in a script. One can use actors for example for:

fast prototyping of objects
user-customisable objects or assistants
application extensions

Each actor has to be "put into an environment" - programmatically it means that one has to assign an environment to the actor.

Here is a short example written in Smalltalk, easily rewritable to Objective-C. First we create an actor:

actor := STActor actorInEnvironment:Environment.

Then we create attributes (instance variables):

ivars := NSMutableDictionary dictionary.
ivars setObject:1 forKey:'number'.
actor setInstanceVariables:ivars.

Now, to create a behaviour, one has convert scripts into a methods. This conversion is done using an engine. Therefore we need to get the proper engine for a language of our choice, which is Smalltalk at this time:

engine := STEngine engineForLanguageWithName:'Smalltalk'.

Create a new method script:

source := 'increment number := number + 1. ^self'.

Create method and add it to the actor

method := engine methodFromSource:source forReceiver:actor inEnvironment:Environment.
actor addMethod:method.

Add few other methods in a similary way: setNumber: - set value of i; print - print i on Transcript.

Finally send the messages and see it work:

actor print.
actor increment.
actor print.
actor setNumber:10.
actor print.

Script for this example can be found in StepTalk sources Examples/Smalltalk/actor.st

StepTalk introduction

2005-08-01T04:20:00.000-07:00

StepTalk introduction document was published and can be found here. I hope to create more documentation about StepTalk.

First post

2005-07-27T17:43:00.000-07:00

Hi and welcome. This new blog is going to be not only about StepTalk. Thoughts about software and programming would fill these pages too...