• Reorganized into a single closure. This helps keep internal details internal.
• Minimize with Closure Compiler
• JSLint now passes
  • I definitely recommend the JSLint VIM plugin if you’re a vimmer.
• Works in node.js (and most likely any server-side JavaScript implementation)
• Works in Internet Explorer.
  • I had never really tested this, but after fixing the things that JSLint found, the tests just passed.
  • Still need to test in IE 6. I don’t have a machine with IE 6 unfortunately.
• Added to documentation to clarify a few things.

At this point, I think the library’s safe for others to use. I tagged a 0.5 version, and I’ll be calling it 1.0 after it gets into a few more projects. Feel free to try it out!

You can find Cobra on github, or you can download version 0.5 now (tgz).

Hitchens’ main line of reasoning stems from a few anecdotes that he brings together to create an overly pessimistic picture of sports creating international tension. This kind of journalism is sickening, but typical, as it poses a number of loosely similar stories as facts that reach a hard conclusion without even suggesting alternative sides of the story. It is nothing more than tabloid-esque entertainment, but nevertheless I am compelled to present a different vision of sports in America and the world as a whole.

Since humanity has formed into nations, cultures, religions, and a number of other ways of organizing themselves, there has been a basic problem. In a world in which it is more likely that you do not know somebody than you do know them, how do we interact, probe each others strengths and weaknesses, find common ground, and establish community with people we have no interaction with? Discussing economics, religion, or politics is more likely to breed conflict than mutual understanding. You cannot compete with somebody who is willing to die rather than give ground on a subject. Competitions, as a natural tribal instinct, had to evolve into a different form. I am always going to want to best by sister at any give topic. My family will want to best the neighbors. The town will want to best the next town over. The state will want to best the next state. If we ever find alien life forms, Earth will want to show their superiority. There should be a way to fulfill this natural need to compete without killing everyone. Sports is that way.

This point seems to play right into sports opponents hands. They would say that sports are still a reflection of animal instincts that we can grow out of, that’s it’s somehow base. I strongly disagree. Sports are the civilized competition, the way we teach and learn how to resolve differences without resorting to violence. Sports are islands of peace in a world riddled with genuine conflict. They provide tribal community without pushing us towards its violence.

The key to sports peaceful nature is that they, in and of themselves, don’t matter. They are not a higher cause. When they become representative of a higher cause, trouble ensues, but when they are kept to the level of competition for competition’s sake, then there is no reason for animosity to endure, or to break into violence. This allows for community on both sides of the competition, which allows us to ignore the potentially violent differences individuals have in their everyday lives.

College is a great example. While I probably do not have an causes that I will violently enforce, many people that are thrown together on the same university do. Israelis and Palestinians sit next to each other in lecture. Blacks and whites, Armenians and Turks, and hundreds of other traditionally irreconcilable cultures, religions, and nationalities interact with each other every day. How is it possible to create a cohesive community out of such a widely varied population? Sports. A few chosen athletes are tasked with representing this created community in a way that we can all join together and push past our differences. This community now has a face, something to fight for, but not in a violent way. We can peacefully come together around this one cause.

The same concept applies to localities, states, and nations. If I meet an older, latino, blue-collar worker on a bus or in a bar, I have nothing obviously in common with this man. Throw on an Ohio State sweatshirt, and suddenly we can talk for hours. What’s more, throw a Michigan sweatshirt on the man, and we can still have a civil conversation. We are rivals, but not the kind that you can’t have a beer with. In fact, I am offered an understanding of how the man thinks that I would not normally have. I know he hates me the same way I hate him, and we can bond over that. The same principle applies to a San Francisco shirt in San Francisco, or a Die Mannschaft jersey in Germany.

Sports at their core are about peaceful competition. So how is there so much violence? The violence is caused by the same things that cause violence outside of sports, sports are sometimes just mixed up into the equation. Violence is frequently caused by money, religion, cultural differences, and a whole slew of other things. When the sports teams representing two sides that are already entangled in a conflict meet, one of two things can happen. The competition can remind everybody of their shared interests, or they can serve as a catalyst to a violent conflict. While I believe that the majority of the data suggests the former, I have no proof of this. The important point is, the violence is not caused by the sport itself. It’s caused by the things that always drive us apart. Sports themselves, when played out as they are intended, can only bring peace.

Whether or not healthcare is a right, however, is not the debate. Rather, it’s a tactic used by one side to make an argument in a sentence instead of in a carefully constructed thesis. What those in favor of healthcare reform are trying to push for is the idea that we, as a society, have some moral imperative to force the provider’s hand and provide some level of healthcare to all, whether providing such care is beneficial to the provider or not. This is an argument for a restriction of rights, which, paradoxically, is something goverments have been granted the right to do by their citizens.

The question then is how much we are morally obligated to restrict the freedoms of healthcare providers in order bring the general health to some acceptable level. This is a very difficult question, made more difficult by the fact that the value of healthcare changes with time and economic prosperity. This is a terrific example of imperfect duty, a duty which is never complete but which we are morally bound to strive to make progress on. We have made great progress too. Healthcare as it exists today is better than at any previous point in history and available to more people. It does seem to be the case, however, that society feels that too many of its members are in a situation where they do not have access to the kinds of care that should be available to all. This probably doesn’t include very expensive experimental treatments, but does include expensive but common procedures and treatments like those used to fight cancer, heart disease, and other widespread diseases.

The current legislation is too large for me to really know what’s in it, but the goals are fairly clear. The bill is meant to require health insurance for almost all Americans, require coverage for those with preexisting conditions, make selecting insurance options more transparent, facilitate keeping your insurance between jobs, and providing some form of publicly funded insurance. These components really try to kill two (or perhaps 3 or 4) birds with one stone. In addition to the much touted coverage for those that are currently without, a large portion of the bill is designed to make health coverage more manageable by individuals. That sounds great to those of us that have healthcare that we really don’t even know how to use, but doesn’t really take steps towards fulfilling our society’s imperfect duty. Perhaps that’s why we don’t hear a whole lot about that part of the bill.

Whatever ends up in the final bill, it seems to me that it will not fulfill any of its goals. The less talked about goal, that of making health insurance more manageable by its own customers, is not something governments are particularly good at. It’s difficult to regulate complexity. The best way to achieve this goal is competition. This would require insurance companies to market straight to consumers instead of their employers. You can be sure that insurance companies will become more transparent in a hurry when they have to convince you that they are actually better than the next guy rather than your company’s HR department. Auto insurance, for instance, is substantially simpler than its healthcare counterparts.

Where government is probably not the best answer for reducing the complexity of the healthcare system, government has become the preferred vessel for carrying out society’s obligations to itself. In the current debate, this has translated to “we must provide insurance to the uninsured”. This seems noble enough, except that the insurance model itself is deeply flawed. Those of us that already have insurance can see this quite obviously. We do not know the cost of healthcare, nor do we care. Co-pays are minimal, so we take what healthcare we need and bill the insurance company. For those of us with insurance, healthcare is near free and limitless. It stands to reason, then, that by providing insurance to those without, they will also have unlimited, near free healthcare.

The question then becomes, is unlimited, free healthcare the fulfillment of our moral obligation? I believe that it is not. Society should not be asked to cover the costs of keeping the elderly around longer than is prudent, nor should we be asked to bear the burdens of an individual’s poor decisions. Society should provide the level of healthcare that most of us enjoy to as many as possible, but we should not give a blank check.

Many are disgusted by the idea of trying to figure out who should get what healthcare. It does not seem ethical to have “death panels” or enforce that your bypass will only be covered if you didn’t eat bacon for a year. Should we provide orthodontics, which seem like a luxury until you look at the importance of good teeth in the white collar world? Again, this is one of those things that government does a poor job of regulating, and again, these decisions should be left up to the individual. How we do this is something that the current legislation doesn’t touch, and I believe is absolutely necessary for true healthcare reform.

Structuring the system to provide individual responsibility while still providing healthcare to those that cannot afford it seems fairly straightforward to me. Offering insurance policies with very high deductibles and supplementing them with health savings accounts ensures that an individual can determine their own regular healthcare needs while still being protected from unexpected disasters. Both the policies and the savings accounts can be subsidized or provided by the government, with the expectation that the individual contributes what they can. This simple combination seems to be the best bet for minimizing government’s interference in an individuals healthcare while still providing them with the level of care the rest of society enjoys.

There is a serious caveat to this seemingly simple solution. That caveat is that all health services, not just disasters, are obscenely expensive and getting pricier. I believe this is a direct result of the structure of the current private insurance industry. Since nobody except for the insurance companies care what the cost of health services is, and the insurance companies are buying in bulk, there is a strong incentive for the hospitals to reduce the costs of those services that the insurance companies will object to while increasing the costs of those services that are cheap by comparison. Added to the burden is the cost of patients that are unable to pay. The effect of the hospitals “making up” money by increasing costs of routine services is that all healthcare services are more expensive, without any incentive for them being made cheaper.

The current proposal for dealing with the cost problem is for the government to provide a public option to “compete” with the private insurers. I don’t understand this reasoning in the least, but it hasn’t been well explained by its proponents, so I could be missing something. Regardless of its ability to provide competition in an already highly competitive market place, the public option is fundamentally flawed since its structured like a traditional insurance company. It will have similar incentives, none of which will encourage lowering the costs of routine healthcare.

A better method for controlling costs is to make sure individuals are aware of them. If people are asked to pay for routine health services, they will pay much closer attention to the costs of these services. The best way to get individuals to pay for routine services is the same method by which we should cover those without insurance: through health savings accounts combined with high deductible insurance policies.

If those that can afford insurance are on a plan similarly structured to those that can’t, then we have a system in which the market can drive down the costs of things that should be cheap while insuring that those things that are not affordable are available to those that really need them. This seems to be the easiest and least error prone method of reforming healthcare.

There are a number of ways to fulfill the nebulous goal of providing healthcare to everybody in America. One way is to buy into the current system and ask society to pay for it. Another is to restructure the system in a way that benefits everyone and only then ask society to provide those minimal services it has deemed morally necessary to provide to its citizens. The latter seems like the more prudent, more moral, and simpler way to make this generation’s contribution to that imperfect duty that is healthcare.

What is this?!

this is the current object. People that are used to object oriented languages use objects constantly, and this is how you access your object in JavaScript. This differs from Java and C++. This is best demonstrated by example, so let’s take a look.

class HotDog {
public:
     string getCondiments();
private:
     string condiments;
}
 
string HotDog::getCondiments() {
    return condiments; // The compiler knows to find "condiments" in the current HotDog instance
}

Ruby and Python don’t work this way. Instead, you must say “look for this variable in the current instance”

class HotDog:
    condiments
    def getCondiments(self):
         return self.condiments # "self" is a reference to the current instance of HotDog.

  class HotDog
         @condiments
         def getCondiments
              return @condiments # @condiments is an instance variable of an instance of HotDog
         end
    end

JavaScript has more in common with Ruby and Python than with Java and C++. The same thing in JavaScript is:

function HotDog() {
    this.condiments = "mustard, ketchup";
    this.getCondiments = function() {
         return this.condiments; //this is expected to be a reference to the current instance
    }
}

That’s what this is expected to be, anyway. It’s expected to be a reference to the current instance of whatever object it’s defined within.

this Gets Tricky

However, let’s say we wanted to find out what condiments were on our hotdog in 30 seconds. Assuming the HotDog class from above, that code might look like this:

var myHotDog = new HotDog();
// Call the getCondiments function in 3 seconds
setTimeout(myHotDog.getCondiments, 3000);

Many JavaScript beginners are surprised to learn that this code won’t work. It’ll give an error saying that this doesn’t have a member called condiments, even though it clearly does. What happened?!

As it turns out, this in the getCondiments function is set to the global object, window. This is because there is no binding of functions to instances in JavaScript. Whenever the instance isn’t explicitly stated, then this becomes window (at least in the browser). Writing this as myHotDog.getCondiments() indicates that you want this to be myHotDog, so it works correctly. The setTimeout function, however, just has a reference to that function. When it calls it, it’s not aware of myHotDog, so JavaScript sets this to window

“Fixing” this

There are several ways of forcing this to be what you want, and many of them touch on some of the more interesting features available in JavaScript. The first is apply. apply is a member of every function. It says “call this function with this object as this and these arguments. An example might help.

// These two are equivalent
myHotDog.getCondiments();
myHotDog.getCondiments.apply(myHotDog);
 
// You could also do this
var yourHotDog = new HotDog();
myHotDog.getCondiments.apply(yourHotDog);
 
// The above line does the same thing as:
yourHotDog.getCondiments();
 
// The above two calls will return the condiments off of your hot dog, not mine.

That doesn’t solve our setTimeout problem, however. apply actually calls the function, and we just want a reference to the function that uses the correct this. Luckily this is easily done, but let’s talk about some background first.

Lexical Scoping

In many languages (all the good ones, if you ask me), lexical scoping is supported. Lexical scoping basically allows you to access local variables in a parent function. If a function is defined within another function, it can access its own local variables as well as those of the function it was defined within. Time for another example.

function drinkBeer() {
    var beer = "Big Daddy IPA";
    function pour() {
         var glass = "Pint Glass";
         return "Poured " + beer + " into a " + glass;
   }
   function drink() {
         beer = null;
         return "Beer is all gone";
   }
   pour();
   drink();
}
drinkBeer();

This works just fine. drinkBeer cannot access glass, but pour and drink can access beer.

Lexical scoping is extremely powerful. If this small example doesn’t explain it, I encourage you to look around other examples on the internet until it’s more clear. While writing JavaScript, look out for ways this can make your life easier. Once you’re looking, they’re all over the place.

Solving our setTimeout Problem

With lexical scoping, we can easily solve our setTimeout problem.

var myHotDog = new HotDog();
setTimeout(function() {
    myHotDog.getCondiments();
}, 3000);

See what we did there? We created a new function that we passed to setTimeout. Our new function can access myHotDog, so it just applies it to the getCondiments function. Pretty slick.

Defending against this abuse

As somebody writing the HotDog class, it might be upsetting to you that people constantly need to keep this in mind when accessing your class. It would be nicer if there was a way to make your class work all the time. Fortunately, there is!

function HotDog() {
    var my = this; // my references the current this, which is correct.
    my.condiments = "mustard, ketchup";
    my.getCondiments = function() {
         return my.condiments; //my is guaranteed to be a reference to the original "this"
    }
}

HotDog is a constructor. You instantiate a new instance of HotDog by writing “new HotDog()“. In constructors, this is always your instance. So we created a new variable, my, that references the HotDog instance. This allows you to always refer to the HotDog instance, no matter how the getCondiments function is called.

Bind

Another method of “fixing” this is adding a bind attribute to every function. This allows you to pass in an object that will be your this. Many JavaScript libraries, such as Prototype, do this.

var boundFunction = myHotDog.getCondiments.bind(myHotDog);

Now boundFunction will always call getCondiments with this set to myHotDog. If you’ve been paying attention, it should be fairly obvious how bind is written.

function bind(thisObject) {
    var my = this; // this is the function here
    return function() {
        my.apply(thisObject);
    }
}

Cobra

My own class library, cobra, solves the this problem in a different way. It passes a reference to the original this to every function, which allows you to use some fancy features like prototypal inheritance while still not worrying about binding and the like. If you’re interested, you can find the code on bitbucket.

Whew

That’s pretty much all you need to know about this.

• this will be window whenever your function is indirectly called.
• Use apply to force this to be what you want
• You can use lexical scoping to make sure this behaves in a predictable manner

I hope that’s clear, comment if it’s not!

This article assumes that you have some knowledge of how to create an app, new scenes, and how to debug. If you aren’t somewhat comfortable with the SDK yet, check out the Hello World tutorial.

Setup

At first, we’ll just create a big button that puts all our meetups into the calendar. Nothing fancy. To create the scene, run:

$ palm-generate -t new_scene -p "name=sync"

Then in the stage-assistant.js file, put:

this.controller.pushScene("sync");

Creating a Calendar

The first thing that we will do is create a new calender for Meetup.com. This calendar will appear in the calendar app right next to your Google Calendar or Exchange calendar using the Palm Synergy APIs. This is great because it allows you to deliver new data to your users without having to write yet another way of presenting it. All contacts and calendars can be plugged straight into the core webOS applications.

To create a calendar, you first need to make an account:

self.accountServiceId = "palm://com.palm.accounts/crud/";
 
 /* Retrieves account if it exists, otherwise creates it */
setupAccount: function(self, k) {
    self.controller.serviceRequest(self.accountServiceId, {
        method: 'listAccounts',
        parameters: {},
        onSuccess: function(list) {
            Mojo.Log.info("Got account list: %j", list);
            if (list.list && list.list.length > 0) {
                self.account = list.list[0];
                k();
            }
            else {
                self.account = {
                    username: "justin",
                    domain: "meetup.com",
                    displayName: "Meetup.com",
                    dataTypes: ["CALENDAR"],
                    isDataReadOnly: true,
                    icons: {largeIcon: '', smallIcon: ''}
                };
                self.controller.serviceRequest(self.accountServiceId, {
                    method: 'createAccount',
                    parameters: self.account,
                    onSuccess: function(response) {
                        Mojo.Log.info("Got %j for %j", response, self.account);
                        self.account.accountId = response.accountId;
                        k();
                    }
                });
            }
        },
        onFailure: function() {
            Mojo.Controller.errorDialog("Failed to create account");
        },
        onError: function(error) {
            Mojo.Controller.errorDialog("Error creating account");
        }
    })
},

You’ll notice a few different things about this code, the odd things which are just my style. Using self instead of this is an idiom from Cobra, a JavaScript class library I wrote. k is a continuation, or the function that should be called after the account is created. k I believe is an idiom for Continuation Passing Style in Scheme.

Beyond that, this is very standard Mojo code. Services are identified as “palm://com.palm.” and all methods support onSuccess, onFailure, and onError callbacks. This code checks to see if there is already an account associated with this appId, and if there is, calls its continuation. If there is not, it creates the account and calls its continuation.

After the account is created, we can create the calendar.

self.calendarServiceId = "palm://com.palm.calendar/crud/";
 
/* Retrieves calendar if it exists, otherwise creates it */
setupCalendar: function(self, k) {
    self.controller.serviceRequest(self.calendarServiceId, {
        method: 'listCalendars',
        parameters: {
            accountId: self.account.accountId
        },
        onSuccess: function(calList) {
            Mojo.Log.info("Got calendar list");
            if (calList.calendars.length > 0) {
                self.calendar = calList.calendars[0];
                k();
            }
            else {
                self.calendar = {
                    name: "Meetup.com"
                }
                self.controller.serviceRequest(self.calendarServiceId, {
                    method: 'createCalendar',
                    parameters: {
                        accountId: self.account.accountId,
                        calendar: self.calendar
                    },
                    onSuccess: function(response) {
                        self.calendar.calendarId = response.calendarId
                        k();
                    },
                    onFailure: function(error) {
                        Mojo.Log.error("Creating calendar failed: %j", error);
                        Mojo.Controller.errorDialog("Failed to create calendar");
                    },
                    onError: function(error) {
                        Mojo.Log.error("Creating calendar failed: %j", error);
                        Mojo.Controller.errorDialog("Error creating calendar");
                    }
                });
            }
        },
        onFailure: function() {
            Mojo.Controller.errorDialog("Failed to create calendar");
        },
        onError: function(error) {
            Mojo.Controller.errorDialog("Error creating calendar");
        }
    });
},

This is almost identical to the account creation code, except it’s creating a calendar.

Now calling these functions is easy:

self.setupAccount(function() {
    self.setupCalendar(function() {
        self.buttonModel.disabled = false;
        self.controller.modelChanged(self.buttonModel)
    });
});

Pulling down events

To get the events that are associated with the account, I am using the Meetup.com JavaScript client. The client requires jQuery, but since it only requires jQuery to do JSONP, we replace that line with a Mojo call. There is no reason that we couldn’t use jQuery, but jQuery is overkill for just doing JSONP.

jQuery.getJSON(urlprefix + call_type + url, params, function(json){callback(json)})

Becomes:

var query = $H(params).toQueryString();
url = urlprefix + call_type + url + query;
Mojo.loadScriptWithCallback(url, Mojo.doNothing);

After we have the Meetup client library, getting the events is easy, but a little indirect. It takes three API calls, one to get the member id, one to get every group associated with the member id, and one to get every event in all those groups. You can see the details on Meetup’s API page.

self.client = new MeetupApiClient(Meet.Auth.apiKey);
syncCalendar: function(self) {
    // Gets my member id
    Mojo.Log.info("Syncing calendar");
    self.client.get_members({
        relation: "self"
    }, self._getGroups);
},
 
_getGroups: function(self, members) {
    Mojo.Log.info("Got members");
    var memberId = members.results[0].id;
    self.client.get_groups({
        member_id: memberId
    }, self._getEvents);
},
 
_getEvents: function(self, groups) {
    Mojo.Log.info("Got events");
    groups = groups.results;
    var groupString = groups[0].id;
    var today = new Date();
    for (var i = 1; i < groups.length; i++) {
        groupString += "," + groups[i].id;
    }
    self.client.get_events({
        group_id: groupString,
        after: today.getMonth() + today.getDay() + today.getFullYear()
    }, self._saveEvents);
},

Now self._saveEvents will receive a list of events that are coming up after today. All we need to do is loop over the list, format them as Palm calendar events, and pass them to the calendar service.

_saveEvents: function(self, events) {
    Mojo.Log.info("Saving events");
 
    self.numEventsProcessed = 0;
    self.events = events;
 
    events.results.each(function(meetupEvent) {
        var time = new Date(meetupEvent.time).getTime();
        if (meetupEvent.myrsvp != "no") {
            self.controller.serviceRequest(self.calendarServiceId, {
                method: 'createEvent',
                parameters: {
                    calendarId: self.calendar.calendarId,
                    event: {
                        eventId: meetupEvent.id,
                        subject: meetupEvent.name,
                        startTimestamp: time,
                        endTimestamp: time + 3600000, // 1 hour in ms
                        allDay: false,
                        note: self._formatNote(meetupEvent),
                        location: meetupEvent.lat + ", " + meetupEvent.lon,
                        alarm: 'none',
                    }
                },
                onSuccess: self._createdEvent,
                onError: self._errorCreatingEvent,
                onFailure: self._failureCreatingEvent
            });
        }
    });
},
 
_createdEvent: function(self, response) {
    self._checkIfSyncFinished();
},
 
_errorCreatingEvent: function(self, response) {
    Mojo.Log.error("Could not create event: %j", response);
    self._checkIfSyncFinished();
},
 
_failureCreatingEvent: function(self, response) {
    Mojo.Log.error("Failed to create event: %d, %j", self._eventsReturned, response);
    self._checkIfSyncFinished();
},
 
_checkIfSyncFinished: function(self) {
    self.numEventsProcessed++;
    if (self.numEventsProcessed == self.events.meta.count) {
 
        if (self.events.meta.next) {
            Mojo.Log.info("Fetching the next page of results...");
            self.client.nextPage(self._saveEvents);
        }
        else {
            Mojo.Log.info("Fetched all the events");
            self.buttonModel.disabled = false;
            self.controller.modelChanged(self.buttonModel);
            self.controller.get("sync-button").mojo.deactivate();
        }
    }
},

And that’s basically it! With the code above, all your Meetup.com events can be inserted into your webOS calendar. All you need is an event handler for your button.

self.buttonModel = {
    buttonLabel: 'Sync',
    disabled: true
};
 
self.controller.setupWidget('sync-button', {
    type: Mojo.Widget.activityButton
}, self.buttonModel);
 
Mojo.Event.listen($('sync-button'), Mojo.Event.tap, function() {
    self.buttonModel.disabled = true;
    self.controller.modelChanged(self.buttonModel)
    self.controller.get("sync-button").mojo.activate();
    self.syncCalendar();
});

This works assuming a view containing:

<div x-mojo-element="Button" id="sync-button"></div>

Debugging Tips

Creating a file called framework_config.json allows you to change the logging level. That will permit JavaScript messages to be output into /var/log/messages on the device. This is especially valuable if you’re working on a 64-bit linux machine where the inspector is currently not supported.

{
    "logLevel": 99 // 0 means no logging, 99 will max it out
}

Removing /var/luna/data/dbdata/PalmDatabase.db3 removes all data you may have inserted. This allows you to start over fresh, but I wouldn’t recommend doing this on your actual device. You’ll lose all your data!

Todo

This program isn’t really complete, but it’s a good start. A couple of things we still have to do are:

• Add Authentication with OAuth
• Keep track of already inserted appointments so we don’t insert duplicates
• Add automatic synchronization in the background
• Add push updates (this is impossible without server side support)
• Make things look nice

Stay tuned for articles on some or all of these exciting new features! Until then, the code is available on github.