JavaScript for Line of Business Applications

A look at the angular source code reveals some nifty tricks that border on Functional Reactive Programming.

Most angular devs I’ve talked to use $scope.$watch sparingly and as advertised: for DOM manipulation inside directives.

For the unfamiliar, each time $scope.prop changes, our callback gets invoked and updates the DOM. This is, in fact, the same API that angular uses to implement one direction of its two-way data binding.

at most devs don’t know is that $scope.$watch takes an expression, not just a property name.

MVC4-Boilerplate - A boiler plate for MVC4 vb.net web applications

* Modernizr
* HTML5 Boilerplate
* Bootstrap
* Font Awesome

During the workshop I explained exactly how to take a single player HTML5 game and turn it into a multiplayer one using Node.js and WebSockets.

Each player is identified using a unique client.id number. We'll use this later when communicating game updates to other players. For now the util.log line will output the client identification number to the terminal on connection.

The client.on event listeners are used to detect when a player has either disconnected or sent a message to the server. Right now they point to handler functions that don't exist.

The benefit of automation is in time saved. If we can pinpoint tasks that we do repetitively during development and automate them, we can save large amounts of time that could be put back into doing more coding, thinking, learning, laughing, beering - the list goes on.

While going through the basics of CucumberJS in the previous articles, I was demonstrating how I use the tool to TDD from the outside-in and constantly hopping back and forth from my code editor to the terminal to run this simple command over and over:

Now, I am pretty good at CMD+TAB - not to brag - but I would much prefer to get feedback on my tests instantly as I describe my asserts and modify my code. If we automate the running of Cucumber on file change, we can start seeing results quicker and we can take that time removed from manually switching between editor and terminal and running commands and put that time back into thinking how to design our code more cleanly :)

This automation and instant feedback really shows its worth in the Refactor phase in which you have previously implemented code to pass the criteria in a Feature.

Having talked to many developers, we found out that there is a huge demand for topics around engineering of SAPUI5 applications. The dynamic nature of JavaScript makes the language very powerful, but it is also challenging to build maintainable products with huge codebases. To counteract the tendency to messy codebases, we have to establish conventions and apply good engineering techniques. This blog post shall act as an overview about the different topics like testability, test driven development, local testing, continuous integration, agile software engineering, tools, setup of development environments, and clean code.

Setup of Development Environment:
* Setup for Local Testing in Eclipse

Testability:
* Starting with Test Driven Development in JavaScript
* Getting more out of your JavaScript unit tests with strict mode
* Basic Patterns for Testable JavaScript Code
* How to Unit Test Custom Exceptions with QUnit
* Unit versus Integration-Tests in JavaScript
* Isolated Integration Tests
* How to improve the testability of a SAPUI5 app
* How to test against SAPUI5 views in a non-fragile way
* How to replace an ODataModel by a JSON Model

Tools:
* TDD and JavaScript - JavaScript Unit Tests for UI5 Applications

I'm a massive fan of JavaScript's Module Pattern and I'd like to share some use cases and differences in the pattern, and why they're important. The Module Pattern is what we'd call a "design pattern", and it's extremely useful for a vast amount of reasons. My main attraction to the Module Pattern (and it's variant, the Revealing Module Pattern) are because it makes scoping a breeze, and doesn't overcomplicate JavaScript design.

It also keeps things very simple and easy to read and use, uses Objects in a very nice way, and doesn't bloat your code with repetitive this and prototype declarations. I thought I'd share some insight as to the awesome parts of the Module, and how you can master it and it's variants and features.

Learn how to create a re-usable component in your next project using Knockout.js.

Often when building more complex applications, instead of repeating the same template and binding logic, you’ll want to isolate it as a unit of UI functionality and re-use it throughout your application. When starting out with Knockout.js, however, it’s not always obvious how to do this. In this post I’ll run through creating a pagination control as an example of how to create re-usable controls in Knockout.

One of the benefits of building Meteor applications is that you don’t have to think about client-server APIs anymore, since Meteor’s built-in collections handle synchronizing data to the browser for you.

But this new paradigm comes with its own requirements: order to limit the amount of data and maintain privacy, any real-world app must also include a set of publications and subscriptions in order to make sure the right data is transmitted to the right users.

Consequently, publication design is a very important part of building a large scale Meteor app, and it’s often a new challenge for even the most experienced of web developers. So today, we’ll take a look at one of the trickiest problems of publishing data with Meteor: joining across collections.

When writing robust JavaScript code, you will probably want to throw exceptions to let programmers know when they’ve misused your API. Sure, you could throw an instance of the built-in Error object, but then during unit testing how will you tell if the exception you’re seeing is yours and not coming from somewhere else?

The solution is to use a custom exception in your method, but this opens up a whole new can of worms. JavaScript’s weak typing and poor support for sub-classing Error mean that a custom exception class can easily be created with no error message, or even worse with no stack trace!

Today, I’m going to help you solve both these problems, and introduce you to a neat, undocumented feature in QUnit that will help you unit test your methods.