I’ve been using the Linkinus IRC client for Mac OS X a lot recently, and one of the things I dislike is needing to think up a different greeting every time I join a chat room (I hate using the same old greeting every time). Thankfully, Linkinus is easily scriptable, so without further ado, I give you the “/hello” command:

-- Script Name: hello
-- Version: 1.0
-- Description: Say "hello" in various interesting ways
-- Author: Ian Beck <https://beckism.com>

-- Usage: /hello folks!
-- Output: [Greeting] folks!
-- (can also use alone for just the greeting)

on linkinuscmd(name)
	-- Get a random item from the list of greetings
	set response to some item of {"Aloha", "Bonjour", "Ciào", "G'day", "Guten tag", "Hallo", "Hello", "Hey", "Hola", "Salaam", "Shalom"}
	
	-- Add the name, if we are using one
	if name is not equal to "" then
		set response to response & " " & name
	end if
	
	return response
end linkinuscmd

-- Changelog:
-- 1.0:
-- - Initial release

To install the command, pop open your favorite Applescript editor (like the free AppleScript Editor that comes with your computer, or Script Debugger if you’re all fancy-shmancy), paste in the code above, and save it as hello.scpt at this path:

~/Library/Application Support/Linkinus 2/Scripts/hello.scpt

The next time you launch Linkinus, you will be able to enter /hello with an optional name or similar, and it will output a random greeting followed by whatever you typed. So for instance, you type /hello folks! and what shows up in the chat room is “Aloha folks!” Or maybe “Hola folks!” Or possibly “Guten tag folks!” Or any number of other greetings.

If you want to use a different selection of greetings, you can modify the list on line 12 of the script.

Granted, figuring out a random greeting in Linkinus is probably not a problem most people have (“IRC? What on earth is that?”), but for those of you who are also annoyed by this repetitive task, enjoy!

Thanks to a recent beta of Carbon (an upcoming Twitter client for WebOS), several WebOS developers have been implementing a feature called power scrolling: in a scrollable area, you swipe with two fingers instead of one, and it jumps you immediately to the top or bottom.

This is an incredibly handy feature, and Jay Canuck and Doug Reeder both posted code snippets to help you integrate it into your own app. However, their code has some downsides: you have to implement it for every scene, it doesn’t animate, and extending prototypes is ugly.

Here, then, is a reasonably simple way for you to enable animated two-finger power scrolling in all scenes of your WebOS app.

To do so, we’ll use Prototype.js class inheritance to create a generic base class with two-finger scrolling support that can then be added to any of your scene assistant classes to toggle on power-scrolling.

The first step is to create a new file (location doesn’t matter, although mine is stored in /app/assistants) and add it to your sources.json file. In my instance, I called it power-scroll-base.js so the new line in sources.json looks like this:

{"source": "app/assistants/power-scroll-base.js"},

(Trailing comma is there because this is not the last item; if yours is last in your file, you won’t want that comma.)

After you have the file created and added to sources.json, add these contents to it:

/*
PowerScrollBase: a Prototype base class to quickly add power scrolling
to your existing scenes

Created by Ian Beck <https://beckism.com>
Released in the public domain

Many thanks to Jay Canuck and Doug Reeder for the basic idea and code:
- http://pastebin.com/6JqcQT4a
- https://gist.github.com/786358
*/
var PowerScrollBase = Class.create({
    // === $SUPER CALLS ===
    
    initialize: function() {
        this.twoFingerStartBound = this.twoFingerStart.bind(this);
        this.twoFingerEndBound = this.twoFingerEnd.bind(this);
    },
    
    activate: function() {
        // Add listeners for two-finger gesture events
        Mojo.Event.listen(this.controller.document, "gesturestart", this.twoFingerStartBound);
        Mojo.Event.listen(this.controller.document, "gestureend", this.twoFingerEndBound);
    },
    
    deactivate: function() {
        // Stop listening to two-finger gesture events
        Mojo.Event.stopListening(this.controller.document, "gesturestart", this.twoFingerStartBound);
        Mojo.Event.stopListening(this.controller.document, "gestureend", this.twoFingerEndBound);
    },
    
    // === EVENT METHODS ===
    
    twoFingerStart: function(event) {
        this.gestureStartY = event.centerY;
    },
    
    twoFingerEnd: function(event) {
        var gestureDistanceY = event.centerY - this.gestureStartY;
        var scroller = this.controller.getSceneScroller();
        var pos;
        if (gestureDistanceY > 0) {
            scroller.mojo.revealTop();
            pos = scroller.mojo.getScrollPosition();
            scroller.mojo.scrollTo(0, pos.top - 50, true);
        } else if (gestureDistanceY < 0) {
            scroller.mojo.revealBottom();
            pos = scroller.mojo.getScrollPosition();
            scroller.mojo.scrollTo(0, pos.top + 50, true);
        }
    }
});

This works by listening to the WebOS two-finger gesture events. When the gesture starts, it notes the Y position. Then when the two-finger gesture ends, if the Y position has changed it uses Mojo.Widget.Scroller.revealTop() or Mojo.Widget.Scroller.revealBottom() to immediately jump to the top or bottom of the scene scroller (Mojo.Widget.Scroller documentation here). However, this instantaneous jump is not very user-friendly because there’s no good visual indication what just happened, so the code then grabs the scroller position and bumps it 50 pixels beyond its bounds with Mojo.Widget.Scroller.scrollTo() (with animation enabled). This triggers the “you’ve reached the end of the scrollable area” bounce, which effectively communicates to the user that they have jumped to the top or bottom of the scene.

To use this code, you need to make a few changes to your existing scenes (assuming that they are already laid out as Prototype classes—if not you will need to first convert them). For instance, if you have an ExampleAssistant, you would modify it to look like this:

var ExampleAssistant = Class.create(PowerScrollBase, {
    initialize: function($super) {
        $super();
        // Do other initialization
    },
    
    activate: function($super, event) {
        $super(event);
        // Do other activation tasks
    },
    
    deactivate: function($super, event) {
        $super(event);
        // Do other deactivation tasks
    }
    // Presumably you will have other logic in this class, as well
});

This works by using Prototype.js’s class inheritance and special $super keyword. When the first argument in a class method in Prototype is $super, Prototype will internally modify the method so that external calls ignore the $super argument, but within the function you can call $super() to invoke the overridden copy of the method on the base class. By using PowerScrollBase for your base class and $super in your initialize, activate, and deactivate methods you can enable power scrolling very quickly in any scene within your app.

Here’s hoping that power scrolling catches on more broadly within the WebOS community; it’s one of those gestures that you will rarely discover on your own, but once you know it can make your life a whole heck of a lot easier.

Daniel Jalkut, developer of the excellent MarsEdit blogging software, recently tweeted:

I’m thinking of commissioning a dedicated site for teaching the basics of blogging. Unless somebody knows of a really good one already?

I’ve never come across a good site for beginning bloggers myself. Most of them are spammy content farms, one-off posts about blogging on otherwise unrelated blogs, or “how to blog” sites that are started with good intentions and abandoned a month or two later when the author runs out of steam.

It’s an intriguing idea, though. After all, blogging is an increasingly popular activity, and it’s one of those things that you never really master. Like any type of writing (or art, depending on what you’re posting), blogging is an on-going project, your style and approach subtly changing every time you put words to page (or, in this case, bits to screen).

As I thought about such a site, what I ended up wondering is what constitutes the basics of blogging? It’s an incredibly wide topic. At a magazine, an author may write an article, but other people are responsible for laying it out, designing the surrounding pages/cover/etc., marketing it, and handling revenue streams. Most bloggers, however, handle all of that and more.

Blogging is finding and choosing the software or platform to host your blog. Blogging is then finding or creating a design for your blog.

Blogging is HTML, CSS, Markdown, Textile, WYSIWYG, and countless other systems for formatting your text.

Blogging is basic writing skills; tone, narrative, grammar, punctuation, and all the rest.

Blogging is being author, copy editor, editor, and publisher all at once.

Blogging is journalism. Blogging is personal opinions. Blogging is keeping in touch with friends and acquaintances.

Blogging is good photography. Blogging is screencasts. Blogging is videos. Blogging is podcasts.

Blogging is learning the software necessary to produce your content, be it images, audio, video, or more. Blogging is knowing how to optimize content for delivery over the web.

Blogging is being happy enough with your work to share it, but unhappy enough to keep trying to improve it.

Blogging is targeting a niche. Blogging is ignoring potential audiences completely and publicly sharing your passion.

Blogging is learning to read statistics about your site’s visitors, whether for practical reasons or navel gazing. Blogging is analyzing your site’s traffic and working to improve the blog’s appeal or usefulness or advertising revenue.

Blogging is finding a way to monetize your hobby. Blogging is entirely personally driven, and need involve no monetary kickback at all.

Blogging is marketing your content. Blogging is trying to catch a lucky mention or link to swell your readership. Blogging is not giving a damn about whether people visit your site, and publishing for the sake of creating something interesting, public, and potentially useful for others.

Blogging is a hobby. Blogging is a job. Blogging is a passion.

Blogging is sharing something you have created online. And then doing it again tomorrow (or next week, or next month, or next year). And again.

Blogging is as varied as the people who call themselves bloggers.

I hope that Jalkut does in fact start such a site. Given the wide range of topics blogging encompasses, I suspect a properly moderated and maintained site focused on the act of blogging would be useful and interesting even to people who are already comfortable writing blogs, and as a purveyor of blogging software Jalkut is uniquely situated to benefit from such a site without needing to fill it with ads or articles focusing solely on monetization.

I first discovered Photoshop in high school when my friend showed me a doctored photo he had created, and it was a life-changing moment. Photoshop took something supremely boring to me (taking photos) and turned it into something supremely interesting (modifying photos in unexpected ways). Photoshop has enabled me to make countless websites, turn designs into reality, and just generally do awesome things.

But I will not be buying another upgrade, because I am sick of Adobe and their bullshit. I have grown increasingly disenchanted with Adobe for several years, but the last straw for me was my recent attempt to update to Photoshop CS5.

I have purchased the CS3 Web Premium bundle and the CS4 Web Premium upgrade, but since I barely use anything except Photoshop anymore I decided this time around to upgrade Photoshop only. I went through the Adobe store checkout process, ordered my CD, and it arrived recently.

When I went to install it, however, I ran across a hitch: the installer wouldn’t accept my CS4 Web Premium registration number as my license to upgrade.

Turns out that Adobe only offers upgrades on single products if you have purchased a previous version of that single product in the past. You cannot upgrade a bundled copy of Photoshop. Of course, they don’t tell you this anywhere in the store that I noticed while checking out.

So I’m done. I had been planning to upgrade Photoshop to CS5, and then likely the whole bundle to CS6 when it came out. After this little stunt on Adobe’s part, though, I think I would rather make a public promise not to spend money on Adobe software anymore. Adobe is a classic example of a company who doesn’t give a shit about their existing users, and I am fed up with it. I will make do with Photoshop CS4 and let them go alienate someone else.

The classic Adobe experience for me was when I was upgrading CS4. I called their sales number because the web store was being wonky on me, and the guy I got into contact with was great. Wonderful speaking voice on the phone, extremely helpful, clear, and concise. It was a great experience. At the end of the call, he transferred me to their technical support (I had some account management issues that he was unable to deal with), and I spent a good 45 minutes wading through the classic outsourced tech support experience. Low speaking voice, heavy accent, apparent inability to understand my non-accented English, unhelpful, and ultimately did not do what they said that they would to help me. That dichotomy stuck with me as the perfect example of how Adobe approaches its customers. If you are a potential buyer, they will treat you great. After the fact? You should consider yourself lucky that Photoshop crashes every time you quit, and leave them the hell alone.

I have tried writing to Adobe. It doesn’t work. The only thing that I can do is vote with my feet.

Good-bye, Adobe. For a company that made software that really lit a creative fire under me years ago, you certainly turned into a disappointment.

A friend recently linked to this comparison of IE 9 and Firefox 4, and I find these sorts of comparison interesting. The implied message, of course, is that Firefox is better because it supports everything and the kitchen sink, IE 9 is not a modern browser, and you should be using Firefox. Pretty predictable conclusion for someone with their content hosted at people.mozilla.com, but you could argue the data speaks for itself.

Yet as a web developer who has been observing the recent landscape of the latest incarnation of browser wars, I have to say: we as web developers and web users need Internet Explorer.

Not IE 6, of course. That shit needs to die, and the sooner the better. There is no excuse for someone still using a browser that old and insecure.

But in general IE, with its massive (if shrinking) userbase and slow acceptance of burgeoning web standards, is a good thing because it forces us to stop and think about what we’re doing. Web developers have a problem, which is they tend to want to jump on the latest developments as soon as a major browser offers them, and because two of the major browsers (WebKit/Safari and Firefox) are open source they often have bleeding edge functionality implemented before it’s even a twinkle in the W3C’s eye.

This is bad for several reasons:

• Early implementations are often confusing or poorly designed. Take a look at -webkit-gradient, for instance (the first available in-browser gradient syntax) and then compare it to Firefox’s implementation (which is the W3C recommended syntax). Firefox’s is legible, WebKit’s requires a documentation lookup every time you want to use it to try and remember what order all the darn properties go in.
• Differing early implementations mean that sometime down the road, someone is going to have to change before it can be accepted as a general standard. When web standards change, it breaks sites. Granted, WebKit will likely provide backwards compatibility for their gradient syntax, but for how long after they switch to the spec? At some point, if you have coded a site with WebKit gradients and forgotten about it, that site will likely break. Of course, IE doesn’t support gradients yet, which means that if you want to use them you’ll need to come up with a workaround for browsers that don’t support them, making your site not only backwards but forwards compatible.
• Web developers tend to forget how much hardware can matter. The other day, I create a CSS-only image zooming effect as a proof of concept. When I showed it to another developer, their comment was “Wow, is that slow!” For me, the transition takes less than a second, but because of hardware differences his experience was completely different. Yes, hardware affects everything, but considering that I can replicate the CSS transition in Javascript (which has been ruthlessly optimized over the years) without degrading performance on either end, Javascript is the clear better choice at this point in time.

The web moves fast. Open source browsers move fast. IE’s slow movement can feel frustrating for developers who see their lives getting easier thanks to improvements on the bleeding edge, but trust me: it is a good thing that Microsoft spends so much time considering what to include and what to exclude. Web developer’s lives may be a little bit more onerous now, but because we are forced to wait on irregularly implemented and insufficiently optimized new technology we end up creating sites that perform correctly for more people (and will continue to perform correctly for more years down the road), web standards have a chance to arrive at more elegant solutions than they would otherwise (making coding for those features when they are widely available far easier), and we web developers are reminded that what we see locally on our computer is not necessarily what the rest of the world will experience when they visit our site (leading to better tested and more resilient designs).

Firefox would prefer to reduce the argument over what constitutes a modern browser down to a list of bullet points because that makes Firefox look best, but to do so belies the greater picture. You wouldn’t want to drive a car with only an accelerator; you also need to have brakes.

Just sayin’.

(Author’s note: I wrote the bulk of this review two months after I picked up a Palm Pre, and then forgot it in my drafts folder. Now, days after Palm’s announcement of the Pre2 on Verizon and the Pre3 and TouchPad coming out in “summer” (probably six months out), I have rediscovered it. My opinions and feelings about the Pre, particularly as it compares with the iPhone, remain remarkably unchanged after all this time, so I have updated the review to be a bit more current with regards to the new HP/Palm ecosystem. I hope you enjoy.)

About ten months ago (or April 2010 for those who don’t like to cross-reference dates) and in the midst of the highest level of pessimism about Palm’s survival that had occurred to date, I went out and bought a Palm Pre Plus from Verizon to replace my iPhone.

“Wow,” some of you are thinking. “Why on earth would you do that? Were you taking stupid pills?”

No, the pills that I was taking were more commonly known as the “fed up with AT&T and uncomfortable with Apple’s increasingly closed environment” pills. A free dose came packaged with my vitamin supplements.

And it didn’t hurt that Verizon had too good a deal to pass up (free web tethering for the life of the device was something I couldn’t easily ignore, and the fact that a device with the same specs as the iPhone 3GS cost me a measly $50 was pretty awesome, too).

(Author’s note: as of this writing, the Palm Pre 2 is currently available on Verizon with the same free-tethering deal. I was tempted, but I’m holding out for the Pre3 which has far better promised hardware. However, for anyone who wants WebOS 2.0 right now, oh my god I can’t wait, that’s a surprisingly excellent deal.)

For those of you who enjoy digging into multi-thousand word product reviews, I’m about to make you very happy. If, however, you just want the quick and dirty version, well here it is:

The Palm Pre is physically smaller than the iPhone, and despite similar specs feels slower thanks to WebOS’s resource-intensive nature (likely exacerbated by the iPhone 4’s even better hardware, but I haven’t used one of those much in person). It is also a dream to use, has changed my entire conception of the ease of use of Apple devices, and continues to delight me on a day-to-day basis almost a year after I purchased it. Even with the iPhone recently released on the Verizon network and my dissatisfaction with HP’s handling of the future, I wouldn’t switch back.

Put that in your pipe and smoke it, Apple.

What makes a smartphone?

The smartphone market has been indelibly changed thanks to the iPhone, and I’m very glad that I used one for a while (although I was by no means an early adopter; I bought a used original iPhone when the 3G was announced). It’s not often that a product completely redefines a market in such a short time, and in the iPhone Apple definitely made good its reputation for creating visionary products.

Thanks to Apple’s influence, there are now four things that make up a quality smartphone:

1. Hardware; the phone itself
2. Operating system; the core software
3. Bundled software; what the phone can do out of the box
4. Apps; third party software for extending the phone’s functionality

(Used to be the only thing that mattered was hardware, and the software was always shit-tastic or crazy complex. Thank goodness we’re past that.)

A fifth item, the wireless network, is also usually a factor, but since we do not yet know what networks will support the Palm Veer or Pre3, I can’t really comment on it.

An overview of the Pre

It is safe to say that without the iPhone, the Palm Pre and WebOS would never have existed. It only takes a couple of minutes with the device to realize that it has been heavily inspired and influenced by the iPhone, both in the areas where Palm has imitated Apple and those where they have departed.

The Palm Pre Plus has roughly the same specs as an iPhone 3GS, but with a smaller screen and a WiFi mobile hot spot. If you care about that sort of thing, I encourage you to check out other Palm Pre reviews.

However, the form factor is quite different. The Pre is quite a lot smaller than an iPhone (both physically and in the size of the screen), but also thicker thanks to its slideout hardware keyboard.

The WebOS operating system also follows some very similar lines to iPhone OS, particularly where it comes to user interactions. You tap things to interact with them, flick the screen to scroll, pinch to zoom, and slide across items in lists to delete them. The biggest difference is the gesture bar below the screen where you have a small number of universal gestures that you can use to control the phone.

Hardware

The word I’ve seen used most often for the Palm Pre’s hardware recently is “aging”. When I originally wrote this review that was accurate; now it’s more euphemistic. The Pre 2 seems like a step in the right direction, but does not offer the amount of improvement that I was hoping for. The Pre3 seems like a much larger step in the right direction, but of course won’t be available for six months or so.

Despite the lackluster hardware compared to recent smartphones, however, I’ve still been very happy with my Pre Plus. At this point in its lifespan, the Pre isn’t going to make your jaw drop, but the form factor and hardware options have proven well capable of providing me with a good experience.

I don’t have the expertise to intelligently discuss things like the camera (which is the best camera in a phone I’ve used, but that’s not saying much), and I have no interest in quantitative testing of the other hardware specs. What I can say, however, is that the Palm Pre’s form factor is a refreshing departure from the blocky designs that have been running rampant in the iPhone and Android camps. At first I wasn’t sure if I’d like the smaller screen, but I’ve found that it’s worth it for the smaller form factor (which is a lot easier to carry around and manipulate with one hand than my iPhone ever was). I can see why Palm has stuck with the basic Pre design through three iterations of hardware with little deviation. The form factor is easy to scoff at if you’re used to a brick-shaped iPhone or Android, but the more you use it the more you’ll appreciate it.

I’m ambivalent to the Pre’s hardware keyboard. I like that the keyboard doesn’t take up screen real estate, but it also requires two hands to type anything. Additionally, Palm seems to have assumed that because they have a hardware keyboard they didn’t need to take as much care with their autocorrection system as Apple, which is a shame. In particular WebOS doesn’t have nearly as many corrections for mis-typing that occurs when you hit an adjacent letter instead of the one you’re going for, which is just as much a problem on the Pre as it is on the iPhone thanks to the tiny key size. I fortunately have pretty dexterous, slim fingers. Someone with large fingers would not be happy with this keyboard. Additionally, ten months into the life of the device some keys are starting to be unresponsive when I click them. This is a major issue, and annoys me almost every time I need to use the keyboard recently.

Although several of the Palm Pre reviews that I’ve read have mentioned build quality as one of the downsides to the phone, I personally have never experienced any problems (aside from the keyboard key issue I just mentioned). The keyboard slides out nicely and locks into place, the keypad is a pleasure to type on (when the keys function), and nothing is cracking or sliding out of alignment. Your mileage may vary, of course. Certainly you’ll have more risk of physical problems with the Pre than with a brick like the iPhone that practically doesn’t have moving parts.

Most of the Pre’s hardware may be losing its pizazz compared to the competition, but there are two areas where the Pre is flat-out fantastic even today.

First, the built-in mobile hotspot. It’s ridiculous how easy it is to turn your Pre into a wireless hotspot and use your 3G connection with whatever WiFi device you happen to have nearby. The mobile hotspot functionality is a fantastic confluence of hardware and software; it just works right out of the box. With AT&T still floundering about trying to figure out its data plan and tethering support options, the mobile hotspot functionality of the Pre is a great reason to buy the phone all on its own.

Second, the Touchstone wireless induction charging station. It may have cost as much as the phone, but this has literally changed my life.

You may not realize it, but if you are currently using an Apple iDevice you are shackled to your desk. In order to charge and sync an iPhone you have to plug it in, wait for iTunes to start up, sit through the synchronization process (which can take a while, given the need to back things up), and then wait for the thing to charge. This seems like a small thing if you aren’t used to anything better, but it’s not. This is a huge amount of headache for a device that doesn’t need wires to function at all.

With induction charging, I set my Palm Pre down and it starts to charge. When I need it, I simply pick it up. It synchronizes contacts, calendars, and so forth wirelessly over the 3G connection (or wireless, if available), and backs the phone up the same way (this is through the “cloud”, folks; no need to have my computer on, be on the same network, or any of that rigamarole). The only time I have to physically plug the thing into my computer is when I want to transfer music onto the phone or video off the phone.

This is the way things should be (actually, it should wirelessly sync music through my local WiFi network, too, but whatever). When I finally caved and bought an iPad, it felt like a huge leap backwards to boot it up for the first time and see an iTunes logo with a USB cord image staring me in the face. The Palm Pre is the first wireless device that I’ve owned that is truly wireless with all the headache relief that entails.

The operating system: WebOS

Quite simply, WebOS is why you should be using a Palm phone. Their hardware is adequate but mostly subpar compared to the competition (with the exceptions I noted above), but WebOS is fantastic. I have no regrets abandoning iOS for WebOS.

Of course, things are not all sweetness and light. WebOS uses HTML, CSS, and Javascript to power its apps and because these are all high-level interpreted languages the operating system requires much more raw power to perform up to speed. Compared to the iPhone, the Palm Pre feels slower and less responsive, particularly when scrolling. How unresponsive will vary depending on how many apps you have running at once, but even when I only have one app open scrolling doesn’t feel as immediate as it does on the iPhone because the page simply doesn’t keep up with my finger in the granular way that iPhone scrolling does. There’s often a slight delay, or the page will scroll slightly out of sync with what my finger is doing (either dragging a little bit behind, or moving a little too far after I let go). If you’re very quickly flicking through a long list, things behave about as they do on the iPhone, but as soon as you start dragging slowly to scroll a little bit at a time you’ll start to feel the difference.

Additionally, the use of the gesture bar below the touchscreen has its bad points. For one thing, there isn’t a whole lot of feedback when you successfully perform a gesture. Sure, the lights in the middle are supposed to flicker, but sometimes I’ll perform a gesture, the lights will flicker, and nothing will happen. This can be frustrating, since without visual feedback the whole gesture idea crumbles a bit.

The second downside of the gesture area is that it makes it more difficult to use the phone initially. On the iPhone, any idiot can use the thing because everything you want to do is staring you in the face. Want to go back to the previous screen? Tap the Back button. Want to close the app? Click the home button. It takes maybe thirty seconds to a minute of playing with an iPhone to figure all that out through straight trial and error.

Picking up the Palm Pre, however, takes a little more learning because there is never a back button: instead you have to know that swiping from right to left on the gesture area will perform the universal “back” gesture. Granted, there’s only two gestures that you need to know to get up and running, but this still provides a steeper learning curve than the iPhone, and it’s highly unlikely you’ll discover the gestures on your own without prior knowledge.

Of course, the plus side is that once you’ve learned the gestures, life improves drastically. Having a universal back gesture means that apps never have to complicate their interfaces with back buttons leaving you with less visual clutter in your apps.

The last major downside of WebOS is the text editing. I’ve already mentioned the less-robust autocompletion engine in WebOS compared to iOS, but cursor placement and text selection is equally frustrating. Like on the iPhone, you tap to place the cursor. However, if you then want to move the cursor (because your relatively huge, inaccurate finger placed it a character or two away from where you wanted) you have to hold down the symbol key and drag anywhere on screen except on top of the cursor. This is fantastically frustrating for several reasons:

• First, you’ll never discover this on your own. I noticed when I pressed the symbol key that the cursor turned into an arrow, but had to go digging through the documentation to figure out what this even meant.
• Second, this interaction removes all of the immediacy of touch. I may as well be using arrow keys on a keyboard (in fact, I’d prefer that, because then at least it would be accurate). On the iPhone I tap and hold to get a magnifying glass that shows me exactly where the cursor is under my finger. This is far more efficacious than dragging around on an unrelated part of the screen and watching a little compass rose jump around.

Similarly, if you want to select text you have to hold down the shift key and drag on screen somewhere away from the cursor. I inevitably find myself overshooting, unable to get the selection to encompass the right characters or lines. And heaven help you if you try to drag the actual cursor. You won’t be able to see what you’re doing, and half the time it doesn’t do anything, anyway.

On a different note, one of the best parts of WebOS is the card-based multi-tasking metaphor. iOS pseudo-multitasking (which I’ve been using on the iPad for several months) doesn’t hold a candle to WebOS. Palm’s multitasking is immediately obvious, elegantly easy to manipulate, and places more power and choice in the user’s hands. After using my Pre for about a week, I booted up my old iPhone to do something, and found myself trying futilely to perform the upward swipe to get to the card view.

Additionally, although the “swipe upwards” gesture to access the Launcher (where your app icons are stored) is hard to discover, I love the launcher itself. Yes, it would be nice to have more than three pages of apps, but I have found that practically I only use about as many apps as fit comfortably into three visible pages, anyway, and scrolling to the others isn’t a big deal. What’s great about the launcher is that it doesn’t clutter up your phone with icons. iOS devices now feel incredibly busy to me, with every screen having apps screaming “use me, use me!”. On WebOS, apps are there when I need them, but by default I get a beautiful (and clean) desktop image.

As a former iOS user, WebOS’s notifications system was another breath of fresh air. Notifications slide quietly up from the bottom of the phone and wait there until you wish to deal with them, allowing applications in the background to inform you of whatever without interrupting your current task. Thanks to WebOS’s true multitasking, some apps do not even need to be running as a card to post notifications (the email and SMS clients are great examples of this) or are capable of running solely in the notifications area. This is worlds away better than iOS’s modal dialogs and icon badges, and I would be hard-pressed to go back.

Another standout feature of WebOS is Synergy. Synergy on a WebOS phone means that you can log into several web services (like Gmail and Facebook) and have your contacts downloaded, synched, and intelligently merged together. So if your Gmail account has your friend’s email, and your Facebook has your friend’s phone number, Synergy knows to combine them into a single person with all of that info available. That info can then be extended by third party apps, or used within third party apps (with your permission, of course).

There are lots of other great little touches in WebOS compared to iOS, as well (dropdown menus that don’t necessitate jumping onto a new screen, a universal menu with battery info and a shortcut to turn on airplane mode, app menus so that common things like preferences don’t have to take up screen real estate all the time, and more). Suffice it to say that WebOS is hands down the best reason to consider migrating from an iOS device to a Pre.

Bundled software

Not much to say here, really. The email, calendar, and contact apps are excellent (particularly with their synergistic sharing of Google logins, for instance). Apps like Tasks or Memos are visually appealing, but almost completely useless. The music playing app words great, except that you cannot create playlists, and other apps like the browser, videos, and Google Maps apps are competent but nothing to write home about.

As I mentioned above, the wifi hotspot app is shockingly easy to use, and a good example of an app that Palm got exactly right. My only quibble with it is that it does not give any indicator for how much bandwidth I am consuming (but then again, neither does Verizon; wouldn’t want me to know if I’m likely to be charged for exceeding my limit, would we?).

The third party question: apps

I have mixed feelings when it comes to the apps on WebOS. On the one hand, I am now able to code apps to meet my own needs, something that I never felt capable of doing on iOS. On the other, the app catalog has relatively few standout third party applications, and finding the good ones amidst the dross of sound effect apps, one-off ebooks, wallpapers, and ringtones is challenging at best.

Fortunately, with the help of third party apps I am able to do everything I needed to do regularly on iOS (like check bus schedules, access visual voicemail, use Twitter, and so forth). However, a number of the third party alternatives are not as appealing as their iOS equivalents, or just flat-out don’t work as well. A good example is the visual voicemail client, which cannot play audio through anything but headphones or the speakerphone thanks to limitations in the OS, and is generally a lot less aesthetically pleasing than anything Apple has produced. Another thing I miss: although wholly functional, none of the RSS readers are remotely as awesome as Reeder or numerous other iOS RSS alternatives.

When you come down to it, I cannot recommend WebOS based on its existing third party apps. I think this is likely to change (and if you are a developer and willing to roll your own solutions, it’s a great development environment), but right now the app scene is nowhere near as exciting, vibrant, and interesting as the iOS app store. If you are trying to figure out if switching from iOS to WebOS is viable for you, definitely take a long hard think about exactly what apps (or features of apps) you would find a hard time living without and check to see if an equivalent exists before you jump ship.

The final verdict: is it worth it?

I must admit that—despite my incredibly positive experiences with the Palm Pre Plus—at this point in time it is likely not worth buying a Palm Pre. If you absolutely must have a new smartphone, and don’t mind missing out on the promised awesomeness of the Pre3, then a Pre 2 might be an excellent investment (particularly with Verizon’s free tethering deal) as long as knowing that next-generation hardware is just around the corner does not rub you too raw.

On the other hand, if you are going to be in the market for a new smartphone within six months or so, then a Pre (or its little sibling, the Veer) will be well worth your attention. Announcing their hardware so far in advance was a pretty dumb move on the part of HP in many ways, but the positive side of it is that we know that their upcoming phones at least have some exciting features (how they stack up with their competition when they are finally released I leave to you to discover, although I suspect given the historical rate of change, at least WebOS and iOS will remain similarly matched).

The bottom line for me is that I have loved—and still love—my Pre Plus on Verizon. As a developer, I am not very happy with HP’s handling of upcoming changes to WebOS and their devices, but as a user and iOS-switcher I am far more optimistic. We will see if HP delivers on the promise of their recently announced hardware and software changes, but in the interim I am more than happy to continue using my Pre Plus.

I recently told a follower on Twitter to send me an email, and helpfully included the email in the tweet. I thought little of it; this is an email address that is published in plain text online because I want people to be able to find it easily. I am well aware that it will eventually get harvested by spammers, and as a result have multiple levels of spam detection software running on the address.

Moments later, I receive an email:

Dear ianbeck

We have found that your email is shared in tweets. We advise you to hide your email from spammers by sharing email address as an image or hide it behind a url.

Visit us at : [REDACTED] to find how you can do this.

Happy Twitting !!!
“2 million emails are sent every second. About 70% to 72% of them might be spam and viruses.”

(I’m a little sad that the web doesn’t let you see all the lovely extra spaces in the message, too. It is truly a work of negative-space-leveraging art.)

I was curious how you would classify this email, and Wikipedia provided a concise definition:

E-mail spam, also known as junk e-mail or unsolicited bulk e-mail (UBE), is a subset of spam that involves nearly identical messages sent to numerous recipients by e-mail

This message is unsolicited email. Based on the format of the email, it is apparent that they are sending this nearly identical message to numerous recipients.

So why would I trust a spammer to protect me from spammers?

Oh, right, I wouldn’t. Blocked and reported for spam.

The ways that people find to abuse Twitter never cease to amaze me.

Incidentally, I have just finished twitting the fools who sent this email. Had I posted to Twitter instead, I would be “tweeting”. Words matter, people. Even if you’re a sleazy spammer.