I’ve previously mentioned that I work on the Platform team within my current company, as the caretaker of our central UI widget repository. As part of an ongoing effort, we’ve been in talks with our offices in Washington, D.C. about how to share some of the development effort between our teams, and get the most out of the finite front-end engineering resources we have at our disposal. In our most recent round of collaboration, there was some terminology brought up that I really liked as a method of conceptualizing the building of widgets, and how they should relate to each other. It was put into the context of the building blocks of life itself: Elements, Compounds, Cells, and Organisms. Continue reading →

I have my first large-scale public presentation coming up in about a month and a half, at the jQuery Conference here in Austin, TX. My topic is about getting the most out of jQuery UI Widgets, mostly dealing with some tips and tricks I’ve either learned or developed over my own time in working with the factory. Some things I’d planned to present were still just conceptual at the time I made my proposal. One of them almost bit me in the ass because of something I hadn’t considered, but having just nailed it with some help from something buried in the bowels of jQuery, I feel compelled to write an article about it, to deviate from some of the more basic, foundational things I’ve been writing about lately. Continue reading →

If you come from a more traditional programming language like C++, Java, or even PHP, you’re probably already familiar with the concept of encapsulation. So what is encapsulation? It’s the act of hiding some parts of your code from some other parts of your code, and only exposing what’s deemed necessary for the consumers of that code. Think about it as your custom object types providing an API, or interface, to any external code that might be consuming the functionality your custom objects provide. Continue reading →

Javascript object prototypes are a topic that’s very near and dear to my heart. Not nearly enough developers make use of the prototype object, or contemplate the overhead of prototype chaining of deeply nested object constructors. Some people use them, but not quite correctly, as in they don’t exactly know where to draw the line in the sand between what should be stored in an instance of an object, and what should be stored in that object’s prototype. This post will attempt to demystify javascript prototypes, and to make them a weapon of choice in your developer arsenal. Continue reading →

Javascript only has and handful of primitive data types: string, number, boolean, null, and undefined. So what makes a data type primitive? For one thing, primitive data types have no members whatsoever; they are strictly a value that can be assigned to a variable or compared against. For another, any variable references to a primitive type are passed from function to function by value rather than by reference, as typical objects are. Continue reading →

What is an object instance? Put simply, it’s any reference created with the “new” keyword.
Continue reading →

This is going to be an opinionated article, but I believe there is a difference between a Javascript Developer and a Front-end Engineer. The difference is one of code quality. I’m not saying that to besmirch any javascript developers out there, but rather to highlight a shortfall found in a lot of them. The tone of this post may come off a little condescending in some places, but I don’t intend for it to be. This post’s main focus is on making us all realize that there are plenty of things we don’t know, no matter where we are in our career.
Continue reading →