My initial impression is good. After a bit of difficulty related to the new App World 3 (I recommend sticking with v2 for now), my data and applications are restored and I am chugging away.

The keyboard

While most smart phones now use soft keys, I still prefer the Bold’s hardware keyboard. Those who share the preference will absolutely love the new Bold’s keyboard. For one thing, it is larger and wider, with a slight curve, making it easier to reach the keys on the outside. It feels very nice to use as well. Many will scoff, but I think that this is just about its most attractive feature; after all, the keyboard is so integral to the Bold experience that it makes a disproportionate difference in the “feel” of the phone.

Touch Screen

The touch screen is pleasantly surprising. The screen itself is crisp and bright, and very touch responsive. I was not a big fan of the new layout on OS 6, but with the touch screen it is quite easy and even efficient to use.

The screen is also slightly larger with a better resolution. Users of the Torch or other smart phones won’t see it, but Tour/Bold and Curve users will appreciate the boost in screen real estate.

The OS

OS 7 deals with most of the issues I had with OS 6. It is much faster, in part due to the new phone’s hardware. Transitions and effects are now hardware-accelerated, reducing the time (and power) required to process them. Not only is it faster than the slow, bogged down experience I had with OS 6, but it is snappier and more responsive than any BB I have owned to date. Even the Desktop-based interactions, like backups and sync, are much faster.

Additionally, universal search is faster and indexes much more quickly. Once painful to use in OS 6, it is now the fastest way to find applications and messages.

Battery life

Blackberry has always been king of battery life. No other smart phone ever comes close to a BlackBerry, and that has traditionally been one of the (extremely few) advantages of shipping much slower hardware.

That said, the new Bold has a smaller battery than my last Bold (the 9650), but appears to last every bit as long. Whether it is due to efficiency gains in the software or the faster hardware, it has made a difference.

It is not intuitive, but just as a heavier vehicle will use more gas with an under powered-engine, software can draw a lot of power when the hardware cannot keep up. This is especially true of embedded programming, where the environment places such constraints on resources. My suspicion is that the combination of GPU-accelerated graphics and better reception are helping to keep the OS from pegging the CPU so heavily. In any case, it is a welcome enhancement.

The ugly

I still can’t send pictures or video directly from the browser. You can only send or post a link, or go to the trouble of saving the file, sending it, and deleting it. I would not think it should be too hard to add this feature, and a number of folks miss it. It is one of those “super app” features that make BB pleasant to use. It saves time by linking apps tightly.

Conclusion

If you have been hanging onto your old Bold or Tour because of OS 6, now is the time to upgrade. It is well worth the money (to me, anyway) to get the new Bold 9930. it is everything I had hoped that my last phone would be, and BB users are going to love it. It is good to see RIM roll with the punches and get back up again.

Submit article

It feels pretty top heavy, though. I think they tried to bolt the QNX UI on top of BB OS, but without the power and efficiency underneath the hood to make it perform adequately on my handset. The 9650 seems high end for OS 5 but low end for OS 6. Some of the rendering, smooth scrolling, and transparency effects really bog down the system, at least on the 9650’s hardware.

The only other real problem I have with it is that it is missing a feature I really like from OS 5 – the ability to send a picture via MMS directly from the browser.

For a while, I used an OS 5 theme which eliminated many of the more expensive UI elements, like app tabs, but at some point I lost the ability to use themes, even after a clean install.

So for now, I’m back to OS 5, and my phone is much snappier again. Oh well. Better to be a big fish in a little pond, I suppose.

Submit article

The Playbook has suffered from a rash of poor reviews, largely due to the lack of apps and RIM’s decision to release without  the native PIM suite ready. These things obviously detract from the experience, especially the absence of email and messaging software.

I try to take the long view, though. This is a brand new tablet platform, and software environment will eventually get a complete host of apps, some useful, some not, just as is the case with the Apple app store as well as the Android marketplace. For the moment, though, it is mostly filled with what appear to be very mediocre experiments with the platform. Very few are worth the money at the moment.

The system is very slick, though. The navigation becomes very natural with very little effort, and the browser is lightening fast. The bridge functionality is excellent, although it will frustrate the unenlightened (read: non-Blackberry users) that it requires a Blackberry hand set to use.

Bridge is extremely cool. It gets overlooked as a stop-gap until RIM releases the official, native PIM, but it gives Blackberry users something important that a more typical suite might easily overlook. Messages are pushed to a Blackberry, rather than synchronized, as is the case with IMAP. Bridge maintains control over those messages on the hand held, rather than the tablet. That’s the right way, because a phone is going to stay with you much more than a tablet (new toy syndrome notwithstanding).

Bridge gives me an extra piece of awesome, too. The Bridge Browser, while not running at native speed, provides a decent web experience without tethering charges. That not only saves me money, but it keeps me feeling young by letting me pretend that I am sticking it to the man, and you just can’t put a price on that.

Therefore, I really hope that bridge is not condemned once RIM releases their PIM suite. I really want to see them add to it and give it the polish that RIM is so good at. I hope it continues as a special extra for BB users, and becomes fully integrated, which is one of the major areas of polish were RIM lords it over the competition

On another note, I also very humbly ask that whoever is in charge of the keyboard make it behave exactly as it does on my Blackberry. I am tired of having to type apostrophes and capitalize with a separate button, thank you very much.

Submit article

Hacking Vim bills itself as a recipe book. While it provides quite a few good ones, it seems to be organized more like a tutorial, using the examples to walk through some of the cooler features of vim. That said, the recipes it provides are very useful and a good number have made it into my ~/.vimrc.

I found some examples to be overly contrived. The author could have done a better job relating samples to real-world situations. I also wish it had gone into more depth when explaining some examples early on. If you don’t skip ahead and read the section on vim scripting (or know it already), there are a few traps in the examples.

For all that, though, my now heavily dog-eared and ruffled copy was well worth the money. Like other books from the same publisher, Hacking Vim stays on subject, maintaining its focus and pragmatism. Definitely a good source of worthwhile tips.

Submit article

I have to admit that I occasionally resort to goto myself. This week was one such an occasion. But before you pick up your torch and farming implement of choice and join the mob heading for my castle gates, please consider that  Dijkstra’s letter was complaining about unrestricted goto, which was a popular feature of languages at the time. It was an unstructured precursor of the subroutine and structured programming, which put goto on a leash and taught it not to bark at the neighbors. In restricting goto to local jumps, as most modern languages supporting the feature do, the beast became much less fearsome. In fact, a while loop is just a structured goto, as is try/catch (albeit with a little extra magic.)

Perl, of course, does not impose such restrictions on a programmer (although it does prohibit jumping into blocks that require initialization, such as other functions.) With a little discipline, though, goto is a feature and quite useful. It can be used to make extremely complex loops explicit and easy to follow as well as allow a loop to break to any outer loop in the current call stack.

As an example, I recently wrote a function to increment a string of arbitrary alphanumeric characters, where letters must maintain their case but increment as base-26 numbers and numbers increment normally (base 10). For example, if a letter increments past z, it becomes a and the next character to the left is then incremented. The increment logic fit into a function that took two of these strings and calculated all possible values in between to support some limited set operations against two alphanumeric ranges.

My original code for the increment logic was grisly at best. It took a series of nested while loops and state variables that were incremented or decremented as needed. I avoided recursion because the sequences were of arbitrary length. Breaking the code into subroutines made it more complex to maintain loop state. Using goto allowed me to break apart the logic into blocks without the overhead or state-passing necessary to shoehorn the logic into subroutines. I was able to label each part clearly and jump between them as needed to increment or “carry the 1.” I reduced the size of the code to just a couple dozen lines, including safety checks, and found that the goto code was much easier to read and reason about.

That said, I want to emphasize strongly that goto should be kept local. Jumping to outer function calls makes the logic of a program difficult to reason about and changes scope in confusing ways. But as a way of structuring complex loops and iterative logic, you just can’t beat goto.

Submit article

newLISP modules

A Google Code project has been created for my newLISP modules. Anyone who would like to contribute is welcome. It can be found at http://code.google.com/p/actools-newlisp/.

Phorms

The Phorms library also has a Google Project page, located at http://code.google.com/p/php-phorms/. Contributions, as always, are welcome.

PHP Pipeline

PHP Pipeline is an asynchronous HTTP pool. It is very simple to use and extremely efficient on resources. Code and samples available at http://code.google.com/p/php-pipeline/.

JoQ

JoQ is a simple message broker written in Java. Its design goals are efficiency, speed, and ease of use. It is optimized for use as a massive job queue for multiple work flows. One neat feature is the ability to create multiple queues on the fly and add jobs to multiple queues; retrieved jobs are removed from all queues in which they appear.

This is a fairly new project and there is not much code yet written, but if anyone has any suggestions, comments, or contributions, I am happy to hear them.

Submit article

At the dawn of time…

The old BBS is terribly antiquated by today’s standards. A sysop (or webmaster for you young folk) would dedicate perhaps half a dozen phone lines to their server, running MajorBBS (which was not a PHP-powered forum), Angelfire (which was not a defunct web hosting company), or Wildcat. Each had their strong points, but they usually had some form of user-to-user chat, in-system messaging, file sharing, and games (who remembers spending all night playing Legend of the Red Dragon or Tradewars?)

The Internet freed us from this more intimate world. Email now worked between all systems, and in-house email either conformed or disappeared. Prodigy and CompuServe died, while AOL adapted (for a while, anyway). Files could be shared simply and quickly, and anyone with basic knowledge of HTML and an ad-supported account somewhere could participate.

Modern day

These days it’s for granted that everyone and everything is connected. With Twitter, even an everyday Joe can be sure that all of their friends are kept up to date on how much they are enjoying that ham sandwich.

The social networking trend is interesting to me because I see it as a shift back to the more intimate realm of the BBS. Counter to the culture of full exposure engendered by the Internet, folks are gravitating toward sites that provide a more limited experience. Even the most curmudgeonly of us grudgingly accept Facebook and use it to filter our social lives online.

Networking sites provide a safe haven – a controlled community, much in the style of the old BBS. We prefer their primitive messaging to full-featured email clients when communicating with our friends and family, not because we are Luddites, but because it is more personal. There is something quite uncomfortable about sending your mother an email at hotmomma288@yahoo.com.

Looking back

This is something of a rehash of an article I wrote last year. In fact, reading back, I even took the same grumpy tone :). I was a bit late signing up for Facebook, but I have to admit that I enjoy it. Now, if they could just port Legend of the Red Dragon over…

Submit article

What I like about TextMate

Let me repeat that I like TextMate. I have happily used it for years. It has some wonderful features. It is reasonably fast and its indentation is great. It has a great selection of plugins for a wide variety of languages and is easy to extend with new language modules. It has a decent macro system based on regular expressions that, while not nearly as powerful as scripted editors, provides 80% of what most users need.

Problems with TextMate

TextMate, for all its sterling qualities – and there are many – has a few problems that, while not deal-breakers in themselves, together provide a less-than-satisfactory experience.

Split-windows

This is a rather stark issue, and is a feature that has been promised in the next release. Nevertheless, its absence often means either filling my screen with open TextMate windows or firing up emacs when I need to look at many files at once – or many parts of the same file at once. C, in particular, tends toward long functions, and is especially painful to write in TextMate.

Large files

TextMate handles many open files well, but a single large file will hang the entire application. I can accept a large file taking a long time to load, but please! Load the file in the background, so that I can keep working. Even opening a large file in a second window blocks the entire application. Find and replace also choke on larger documents, sometimes taking minutes to complete.

Key-bindings

TextMate’s key-bindings can be puzzling. Many common commands (especially in Python), such as converting between spaces and tabs in a document, don’t have bindings and are several levels deep in the menu. Other commands of dubious utility are given simple bindings, such as “Execute line/selection inserting result” (control-R.) Many have extremely difficult combinations, such as control-alt-command-D to toggle to project drawer, or control-option-shift-P to toggle text mode (and then – because several bundles use this same key-binding, god knows why – you are given a drop-down to choose which command you wanted.)

Choosing a new editor

I was initiated into the cult of emacs in college and have used it for several years. I’ve played with BBEdit (which I think is horribly cluttered and completely lost in the pre-OSX world), NetBeans, and Eclipse (which is, amazingly, slower and clunkier than NetBeans.) I love emacs’ extensibility and its indentation is second to none. It suffers from the key-binding issue as well, though. Becoming efficient in emacs is a journey, not a destination. I find myself spending more time navigating its arcane and bureaucratic configuration system than actually writing code in it.

NetBeans in some ways seems very polished, and the new Python module is very good (I have written about this before.) Refactoring across files is extremely useful. It has good debugger integration. Unfortunately, tight integration with any particular language costs a great deal in load times and can lead to an unresponsive UI. And for god’s sake – why does it have to be such a chore to open a file outside of a project?

Panic’s Coda is pretty and has some neat features, but in the end, SubEthaEdit (its editor) has poor syntax support and its extension system feels very clunky. Editra is nice, but slow and buggy on OSX.

Vim

After a disappointing look around the net for better choices, I decided to give Vim another try. I had a passing familiarity with some of its basic functionality from my days as a system administrator, it is scriptable, and it has a large number of plugins for syntax support.

Lack of distractions

Overall, I am satisfied with Vim’s minimalism. Its indentation is pretty second rate, but I can live with it. Vim feels extremely comfortable. Over the years, Vim has gently washed away all of the “features” of an editor that actually get in the programmer’s way and come up with a system that drastically increases productivity and makes coding a more satisfying experience.

Load speed

While not the primary measure of an editor, load time is important. How many programmers (myself included) give up on Eclipse or NetBeans right away because it takes more than half a minute to start up? Load time is one of those things that, while really just an annoyance, can completely color the experience of using a program. Vim loads quickly. It is one less thing to get in the way of productivity.

Efficiency

Nothing beats Vim for efficiency. If you ever wonder why so many applications have modes that mimic Vim, it is because once you learn Vim’s bindings, there is nothing faster. Jumping around a file with precision is a breeze. Coming from emacs, I expected it to take a lot longer to become comfortable with Vim’s style and bindings, but it has a much milder learning curve than emacs. Search and replace is also fast and easy to use. I quickly found myself giving up MacVim in favor of the command line. Copy and paste – the biggest barrier to command-line editors for me – is fast and easy with Vim’s visual mode.

Other features

Vim 7 has auto-complete, although I rarely use it. I’m much more comfortable with an enormous stack of O’Reilly books. Vim’s code folding is also very nice. I generally turn code folding off because it slows most editors down so drastically, but it does not appear to affect Vim.

Two of Vim’s features really stand out for me: reformatting text and retabbing a document. I love being able to convert a file’s tabs to spaces just by typing :retab. It is much more efficient than having to go through two levels of menus in TextMate. And being able to reformat Python doc strings is very useful. It removes an annoyance that can make updating documentation a real chore.

Conclusion

Vim strikes the perfect balance for me. At first glance, it seems archaic, especially for those born after the mouse became standard. After a few days of using it, though, I find myself enabling Vim bindings mode in any application that has it, using the Vimperator plugin for Firefox, and wishing that OSX’s terminal was more easily scriptable. If you haven’t used Vim, give it a chance. Coming from a graphic editor like TextMate, it is a much different experience and, arguably, a more satisfying one.

Here are some other folks’ experiences with the transition in both directions:

• Coming home to Vim
• From Vim to TextMate

Edit [2009-08-03 15:50]: added links to similar stories

Submit article

Take this trivial example:

from django.db import models
 
class Sport(object):
    name = models.CharField(max_length=50)
 
class Season(models.Model):
    starts = models.DateField()
    ends = models.DateField()
    sport = models.ForeignKey(Sport)
 
class Team(object):
    name = models.CharField(max_length=100)
    sport = models.ForeignKey(Sport)
 
class Game(object):
    season = models.ForeignKey(Season)
    home_team = models.ForeignKey(Team, related_name="home_games")
    away_team = modesl.ForeignKey(Team, related_name="away_games")

In the admin change form for Game, it is obviously desirable to only permit teams to be selected that match the Season‘s Sport. Unfortunately, because fields are defined on the class rather than the instance (such as inside of __init__), there is no obvious way to create a relationship based on the values in the instance.

Inside the ModelAdmin class is the method get_formset(self, request, obj=None, **kwargs). The parameter obj stores the current instance, if any. The significance of this is that this method is a hook with access to the instance data and is called for every form as it is built.

That makes it possible to filter the Teams based on the current form’s instance.

from django.contrib import admin
from django import forms
from myapp.models import Team, Game
 
def game_form_factory(sport):
    class RuntimeGameForm(forms.ModelForm):
        home_team = forms.ModelChoiceField(label="Home",
                queryset=Team.objects.filter(sport=sport))
        away_team = forms.ModelChoiceField(label="Away",
                queryset=Team.objects.filter(sport=sport))
 
        class Meta:
            model = Game
 
    return RuntimeGameForm
 
class GameAdmin(admin.modelAdmin):
    model = Game
 
    def get_formset(self, request, obj=None, **kwargs):
        if obj is not None:
            self.form = game_form_factory(obj.season.sport)
        return super(GameAdmin, self).get_formset(request, obj, **kwargs)

Here is how it works. When the GameAdmin form is built, get_formset is called. If this is an edit form (add form’s will not have instance data) the Game instance is passed as the obj parameter. In this case, the instance sets the form attribute to be the result of calling game_form_factory, which is a class factory function.

What if we want the Game form to be an inline form for the Season form? The major difference with inline form sets is that the instance passed to get_formset is now that of the parent form, rather than the form set model (in this case, Season instead of Game.)

The class factory function remains essentially unchanged. The Game admin model requires only a small change.

class GameAdminInline(admin.TabularInline):
    model = Game
 
    def get_formset(self, request, obj=None, **kwargs):
        if obj is not None:
            self.form = game_form_factory(obj.sport) # obj is a Season
        return super(GameAdminInline, self).get_formset(request, obj,
                **kwargs)

Submit article