JavaScript for Line of Business Applications

I’m often still amazed at just how well Ember deals with complexity.

Ember Components are one of many reasons for this, they very neatly allow us to create decoupled views which can be reused throughout our application. Below tag editor component which consists of 30 lines of clean JavaScript. (view the source on jsbin)

Directives make our lives easier when you can reuse them without needing to read or edit the source code. Then we can forget how they work, and just remember what they do.

If you’re coming from a view-centric framework, like Backbone, you may be tempted to separate your application into view-like directive chunks. For example, if you want to display a list of users, you might create a directive that reads $scope.users and prints them all out:

The user-list directive works. I mean, look how DRY it is! However, contrast it withng-repeat, which handles only the repetition. Which one could be used in more places? What if you need to display users differently in two places?

jTypes is the most comprehensive and robust JavaScript library for overcoming differential inheritance with prototype-based objects.

jTypes will provide you with the ability to develop robust, modular, and scalable application libraries in JavaScript using encapsulation, inheritance, and polymorphism. What exactly does that mean? You know all those keywords from languages such as C++ or C# that you started missing quite badly after you transitioned to JavaScript? You know what we're talking about; all those modifiers of classical inheritance such as virtual, abstract, and override or private, protected, and public that gave you so much more control and freedom with your libraries. Well jTypes lets you use those keywords in JavaScript, so you can develop extremely powerful and robust web applications using the principals of classical inheritance.

When discussing functional programming we often talk about the machinery, and not the core principles. Functional programming is not about monads, monoids, or zippers. It is primarily about writing programs by composing generic reusable functions. This article is about applying functional thinking when refactoring JavaScript code.

At its core lucuma helps with creating custom HTML tag elements (Web Component) encapsulating content, style and logic. It is not a fancy MV* framework and aims at being a thin layer building on top of next generation web standards (mainly Custom Elements and Shadow DOM). 

It also makes the extra effort of being flexible and open to existing ClojureScript standards and libraries.

Lucuma is conceptually similar to polymer, x-tags or Polymer.dart.

I've been working with node.js almost a year. Here's my tips for new node.js users.

* Make it Named
* Unreference earlier
* No copy
* Careful when involve new modules
* Use async or promise
* Client may be very slow
* Emit when finished, or even later
* Maybe more?

A reusable AngularJS directive leveraging HTML5 Drag and Drop and the FileReader API.

Directives allow you to create new HTML elements, attributes, classes, or comments that can transform the behavior of the DOM. A better way of thinking about directives is “a way to teach HTML new tricks.” In this example, you will see how to leverage directives to solve a common drag and drop problem that can be reused in the future.

Creating a directive with AngularJS is easy. Check out how I made one to handle errors effortlessly.

In our CampNG class, we have a section on adding validations and error messages. Having to add a span for each possible validation error is pretty tedious, so I thought I’d have a go at writing a directive to do it. One thing that was interesting about building it was making it configurable. I haven’t seen much info out there about how to do this, so I thought I’d talk about how I did it.

Kat had a great idea for measuring time people spent in meetings. A cumulative counter that measures time faster the more people that are in them.

The result was Hyperclock, built in meteor, theoretically supporting websockets -but it's hosted (free) on heroku ;-)

I hadn't developed a project in meteor before so I learnt some stuff about it along the way:

*  Where does everything go?

*  Autoupdating

*  Mongo

*  Drawing

*  Save safely

*  Have a go! (maybe)

What should I be testing and when should I be writing tests?

I think it's essential that you learn to love the feeling of having a water-tight app. One which you know is not going to, you know, suddenly die the moment someone else starts making changes.

It might just be me, but when you've written a nice function, and you've verified it works the way it should, it feels solid. You see green ticks on a command line, all tests passed. BOOM! You've just written some of the most solid, reliable code that's ever been written!

Level 3. Mocking

n general, applicative programming is the pattern of defining a function that takes a function and then invokes that function for each element in a collection/list. To apply this definition of applicative programming to JavaScript, you will need to know a little something about first-class functions before we dive in. So, let's start there.

JavaScript has first class functions. This means that instances of the Function constructor can go and do anything any value in the language can do because functions in JavaScript are values.

Web components promise to bring reusability and encapsulation to the next version of JavaScript. The bad news is that their power is out of reach until mainstream browsers fully implement the ECMAScript 6 standards that make up web components. Fortunately for Ember.js developers, the power of web components can be leveraged today in the form of Ember components. Ember components share more than a similar name with Web Components, they aim to adhere as closely to the W3C Web Component spec as possible.

In this article, I’ll show you how to use Ember components to build a reusable building block for a scrum card management application. For those of you who have never used Ember before, don’t worry, we’ll also cover some of the basics of Ember.js that you need to know.

There are many design patterns used in Javascript and I would recommend taking a look at Javascript Patterns by Stoyan Stefanov for a full introduction to the most widely used patterns. Of the design patterns available, the Module pattern has gotten the most recognition in the past few years thanks in part to the maturation of the module pattern via commonjs as well as the wild success of node.js.

In a nutshell the module pattern allows you to create code that can expose a public API while safe guarding private variables and methods behind a pseudo blackbox.

We’ve looked at the basic Module pattern and seen how to use it to create some really powerful Javascript. We then took a look at how AMD works and how we could easily change our code to build our modules following the Commonjs specification for asynchronous modules, lastly we took a look at the bleeding edge harmony modules specification. I find that it is easy to see the beauty of where ECMAscript 6 is heading, with respect to modules, when you take a look back at where we’ve already been and how we’ve evolved up to this point.