Nokia 5800 Review

There’s quite a bit to like about the Nokia 5800:

• compact size, low weight
• good call quality
• over-the-air software updates
• good web browser
• high resolution screen
• good music player (you need to transfer the music directly to the card)
• good battery life
• 3.5mm headset jack
• acceptable E-mail client, minimal podcast client included
• Google Maps works well
• works flawlessly as a 3G tethered modem
• great speaker

So, it’s a useful, nice phone out of the box.  However, it doesn’t even get close in terms of functionality or extensibility to something like the iPhone or an Android phone.  Here are some problems:

• inconsistent, at times incomprehensible user interface
• inconsistent scrolling methods (scrollbar, dragging, work opposite ways)
• synchronizing contacts and calendars is manual and requires many clicks each time
• apps run in the background by default, running the phone out of memory
• almost no useful third party apps for S60 for the 5800
• many existing S60 apps don’t work or work poorly
• bad lookup method in the contact manager
• applications constantly ask for permission to access the network; this can’t be disabled
• the chat client is still useless
• the on-screen keyboard is as bad as the iPhone’s (but the plectrum actually helps a little)
• poor quality camera
• no USB charging
• Nokia’s Multimedia Transfer software for OS X transfers music so slowly that it’s useless
• Google Mail app works poorly

These are the usual problems of the aging Symbian “smart phone OS”.  Touch makes dealing with some aspects of the awful Symbian UI a little easier (e.g., you don’t have to scroll through useless menus anymore in order to dismiss them, you just touch them), but at the cost of incompatibilities and cumbersome text entry.  Overall, given the tiny collection of usable S60 applications, the Nokia 5800 is, for practical purposes, not a smart phone, but it’s a “dumb phone” with nice hardware and a limited OS.

I don’t see Nokia getting out of this mess either.  Instead of partnering with Google, Yahoo, Facebook, TomTom, and Amazon to provide kick-ass applications for chat, mail, sharing, social networking, navigation, e-books, and on-line music, Nokia is trying to do it all themselves with Ovi.com, and they are failing miserably.  Nokia knows how to make great phone hardware, but they don’t know how to make good software or user interfaces, and they have a serious case of NIH.

In the end, the Nokia 5800 is going to be the phone I use with my prepaid card, and it’s probably going to be the last Nokia phone I’m going to buy.  Android is simply a far better smart phone OS than Symbian.

My advice to Nokia: make a clean break, retire Symbian, and switch to Android.

Whither Python?

Background

I’m a long-time Python user.  I switched from Perl and Tcl, and Python was a much better language.  Of course, it always was no more than a simple scripting language; even when Python was created, people already understood how to build high performance dynamic languages (like CommonLisp and Smalltalk), but those other languages didn’t take system integration and libraries very seriously.  As a scripting language, Python is nice, but what really has made it attractive to many people in recent years is NumPy, the only really credible open source alternative to Matlab.  Python is much better than the Matlab interpreter.

Python 3

A new version of Python, Python 3, is just coming out.  Unfortunately, there have been a bunch of technical decisions that I think seriously hamper the future of the platform:

• Python 3 has now sanctioned the use of malformed Unicode.  That is, standard Python library routines can return malformed Unicode strings, and standard Python library routines for UTF-8 conversions will turn these into malformed UTF-8 encodings.   Nobody knows what exactly the consequences of sanctioning and introducing malformed Unicode and UTF-8 into Python has, but it’s clear it will make debugging Unicode issues harder, introduce incompatibilities with libraries, and probably create security problems.
• Python 3 still retains a global interpreter lock (GIL).  A GIL makes it effectively impossible to write multithreaded Python code.  Guido van Rossum, the project lead, believes that this is not a problem, and that multiple processes provide adequate means for taking advantage of multiple processors.   Since multithreading is hard to do well, this is a convenient belief.  It used to be a common view on UNIX, for the Apache web server, for C/C++ programming, and many others.  Most of those eventually came around to offering threading even before the advent of multicore machines.  Now that almost every new desktop and server is multicore, multithreading is essential for taking advantage of those cores in many applications.
• Calling C/C++ from Python remains tedious.  That’s actually not Python’s fault (Python is better than other scripting languages), but it’s still a limitation.  What is a problem is that there are so many choices for foreign function calls, none of which really gets the job done completely.  Among other things, there are swig, sip, boost::python, cython, pyrex, psyco, and ctypes.

An Alternative

The Python developers have invested a lot of effort into updating the Python byte code interpreter (“C-Python”) as part of the Python 3 release.  Furthermore, all the issues mentioned above (and then some) are shared by other major scripting languages: Perl, Ruby, and Tcl.  The only scripting language that relaxes the GIL slightly is Lua, which allows multiple concurrent interpreter instances.

However, there are two significant alternatives available for running Python: Jython and IronPython.  Jython is based on the Java JVM and IronPython is based on the Microsoft CLR.  Jython, unfortunately, inherits some limitations from Java, but IronPython is worth looking at.

IronPython+CLR is mostly compatible with Python+C-Python, and it functions the same way: Python is compiled into byte code and that is then executed by a virtual machine.  The IronPython virtual machine, however has several advantages:

• There is no GIL; IronPython is fully multi-threaded.
• IronPython is automatically JIT compiled and somewhat faster than C-Python.
• There are large numbers of pre-existing libraries available on the CLR platform, including GUI libraries and bindings to many standard open source libraries.
• IronPython inherits consistent Unicode support from the CLR and its libraries.
• The CLR has an efficient, well-supported foreign function interface.
• The CLR provides easy interoperability with many CLR languages.

Technically, it is difficult to see why Python 3 bothers with implementing a Python-specific virtual machine.  Practically, there are still a number of reasons why IronPython isn’t taking the world by storm.  The first is probably the fact that the CLR is tainted by its association with Microsoft; although there is no evidence whatsoever of any patent issues, fears and rumors that Microsoft can shut down any open source use of the CLR persist.  In addition, although Python 3 will require significant work for porting extensions to it, that is likely still less work than porting those extensions to the CLR (however, tools like IronClad may help).

Conclusions

Python is still one of the best scripting languages out there, and NumPy still beats Matlab handily.  However, Python is also not advancing very well: the GIL, Unicode incompatibilities, and FFI have been issues for ten years, and rather than fixing them, the Python developers are just redefining them to be features and telling people to live with them.

IronPython running on the CLR may be a reasonable migration path for existing Python users (like myself), since it addresses many of the shortcomings of C-Python.

Unicode in Linux

Since there was a long discussion of Unicode and Python (with the, in my opinion, unfortunate outcome that the Python 3.1 specification explicitly allows the generation and use of malformed Unicode strings), I was thinking a bit about where I think Unicode is going.   Here’s my predictions for Unicode, Linux, and Python.

I think Unicode support in FOSS and Linux is in flux right now.  I expect that in 1-2 years, all Linux distributions will enforce UTF-8 file system encoding by default, and many “char*” interfaces will be redefined to take UTF-8 encodings, because that’s backwards compatible at the API level.

I suspect that for non-UTF-8 file systems, Linux desktop environments will probably sample the paths on a file system first to guess at its encoding before mounting it, maybe with a “safe” (in a certain sense) system-dependent fallback (iso8859-15 or so), so that things just work almost all the time.  Internally, libraries will probably use UCS-4 or UTF-8, depending on space/time tradeoffs.   PEP 383 will probably be pointless before Python 3 even is widespread.

UTF-8 and UCS-4 conversion routines will vary, but I think many of them will be picky about any non-conformant inputs, because debugging Unicode issues is hard enough without having to deal with “lenient” implementations.  They’ll probably not only check on conversion, but also start checking whether any UTF-8 inputs they get are valid, even if they don’t decode them and just pass them on.  It’s good software engineering, and it reduces bug submissions (“you gave a bad UTF-8 string to the library” is better than “the library gave a bad UTF-8 string to some other library”).

UTF-16 will probably just fall into disuse in the UNIX world.  Windows will be stuck with it, and 16 bit wchar_t, and a separate set of byte APIs, and it will probably also be stuck with a lot of programs that mistakenly treat UTF-16 like UCS-2.  Fortunately, only the Chinese will suffer from that, but they are responsible for this mess (and they are used to suffering).

HP DV2-1030US with Ubuntu 8.10

The HP DV2 is a lightweight (3.8 pounds), fairly low-cost 12″ laptop with a great keyboard, a sharp screen, and plenty of ports (VGA, HDMI, 3xUSB, Ethernet).  Its main limitations are a fairly short battery life (2.5h) and a CPU that is somewhat slower than Intel Core Duo machines.  The machine also comes bundled with a USB-based DVD burner.

The Windows Vista installation that shipped on the machine didn’t work properly.

Ubuntu 8.10, on the other hand, works correctly out of the box:

• audio: OK
• WiFi: OK
• video: OK
• suspend: OK
• CPU frequency scaling: OK
• built-in camera: OK
• accelerated video: OK (selecting ATI driver under Ubuntu)

I haven’t tested Ethernet, Bluetooth, or external displays yet.

Pre-release versions of the Ubuntu 9.04 installer do not boot properly, but that will hopefully be fixed by the time 9.04 is released.

Additional comments after using the machine for about 10 days:

• the wired Ethernet is working properly
• projectors on the external VGA connector are not recognized
• CPU frequency scaling is not working reliably after wakeup
• very occasionally, after waking up from sleep, the disk drive does not respond anymore
• the machine doesn’t have an internal Bluetooth

There is a BIOS update available; I will give that a try and see whether it fixes some of these problems.  Except for the external VGA, these are quite minor for me.

Additional comments (4/30/09):

• booting 9.04 from USB sticks and CD-ROM is apparently possible by using debug=mount during boot and unplugging & replugging the boot device
• I upgraded the 8.10 installation to 9.04 and the upgrade worked without problems
• external VGA works after booting with a monitor plugged in; it continues to work after suspend and can be configured via ATI’s tool (automatically included in 9.04); I don’t know yet whether, after being configured, it works even when booting without an external monitor and then later plugging in the monitor

Dell Mini 12

Good Points:

• great screen
• slim, lightweight
• ships with Ubuntu pre-installed; everything works
• boots and works fully with Ubuntu 9.04 out of the box
• relatively inexpensive for a 12″ laptop

Bad Points:

• lousy keyboard: bad keyboard pitch, bad placement of “/” and “\” keys
• although it ships with a full version of Ubuntu 8.04, it doesn’t point at the standard repositories, so the only way to upgrade it is to reinstall from scratch (and you can’t install 8.10)
• bad battery life (less than 2h with the standard battery)
• fairly slow (slower than an ASUS EEE 1000 or an HP 2133)
• the default desktop attempts to run every application maximized, which doesn’t make sense on such a large screen (fortunately, it’s easy to disable)

Altogether, the Dell Mini 12 is not a bad netbook, and it’s the only one in its class with a 12″ screen.

But Dell kind of screwed up the design, in particular the keyboard.

Google G1 Phone running Android

I recently received a G1 phone running the developer version of Android. Here’s a micro-review.

Good:

• Software
  • Nice, intuitive user interface.
  • Easy software installation through Android store.
  • Already good selection of software.
  • Non-store software installation easy with packages.
  • Good, intuitive use of hardware keys.
  • Great set of pre-loaded applications: Google Mail, Google Maps, IMAP/POP Mail, Google Talk, YouTube, etc.
  • Excellent web browser.
  • Intent- and Activity Focused User Interface
  • Good access point management (compared to Symbian, which constantly asks about which AP to use)
• Hardware
  • Good screen.
  • Good keyboard.
  • Lots of functionality (Bluetooth, Wifi, GPS, accelerometer, 3Mpixel camera)
  • Good keyboard.

Bad:

• Software
  • Multiple Google account management (Google Mail for Symbian handles multiple accounts, Google Mail for Android does not)
  • Too many ways of arranging applications on home screen (left and right slides, folders, pull-up window).
  • Limited network configuration options.
  • No tethering support, no Wifi/3G gateway support (apparently).
  • No soft keyboard (but will be supported soon, through firmware upgrades).
  • Picasa support could stand improvement (e.g., automatic syncing of pictures).
  • Needs a note taking app.
  • No turn-by-turn navigation app (yet).
• Firmware / Drivers / Kernel / Hardware
  • No 3.5mm headphone jack.
  • Headphone jack shared with USB connector.
  • No USB master connection (but few phones have that).
  • Pitiful battery life.
  • 3G is unreliable and takes a long time to connect.
  • No 3.5G support.
  • WIFI/DHCP bugs (keeps requesting new leases and exhausts DHCP servers quickly)
  • Less comfortable to hold and use, less convenient control layout, than the Danger Hiptop.
  • “Bent chin” makes the phone thicker than it needs to be and gets in the way.
  • Trackball is too fiddly and sensitive to make selections with easily.

Overall, I think the Android team did an excellent job on the software; it’s the hardware that makes this phone less than stellar. On Nokia E71, Nokia 5800, or iPhone hardware, this would be an outstanding phone.

I think one can live with this phone, and it’s probably a good choice for new users, since the G1 is so much easier to use than other smart phones from Nokia, Microsoft, Palm, or Apple. Yes, that’s right, the G1 is enormously easier to use than the iPhone because it synchronizes fully over the air, while the iPhone needs to be synced with a desktop.

If you already have a smart phone, I suggest waiting maybe six months; Android will then be running on a lot of other hardware, and the few remaining software kinks will have been worked out.

Nokia E71 Software Upgrade

Just a quick note: Nokia recently released an E71 firmware upgrade, from 1.x to 2.0.

Prior to this upgrade, the camera had developed excessive delays between pushing the shutter button and taking the picture (somtimes 15 seconds).  With the new firmware, the camera works as expected (although the quality is, of course, still quite limited).

The phone generally also seems to perform significantly better and be more stable with the firmware upgrade.

iPod Touch Review

iPod Touch

The iPod Touch (and, by extension, the iPhone) is a frustrating beast: on the one hand, Apple has gotten a lot of things right, yet their corporate strategy is spoiling the whole experience.

So, what does the iPod Touch get right?

• great screen
• fast response
• easy software installation
• great industrial design
• decent desktop integration, if you use Apple’s approved applications
• development tools that help average developers develop decent applications

What does the iPod Touch/iPhone get wrong?  Plenty.

• text input Text input on the iPod is a pain; it requires constant attention to the screen, lacks any kind of tactile feedback, and is generally slow and unreliable.
• synchronization Out of the box, the iPod Touch/iPhone only synchronizes to your desktop; that’s so 1990’s. Synchronization is slow and buggy.  Apple’s productivity applications manage to be even more limited than the Palm desktop of yore, but, of course, they look a whole lot nicer.
• software The default set of applications that ships with the iPod Touch/iPhone is oddly limited: no iChat, very limited functionality in applications like the photo browser, no terminal, limited Bluetooth support (e.g., no external keyboards).
• third party applications It’s astounding how many third party applications have been created for the iPod Touch and the iPhone in such short time, but Apple’s restrictions hamstring many of them: WiFi browsers can’t connect, ebook readers can’t communicate and share data, SyncML software can’t synchronize the calendar, etc.  Basically, Apple tries to restrict anything that could compete with iTunes or MobileMe.
• no Java Mobile Java applications are often ugly, but there are some gems out there, as well as plenty of good games.  Apple’s restrictions on Java are pure corporate greed.

Between the numerous bugs and numerous restrictions, I think it’s a bad idea to buy an iPhone right now: you’ll be locked into a long term contract with a device that may turn out to be too buggy to be useful.  The iPod Touch may be a good choice, though: you can run most of the applications and you aren’t tied into a contract.  I

EEE PC 1000 (40G)

EEE PC 1000 (40G Linux)

I travel a lot and I write a lot, so a very portable machine with great battery life is important to me.  The MacBook Air has some appeal (nice keyboard, nice screen), but its price, size, limitations, and operating system make it a bad choice for me.  The EEE PC 1000, however, fits the bill exactly.

Pluses

• good keyboard, good screen (1024×600 is about right for the 10″ screen)
• great battery life (>4h with standard battery)
• quiet
• runs Linux
• hardware with open source drivers (meaning, you can run other distros)
• lots of easy-to-use applications included out of the box, simple launcher
• plenty of ports, including VGA and 3x USB
• graphics card powerful enough for Compiz

Minuses

• Xandros is a bit limiting for power users (Asus should offer Ubuntu instead/in addition)
• 1024×600 screen makes presentations a bit awkward (support for virtual 1024×768 would be good)

Nokia E71

Nokia E71 (US)

I’ve had a chance to use the Nokia E71 for a few weeks.

Pluses

• the hardware is great; in particular, the phone has a very nice QWERTY keyboard, A-GPS is very fast, there is 3.5G support, and the phone is very small
• more buttons are user-remappable
• responsiveness is much improved over previous versions of Symbian phones (probably due to a faster processor, rather than software improvements)
• the phone seems less buggy than, say, the N82; in particular, the web browser works better
• there is lots of third party software, including Google Maps, ShoZu, Skype, Slick, Putty, MobiPocket, and more
• there’s no need to synchronize with the desktop; everything can be done over the air
• like all Nokia Symbian phones, works like a tethered or Bluetooth modem

Minuses

• the Symbian user interface and menu system is as convoluted and unintuitive as ever
• the phone still only has a 320×240 screen
• the 3Mpixel camera produces pretty lousy images
• no mini-USB connector, no charging through USB, and no 3.5 mm head phone jack
• Nokia wants lots of money for a navigation application (but basic mapping is free)

Overall, I think it’s a more practical phone than the iPhone and the hardware is better.  The keyboard and modem capabilities alone would be a deciding factor.

I think the E71 is probably the best overall smart phone you can get right now.  Unfortunately, that’s only a guarded endorsement because the standards are so low.  Nokia has their work cut out for them in terms of improving the user interface and making the platform easier to program; Google’s Android looks superior on both counts right now, and when Android-based phones come out, they will be a serious threat to Nokia’s Symbian platform.  Maybe what Nokia really should do is join them rather than fight them because Nokia hardware is great.