JavaScript for Line of Business Applications

About a year ago SmugMug had a dilemma. Our upcoming site-wide redesign and refactor  (aka the new SmugMug) moved all of our rendering code into client-side JavaScript using YUI. We had a problem; SEO is critical for our customers and search engines couldn’t index the new site.

Possible solutions were thrown around: do we duplicate our code in PHP? Use an artificial DOM? What about PhantomJS? Duplicating code would be a monumental effort and a continued burden when writing new features. Initial tests of fake/artificial DOMs proved unreliable. A small prototype Node.js web server that hooked into PhantomJS proved promising. Node.js’ async model would be perfect for handling things that wait for I/O like rendering webpages. We came up with the project name ‘The Phantom Renderer’ soon after.

ngAnimate now supports staggering animations natively

With the release of AngularJS 1.2, a crazy, but hidden, feature was introduced which provides native staggering support to CSS3 transitions and keyframe animations with just a little extra CSS code. The $animate service, found within ngAnimate, will do the grunt work to render animations in a staggering fashion.

Still curious as to what a stagger is? Does Greensock ring a bell? Well if not then a stagger is an animation that occurs that contains a delay between each successive animation which causes a "curtain-like" effect to occur. Click here to see how GreenSock performs a stagger animation.

Backbone vs. EmberJS vs. AngularJS.

* "C” in MVC doesn’t exist in many of the new frameworks

Backbone has no Controller object to extend; it’s more like an MVP framework where the view does more than displaying data

* Angular has controllers and services … MVCS?

* Ember has controllers in a more um … classical(?) sense

* Backbone as sort of a “control”

* Oldest of the three, wildly successful and well-understood

* Angular and Ember because they seemed to have the most steam

Ah, the great and crazy Node.js Event Loop. Often talked about, rarely intimately known. What does the Node.js Event Loop do? What does it provide the programmer? Let’s dive in and talk about what the event loop is and does and how it can help you in your day to day development.

In the case of most pre-node.js Javascript, it existed in the browser and took user events manipulate the content of the rendered page in the browser. Manipulating these events were the only real interaction the code had. It was a single route of actions that the programmer had to deal with. Besides the DOM (that’s another whole discussion) the Javascript world on the browser side was relatively simple.

Enter server side JavaScript via Node.js. All of a sudden JavaScript now can deal with all of the interactions on a server. This changes the paradigm of JavaScript development dramatically, from a single event happening at a time to the need for many things to start, stop and evolve over time. So how does JavaScript, and Node.js, deal with this new complexity on the server side?

Welcome to part two of my series on learning Javascript. In this article, we'll create the classic Space Invaders game, step-by-step. For now we're keeping it really simple - no frameworks, just raw JavaScript and HTML. Here's a screenshot of what we're going to make. 

In part two of the learn JavaScript series we'll create the classic space invaders game.

One of the things I love about JavaScript is the fact that objects in JS are really just simple hashes of key/value pairs. What's nice about that is that the keys (properties, members, whatever you want to call them) are enumerable. So of course, we all know what that means, right? Right...you caniterate over JS objects. I mean, we all knew we could iterate over collections of objects, but the object itself? Yeah...its OK...I didn't realize it at first either, but its really nice to be able to do that. Knowing this opens up some nice possibilities, doesn't it?

Lets say, as an example, that you wanted or needed to write your own object extension/mixin functionality. Such a function would need to iterate over a source object in order to copy its members onto the target object, right? Lets take a look at how we might do something like that:...

Mark Michaelis walks you through the Visual Studio tooling and project setup you'll need to get the most out of your JavaScript unit testing.

Of all these characteristics, it's JavaScript's lack of type safety coupled with not having a compiler fail in the capacity to verify intent. That is, of course, if you don't have unit tests. Unit tests can compensate for the lack of type safety. And unlike with .NET, where unit tests focus mainly on functional verification (since the compiler eliminated the majority of typos), unit tests in JavaScript do both. In summary, JavaScript unit testing is all the more critical because it's responsible to not only verify functionality, but also to verify syntax and language semantics.

In this article, I'm going to focus on the Visual Studio tooling and project setup requirements needed to get the most out of your JavaScript unit testing.

At Artsy we’ve been building Node.js applications that share code and rendering between the server and browser. We’ve seen many benefits from this – pages load faster, we can optimize SEO, developers are more productive, and JavaScript coding is just an overall better experience.

Today we’re happy to announce Ezel, our open source boilerplate we use to bootstrap our Node projects and the various node modules that built up to it.

 In this article I’ll tell Artsy’s story of moving from a single monolithic application to modular Backbone apps that run in Node and the browser and consume our external API.

A monolithic app that treats it’s client-side code as a second class citizen was clearly not going to scale. Our poor mobile web experience was a good candidate to try something new. So we started building a separate mobile optimized website (m.artsy.net).

Some goals became clear:

* Better client-side tools from JavaScript testing to package mangers.

* Share rendering code server/client to reduce duplication and optimize initial page load.

* Flexibility. We needed a way to divide our app into smaller chunks with smaller asset packages.

Most of my projects revolve around real-world applications which utilize complex data architecture in SQL databases.  Exposing this data using RESTful approaches (more on that in a later blog post) and JSON consumed by the Sencha Model and Store objects is a godsend in developing robust, responsive web/mobile applications.

The process of taking SQL table and view definitions and converting them by hand to appropriate, well formed Model definitions was, to my lazy programmer side, a royal pain.Especially in an iterative, agile development environment where the under-lying SQL schema was going through as many changes as the front end code.

After finding myself, may times, chasing a bug or behavior that turned out to simply be the lack of synching the SQL data model to the Javascript model, I decided to work up a small time saver: A SQL function to generate the ExtJS/Touch model definition Javascript directly from the table/view definition - ExtjsModelGeneration.

Over the past few months, it has been really exciting to follow the phenomenal traction and explosive adoption of AngularJS, an Open Source framework for Web Application development, originally started by developers at Google and now receiving global attention.

Over the course of building a few PubNub-enabled AngularJS applications, we came across a bunch of patterns and features that we thought would be useful for AngularJS developers, for example:

* an Angular service to inject the PubNub object into controllers.

* an Angular-friendly mechanism for binding events to the root scope.

* additional bookkeeping functions for providing easy access to collections (such as the presence and channels lists).

We've known this for some time over here in the ClojureScript corner of the world - all of our collections are immutable and modeled directly on the original Clojure versions written in Java. Modern JavaScript engines have now been tuned to the point that it's no longer uncommon to see collection performance within 2.5X of the Java Virtual Machine.

Wait, wait, wait. What does the performance of persistent data structures have to do with the future of JavaScript MVCs?

A whole lot.