Educational opportunity for all

Oftentimes domestic government policy is oriented around helping those that cannot help themselves. If we grant the premise that government is bad at things, then it goes without saying that they’re bad at helping people that can’t help themselves. I believe that education is the great equalizer, with access to education available to all, then it is up to the individual to seize those opportunities and achieve whatever they are able to. One of the greatest crimes we can allow to continue as a society is to deny people the opportunity to help themselves, and yet without the ability of each citizen to access the best possible education affordably, we are doing exactly that. Fixing this situation doesn’t even seem that hard, all that needs to be improved is access and affordability.

Fixing access is the harder part. Access to education means at a bare minimum permitting a person to get an education. I genuinely believe this is mostly solved. Whether you are black or white, male or female, gay or straight, you are allowed to enter any school in this country. This took us over 150 years to get right, but I believe that we are well on our way. Good job team!

The other parts of access relate to quantity of quality education. Without enough quality education available, we are forced to limit access through either price, lottery, or geographic location. I had a quality education because I lived near a wealthy suburb that paid good teachers well and was pleasant to work at. In San Francisco, there is a lottery to see who will go to what school. Some are good, some are, generously, less good. Most cities just do not have quality public schools and the only way to escape that is to pay ridiculous sums for a quality private education.

To fix this we need more good teachers. The current system does not encourage good teachers. I do not really care how we fix this, we just need to do something, and do it quickly. Making it easier for highly educated professionals to go and teach is one way. This means the regulatory requirements need to be lessened, with more control given to the school systems to determine who would and would not make a good teacher. It also requires paying teachers better. When teachers are seen as martyrs instead of professionals, we have a problem. Not everybody can afford to be a martyr.

Politically, increasing teacher quality through sweeping reform is difficult. The teachers’ unions are quite powerful and seem to be opposed to all kinds of constructive reforms. This is why I am a supporter of school vouchers. If we cannot make public schools better in an expedient fashion, then we must try something else, and vouchers are a good way of pumping more money into a system that might be able to fix these issues. I understand a lot of the arguments against vouchers, but they all fall, in my mind, to the simple need to do something.

Affordability can go hand in hand with access, but tends to apply more to higher education. A quality higher education is necessarily expensive, and is not necessarily the right choice for every person. Not everybody needs to go to Harvard, but everybody that wants to go to Harvard and has the qualities Harvard is looking for in students should be able to do so. There are currently many programs to help students gain a higher education, but I feel that we need to be much more aggressive about it. A student should go through their entire primary education with the assumption that they can afford whatever college they desire so that they may focus on deciding which college will help them achieve whatever goals they may have. This means aggressively expanding the Pell Grant system. Pell Grants are laughably small for anybody that does not go to a state school. This means lower interest rates on student loans, and longer periods of time before it’s required to pay them back. This means more programs that forgive student debt, whether it be Peace Corps, Americorps, becoming a public defender, or even going into teaching. This means matching a student’s part-time pay. This means providing travel vouchers. This means providing free child care. This means tax breaks for everybody that helps an individual achieve a college education. This means bending over backwards to make sure those that are able to make an impact are given the education necessary to do so.

Immigration Reform

In addition to making our own population more able to advance our society, we need to allow others to freely do so as well. America may be losing some stature on the world stage, but it is still largely seen as a shining beacon of freedom and opportunity, if only you can get there. Without enough educators, doctors, nurses, engineers, and innovators, we are fools not to throw open the gates and announce to the world that if you think you can make it in America, we are going to let you try. The process should be as easy as getting a drivers license, which itself should be a whole lot easier. The only thing that seems to be preventing this now is a fear of low-cost migrant workers taking jobs, and in my mind the cost of that fear is far too high. Competition is good, it makes us strive to be our best when we’re winning, and forces us to change our approach when we’re losing. Immigrants oftentimes don’t have the preconceived notions of comfort and well-being that so many Americans have, many of them will work extremely hard to make it here. They will start businesses that will provide millions of new jobs and bring innovations to our country that will bring trillions of dollars to US shores. The best and the brightest should know that America is where they can have their dreams realized, without the hassle of convincing America that it wants them at all.

And that’s it. After that, I really just want government to leave us alone. The issues of the day pale in importance to these issues. Healthcare, Social Security, the next Keynesian jobs bill, they are all politically easy and ultimately problematic, band-aids for a society afraid of its diminishing promise but unable to make the hard changes necessary to reverse course. My far right agenda is simple: do less and allow people to achieve more.

What this shows is that when a Boolean object is used in an if statement, it always evaluates to true, but when it’s used in a type coercing operator (such as ==), it converts to the value it represents. Why?

The reason is actually pretty straightforward, even though it’s not obvious when looking at it. if statements convert the result of their expression to a boolean primitive, whereas == converts the right side expression into the type of the left side and checks for equivalency. So if statements don’t do type conversion at all until the expression is evaluated, and then it implicitly converts the result of that expression into a boolean primitive.

JavaScript is really just doing this:

Where the weirdness comes in is how type converting an object works. If you look at the JavaScript spec, you can see that converting an Object to a boolean is always true. And guess what? Instances of Boolean are objects:

Since new Boolean instances are objects, they will always be true when converted to a boolean primitive, which is exactly what the if statement is doing.

So then, why does new Boolean(false) == false result in true? Well it’s because the rules are different for ==. Let’s say you’re doing false == new Boolean(false). This will result in true because the left side of the expression is a primitive, so the interpreter will convert the Boolean instance, not to a boolean, but to a primitive. When converting an object to a value, the interpreter will:

Return a default value for the Object. The default value of an object is retrieved by calling the internal [[DefaultValue]] method of the object, passing the optional hint PreferredType. The behaviour of the [[DefaultValue]] method is defined by this specification for all native ECMAScript objects (8.6.2.6).

And, you guessed it, the default value of a Boolean instance is just the boolean primitive that it represents. So, after conversion, we’re testing false against false which is of course true.

The other direction also works. If we’re doing (new Boolean(false)) == false , then the interpreter will convert false to an Object. The spec specifies that to convert a boolean primitive to an object, it should:

Create a new Boolean object whose [[value]] property is set to the value of the boolean.

So then we have two equivalent Boolean instances being compared, which again results in true

Pretty crazy, but it kind of makes sense when you think about it. Maybe.

Today’s complex web apps have a complicated mish-mash of server-side templates combined with client-side JavaScript. Often times there are certain calls to the server that return HTML, and others that return JSON or XML for client-side use. This not only distorts the “view” portion of MVC, but it can also be hard to develop for and, increasingly, slow. At rdio, we thought that we may be able to see substantial performance improvements across the board if we changed our templating engine from Jinja2 on the server-side to a custom, client-side templating engine. We found this to be quite true in the end, and the majority of the pages found on rdio today use Bujagali (the name we gave our system).

Goals

The goals for the project were pretty ambitious.

• Trivial to convert from Jinja to Bujagali
  • Support template inheritance
  • Support importing shared code
  • Support filters (essentially just functions accessible from the template)
• Make heavy use of client’s cache
• Reduce bandwidth usage to being as close as possible to the size of the actual data required to render
• Perform really, really fast on good browsers
• Not have terrible performance in IE
• Optionally render server-side to support googlebot and other limited JS environments

We achieved these goals, and you can learn how to use the engine and play around with the source on github. Be warned, however, that documentation is sparse right now.

If you want to learn how all the insides work, keep reading.

Architecture

The architecture is pretty simple on the surface. It comes down to heavy caching, robust versioning, a laissez-faire syntax, and flexibility in runtime environment.

A quick note about measuring performance: it’s hard. Bujagali is optimized to perform better over time, to get you your data faster by utilizing smaller payloads, and to actually be fast once we were shoving data into strings. To top it off, it performs differently depending on your client. It’s hard to do an apples-to-apples comparison of overall template performance in a case like this, but suffice it to say that we measured performance extensively at rdio and Bujagali is way, way faster in most cases than the previous Jinja2-based system. I hope to write more about performance in the future.

Caching

When it comes to caching, there’s one overriding rule: templates themselves are very cacheable, data is not. I also did not assume that the application JavaScript was very cacheable since in rdio’s case it’s not. After all, we roll out new versions of the site every day and since the application JavaScript is compressed into one file, your browser almost always has to reload the JavaScript whenever we roll out a new version. I wanted to avoid this in the case of templates for a couple of reasons. First of all, most of the templates change quite a bit less frequently than the JavaScript itself, and second, including all markup on the site would increase the size of the rapidly-changing JS file enormously.

To maximize cacheability of the templates, we turn to the browser cache itself. Each template is just a JavaScript file that contains a JavaScript function of the same name. By including the version of the file in the file name and telling the browser to cache it til we’re all long dead, we can assure that the turnaround time for the browser to get the template loaded into the program is really low. In fact in some versions of IE, loading a script that is contained in the cache is a synchronous operation. This is better explained through a bit of code.

As long as we carefully keep track of versions, we can be sure that the function loaded by the above script is the one that we want and that if the template does not change, it will never require another trip to the server to retrieve. In practice, this is a huge win as the full markup of your site really only has to be transferred once.

Versioning

The next overriding principle was strict versioning. This was pretty much necessary as a result of the heavy caching. Every time data is passed into Bujagali to be rendered, it must specify what version of the template it expects to be rendered against. By providing this information every time, we can be sure that the templates always work right in pretty much every possible proxy and caching set-up. A cool side effect of this is hot-swappable templates. If you modify a template server side and an ajax request comes in for data that’s supposed to render against that freshly modified template, Bujagali will reload the template and render it seamlessly, no refresh required.

Laissez-Faire Syntax

The final part of designing Bujagali was figuring out what we would actually allow in the templates. Jinja is very strict about what you can and cannot do. Bujagali is not. You can just write arbitrary JavaScript, and in fact writing a template in Bujagali feels a lot more like writing JS than it does HTML. This isn’t because I think there should be logic in your templates (I don’t), but I think that it’s up to the developer to decide what constitutes “program logic” and what constitutes “view logic”. Having a full-fledged language can be very useful in a template, and so arbitrary JavaScript is perfectly acceptable in Bujagali. It’s a language you already know and it won’t get in your way. An example comes from one of rdio’s own templates:

Flexibility in Runtime Environment

Despite the fact that Bujagali allows you to execute arbitrary javascript, it does not make a lot of guarantees about the environment. Bujagali requires the Underscore.js library, so it will always be available to templates, but beyond that it makes no guarantees (although it is extensible, so you can ensure that your own objects and helpers are available). This restriction gives us the flexibility to render templates either on the client side or on the server side using a server-side JavaScript environment like node.js.

This restriction on environment does have some practical benefits that keep the templates “clean”, despite the arbitrary JS that is permitted. Without access to the DOM or the rest of the running program, side effects from the templates themselves are limited. This restriction is not actually enforced by Bujagali itself, however, instead you’ll just get burned if you don’t stick to the restriction and then try to use your template in a different context.

Try it out

I’ll write more about actually using Bujagali in the future. However, the code is available now on github. The documentation is a bit thrown together right now, but it’s hopefully enough to get you started. There’s some infrastructure required since, unlike a normal templating system, this system spans the boundary between client and server. Luckily the code provided should make it fairly easy to get going if you already know what you’re doing.

It should be stated that this isn’t exactly a templating system for the faint of heart. Best of luck to all who venture on to github.

• 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.