What is Sloup?

Sloup is a utility for transferring data or text between desktop files and Newton "soups" (object-oriented databases).

Feature summary:

Warning: since Sloup can add or remove entries from your Newton soups, please keep your information backed up regularly, and follow the formats and commands carefully.

For the latest information and versions, please check Steve's Newton page.

Why Sloup?

I wanted a convenient way to move information from the desktop to soups on the Newton, especially text paragraphs to separate Notepad entries, and vice versa. Desktop synchronization/transfer tools were not always available for different versions of Newton OS and different desktop systems, and did not always provide the current set of features I wanted. See related tools. Apple provided several Newton programming examples (Slurp, SuperSlurp) for soup transfer, which I modified over time, adding many improvements.

Although Sloup was created primarily to support moving NewtonScript application/method sources and graphic/sound resources by users of the Newt Development Environment, and HTML source and graphics for Newt's Cape books, I thought that this may be useful as a general utility for others to transfer Notes, Names and other data. Sloup can transfer binary data -- graphics (including gray scale on NOS 2.1), sounds (and packages on NOS 2.x) -- via a simple encoding format.

To assist in real-time application development with Newt, I added some "Inspector-like" functionality so that you can use your desktop keyboard to type into Newton fields, and to redirect Print and Notify results to a window on your desktop.


Sloup is shareware ($10). Sloup may be freely distributed via online services and bulletin boards if it is unmodified and includes this and other files mentioned here. It may not be commercially bundled or redistributed on CD-ROM, floppy disk, PCMCIA, networks or other media without permission.

Sloup is currently free to registered users of Newt Development Environment and Newt's Cape.

Setting up Sloup

Sloup makes no claims to being a user-friendly tool. The process of configuring your terminal emulator and defining frame specifications may yield strange errors. There are several third-party tools that provide alternatives, use Sloup but hide some of this complexity. I can provide some documentation, examples and interactive help (especially if you register), but you'll have the most success if you have used terminal emulators, have a little programming or database background, and are adventurous and not easily frustrated.

Once you've surpassed the initial configuration/setup hurdles, Sloup can be quite useful for quickly and flexibly moving information in and out of your Newton.

Although the Sloup application has some controls and preferences, you should think of it primarily as a "server". Once a connection has been established, all of the commands come from the desktop client such as a terminal emulator.

For example, to send data to your Newton, you tell Sloup to Connect, and then send text containing soup name, format specification, and data, via your terminal emulator, usually as a text file. To send data from your Newton, you also set Sloup to Connect; however, the text file that you send contains a soup name and format specification, but no data -- just a Dump command (this assumes you set up a log file to capture the data returned)

When first getting started, it's usually a good idea to just give Sloup a line at a time rather than sending it a large file. That way you can see the status messages, and if there are errors, the desktop side may not hang.

Configuring Sloup and Desktop Communication

Given the wide variety of terminal emulators that are available on Mac (ZTerm, ClarisWorks,...), Windows (Terminal,...), Unix and other platforms, I hope that these guidelines below are adequate, and that with a little interpretation and experimentation, you will be running soon without excess pain and suffering. Please send let me know which software you are using and whether there was anything unusual you needed to do to get Sloup to work (or if there's a comms package that did not work well or at all) -- I'll summarize and make these accessible on the Sloup page

After installing the Sloup package, make sure you have a serial cable still connected, no other desktop program using the serial port, and (on NOS 1.x) no other Newton application using communications: beaming, modem, etc. If you are using a 3rd-party front-end for Sloup, follow those directions; if you are using a desktop terminal emulator, configure it initially as follows:

Start Sloup on the Newton, and choose connection speed (9600 is only choice in public version) to match desktop configuration.

Initiate/open desktop connection; tap Sloup's Connect button.

To check that the connection is working, just type "xxx" on desktop-- you should see a Sloup message: "not a soupname: xxx"

Another simple thing to try before attempting anything more complicated is to type (or click on the example in book version of this on Newton if Sloup is installed):

hello there

The note should appear in your Notepad (Unfiled folder)

If things are working, send an example file. In Sloup, make sure it is waiting for a soup name (if not, do Disconnect/Connect). On the desktop side, "Send File..." or "Send Text..." in the comm program, and choose the file to be sent, e.g., CasioNam.tab. Note: this is not a XMODEM, Kermit, ZModem or other protocol, just text; alternatively, you could just Copy a section from a text editor window and Paste it into your terminal emulator. If you are doing a "Dump", immediately setup a file to log/receive/capture the result.

Sloup should display the number of entries received/dumped in a view near the top of the screen. When the file transfer is complete, Sloup will automatically wait for another transfer. I would suggest starting with the CasioNam.tab example first (you could delete some of the lines, but don't start making other modifications just yet...). Tap Disconnect to end the connection, or just close Sloup.

User Interface: Sloup

drag dot[top center]
main view can be moved
Inspect?[checkbox; top left]
default off. toggles to a smaller view (see "Inspector"). input characters/lines are directed to current "key view" rather than to a soup. saved as a Preference
Paste[button; top left]
pastes current text entry (key view) or highlighted selection over current connection
Connected/Disconnected[status text; below Paste]
depending on state of connection
9600 (speed)[picker; top right]
the standard, public release just offers 9600(serial); other versions of Sloup offer: 19200, 38400, 57600, ADSP. (If you are using ADSP connection in Sloup with ClarisWorks, choose the AppleTalk ADSP Tool, leave your zone as "*", and set your Local Name; select "Wait for Connection"; on Newton, a "NetChooser" dialog appears -- select name of desktop system)
Connect/Disconnect[button; top right]
open or close a connection using the current connection speed, e.g., 9600
"$" (Register)[button; top right]
If the Newton Register application is installed, tap on the "$" icon to open up a registration screen. This is a convenient and reasonably safe way to register with a credit card via Newton email (e.g., Aloha). web, Newton, Mac, Windows versions of Register
"i" (info)[button; top right]
displays About box (URLs are active if Newt's Cape is installed)
Newt icon[icon; center]
If Newt Development Environment is installed, tap on Newt's icon to start it. Typically, you might start Newt, then tap on Inspect? Or, you can start Newt first, and select Sloup from the overview menu
Status:[text; center]
displays current state of connection
Soup:[text; center]
name of current soup, e.g., Notes
Entries:[text; center]
displays number of entries imported/exported
Idxs:[text; center]
number of indexes for current soup
Entry:[text; bottom center]
current line (or recent if Refresh? is off or at higher connect speeds)
AutoConn?[checkbox; bottom left]
default: off. if checked, connects immediately and automatically upon Sloup startup using last settings, e.g., serial (speed), ADSP (zone, host)
Sound[picker; bottom center]
default: none. pick a built-in sound to play when connecting and at end of transaction; saved as a Preference across sessions/reboots
Refresh?[bottom right]
default: on. turn off to speed up transfers -- Sloup only refreshes when there is extra time available; this might mean every line at 9600, only every few lines at higher speeds. Leaving it on does a refresh after each line. saved as a Preference

Terminology: Sloup

an object-oriented database. Its entries are frames
a frame is a Newton object which contains slots and values. It's similar to a database record, or row of a relational table. Also called an entry. Although the frames in a soup can have different slots, it is more efficient for the system (and easier to write applications) if the frames are similar, if not identical, in structure
a slot is basically a field or attribute that contains a value. A slot could have different types of values, though not if you want to index a slot
a value can be a literal value (number, string, symbol, boolean) or an array, frame or binary object
if an index is specified for a slot, the Newton can uses value as a key to access an entry or sort entries faster. This assumes that all of values of a slot are of the same type (integer, symbol or string)
entry specification
an entry specification is a frame that describes the order of fields and types of values