Newton Poetry

“Back in 1998, Apple killed the floppy drive with one fell swoop. Killing the PC desktop won’t be as quick and easy, but Apple will do it over time. It started with the iPhone, and in a few years we won’t even remember the Finder.”

– Sachin’s Posterous, in a very thought-provoking post. I often wonder what OS X+1 will look like. Not OS X 10.7 or 10.8, but after the tens are done. What does the next-generation, non-OS X-based operating system look like?

[Via Sir Kendal.]

Now that Paul Guyot’s Einstein, the Newton emulator for Mac and Windows, is available for Snow Leopard, users with up-to-date Macs can play around with the Newton OS.

This seemed like the perfect time to give Einstein a spin on my new iMac.

First, I downloaded the latest Einstein app from Google Code, plus the Users Manual. The Users Manual is handy because it gives instructions on how to grab a ROM image of your OS 2.x Newton device. In my case, I’m grabbing my eMate’s ROM with a package of file called Lantern DDK (thanks to Macintosh Garden).

Lantern DDK gives you ROMs from an eMate and an MP2000, along with a few other pieces of debugging software.

Einstein has you pick which Newton device you want to emulate, and point it toward a viable ROM image. Then you pick how much RAM you want the thing to have, native or full-screen resolution (warning: full screen is a bear), and how to run the screen and sound.

After a few minutes of booting, Einstein pops up with a Newton screen showing that it’s working fine.

From there, the pseudo eMate runs through the name, address, and time setup process. What’s nice about Einstein is that it grabbed my Address Book information automatically.

Then you get a simple Notes interface. And that’s about it, at least from what I saw, so it could be that the ROM only has certain features from the eMate. But it’s a fun little project to get running on your Mac. Note, though, that Einstein also has a Windows version.

[Thanks to Riccordo Mori for the inspiration to give it a try, and NewtonTalk for the link.]

Here at Newton Poetry, there is One Supreme Operating system, and therefore most posts relate to the Newton interacting with the Mac environment.

I realize, however, that there are other operating systems out there. And, while I’m not a user, I respect that Newton fans can be Windows and Linux users. With Windows, there are tons of tips and how-tos on how to make connections and upload packages and whatnot. Sadly, we don’t hear as much from the Linux side.

Let’s put our operating system differences aside and help Newton users be better Newton users, shall we?

To start, I found the Newton and Linux mini-HOWTO, a site filled with questions and answers (like “How to upload a Newton package to Linux” and “Which Linux software is available”).

Some of the info seems to be dated. For instance, the author talks about Windows-emulating WINE to be a project slated in the future tense. Plus a few of the links are dead. But the basics are all there.

To get connected, there’s Newtonlink.  There are a few more Linux applications for the Newton over at TuxMobil.

Then again, you can always replace Linux on your PDA with the Newton OS. I’m just sayin’.

Any Linux users out there that have successfully paired their Ubuntu with a MessagePad or eMate? Let me know in the comments.

After installing a new battery pack in my Newton eMate 300, I wondered about the pack’s abilities: how long did it take to charge? How could I find its exact charge capacity? How long would it take to discharge?

Thankfully, I found a super-useful application (thanks to Tony Kan) to find all this out: Frank Gruendel’s NewtTest.

NewtTest is an all-in-one information source for any Newton ever created, from the OMP to the MessagePad 2100. As Frank says:

NewtTest will only show tests that make sense on the particular machine it is running on (you won’t, for example, find the backlight test on an OMP). Hence it will look different on different Newton models.

Once you install NewtTest on your Newton, you have access to tons of great tidbits of data. From the most detailed, like the above screenshot under “System Info,” to a “Backlight” feature that simply lets you turn your backlight-capable Newton on or off.

For my own use, the “Battery” section showed my eMate’s capacity, temperature, and voltage. It also recognized the type of battery pack I installed as an Apple NiMH rechargeable pack. Gruendel’s attention to detail here is impressive, and much-appreciated.

Another benefit is the “Clock” feature. If you’ve ever had to reset your Newton’s clock (on OS 1.x models) or calendar date (on any Newton), you know how frustrating it is.

NewtTest makes it simple by letting you pick the year first (above) and then worry about the date. Since my eMate was constantly running out of juice, I spent a lot of wasted time resetting the date by scrolling through the months and years (usually starting with 1997). NewtTest’s “Clock” feature becomes a big time saver.

Other “Test Types” in NewtTest, like testing the sounds on your Newton (cuckoo!) and calibrating the digitizer, are so helpful I wonder how I’ve lived without them.

For instance, my eMate’s screen shows a few faded or missing pixels on the right-hand side of the screen. With NewtTest’s “LCD Display” test, I can show a fully black screen, or a series of horizontal lines. It turns out that my eMate has a vertical line of faded pixels running the entire length of the screen. That’s not good news, but it’s worth knowing.

Gruendel has developed a few other applications for the Newton, but NewtTest is so practical that no MessagePad or eMate user should be without it.

Steven Frank, at his stevenf.com blog, has been thinking about what could possible replace the desktop metaphor that XEROX and Apple helped to pioneer.

Besides the desktop paradigm, Frank describes the pros and cons of other computing models – like the Newton’s soup-based data model and the iPhone’s multi-touch platform.

The Newton’s model had benefits, Frank says, but crumbled under the weight of OS-to-OS translations:

The Newton’s object store was an engineering marvel that fell apart as soon as you needed to exchange data with the outside world. You couldn’t just take a text file and send it over to your Newton because the Newton didn’t understand the concept of “file”. Your text first had to go through a conversion (via Newton Connection Utility) into an object format that some Newton application (in this case, probably Notes) could handle. Then you’d have the reverse problem going the other way.

Because desktop apps and Newton apps would never offer exactly the same feature set, inevitably these conversions result in loss of some information. Nitty-gritty things like precise formatting, metadata, and so on are the first things out the window when you need to convert data between two formats. It leaves you with a “lowest common denominator” form of information exchange that’s more frustrating than just being able to send files around. But in order to “just send files around”, you’d have to jettison all your radical (and useful) innovations and go back to square one: the good old hierarchical file system.

It’s a heckuva read, even if Frank offers no clear solution to what will come (web apps? Spotlight?) after the desktop metaphor has outlived its usefulness.

John Gruber at Daring Fireball has mentioned this before, but what I like about the Newton OS is that everything is automatically saved for you. When you scribble out a new note, you never have to press a “save” button. The only action you take with a note, after you’ve finished it, is to move it into some sort of organizational file system. But that’s optional. If you don’t want to move it, you don’t have to; you can shut off your Newton and the note stays right where you left it.

It’s like the Notes app on the iPhone, or the Stickies app on the Mac. Everything is automatically saved to some arcane folder deep in the Mac Library system.

What do you think? What’s the best possible platform to inherit the desktop’s dominance in computing?

Mike Levins on his favorite programming language:

I used to say it was 1992-era Dylan. Dylan was a Lisp that Apple invented. I worked for several years on Apple’s Newton project. Newton was initially written mostly in Dylan, and I got to write a lot of OS code in Dylan. That was a time of high joy in my programming life.

It didn’t last, of course. The story of Newton’s abandonment of Dylan and its other adventures makes entertaining reading, but the short of it is that eventually I had to stop programming in Dylan.

Turns out Dylan is still around, but Levins has moved on to a Lisp dialect called Clojure.

“If Apple had sold even close to 30 million Newton OS devices in its first 18 months, Apple would not have been ‘beleaguered’, they would not have bought NeXT, and Steve Jobs never would have been brought back. Instead, IDG reported that Apple sold a grand total of only 60,000 Newton units in all of 1996, the Newton’s third year on the market. That’s about how many iPhone OS devices Apple sold per day — per day! — for the first 18 months after the iPhone went on sale.”

– John Gruber at Daring Fireball, on Apple’s too-intent focus on the Next Big Thing during the 1990s.

“One way to think about the NewtonOS is as a particular way of working with words, ideas, and so forth–kind of a particular way of imagining the world. If there’s no way to interact with a Newton after the coming year, this way of imagining / interacting with the world is more or less lost to us, and that’s a very sad (cultural / ideational) loss.”

– Jonathan Dueck, on the Newtontalk list, regarding the fight to get the 2010 bug resolved.

I’m all about the classic Mac’ing around these parts. That’s why I thought Jason Snell’s “A Time Machine trip to the mid-’90s” article for Macworld.com was so darned cool: he lets us know about some of the never-to-see-the-light-of-day features of Copland, Apple’s vaporOS.

I remember reading about Copland and Pink and all the other weird OSes Apple was planning, but it was cool to see the operating system screen shots. Love that ’90s styling – takes me back to the Packard Bell computer my dad bought (and I ruined).

Check it out for a neat comparison on features in Copland and today’s OS X Leopard.

Owning an iPhone and a Newton, it’s always fun to poke around at other mobile operation systems when I get the chance. The other day, I put my stylus on a Palm for the first time, and got to play around with it for a bit.

Gizmodo puts all the major smartphone OSes – RIM’s Blackberry, Apple’s iPhone, Windows Mobile, for instance – against each other in a run down of features, pros, and cons.

The only classic mobile OS in the bunch is the “basically dead” Palm OS in the Centro, which is sad, considering (a) the Palm OS looks so dated with the other systems and (b) Palm succeeded where the Newton did not in a lot of ways. Now it’s a dying system.