JavaScript for Line of Business Applications

With a focus on their philosophy (vs practical usage tips)...

Agenda
* Derby.js/Meteor.js - Common Concepts
* A little more about Derby.js
* A short Derby.js demo (Oooooo)
* A little more about Meteor.js
* A short Meteor.js demo (Ahhhhh)
* Discussion & Beers (Yummm)

In a nutshell, it's a property whose value is computed the first time it's asked for. You can defined the computed property as a function and when someone asks for it, Ember will automatically invoke the function and treat the return value like value of the property.

y default, all computed properties are cached. That means that once you requested the value of computed property (called get on it), it's going to compute and cache its value. Computed property gets recomputed when any of the properties it depends on changes.

* How is CP different from Observers and Bindings?

* What do I use and when?

* Painlessly generate Knockout syntax with strongly typed, fluent, lambda expression helpers similar to ASP.NET MVC
* Rich intellisense and compiler support for syntax generation
* Fluent syntax makes it a breeze to create custom helpers or extend whats built in
* OSS alternative to ASP.NET MVC helpers: feel free to add optional features that everyone in the community can use and I'll merge your pull in ASAP!
* Painlessly provides validation based on .NET types and DataAnnotations in a few lines of code for all current/future application types and changes
* Client side JavaScript object factory (based on C# types) to create new items in for example, a list, with zero headaches or server traffic

Durandal.js is a new framework that uses Knockout, jQuery, Require and Sammy that makes it very easy to create single page applications. It 'just works' with Knockout and feels very clean so I have created the Survey App using it. Also take note other than for the start page and WebAPI MVC isn't used at all for views. This seems pretty natural so far but time will tell as it is built out.

Take a look at Survey App demo to see a full demo using Durandal.js

We have invested a lot of time in our unit and acceptance testing, but we also need to test our application after deployment or on a staging infrastructure.

We have looked into several tools, including Selenium and Testacular, but found that CasperJS provides the perfect mix of being easy to use and being powerful enough for our purposes.

We wanted a tool that doesn’t have any dependencies on languages or frameworks a team may use. While tools like Capybara are great and neatly integrated into Rails they still need some effort to be set up. And if you don’t use Rails you are out of luck.

We also wanted everyone on our team to be able to write tests with it. The syntax therefore needed to be easy and comfortable for all of us. CasperJS is based on Javascript but has Coffeescript support built in. WIN!

I've started using the Revealing Module Pattern a lot more than I ever have before. While many things have contributed to this shift, one feature, or lack thereof, was the inability to use Base Controllers in AngularJS. Since Controllers cannot be generated within Factories, it seemed that Base Controllers could only be provided through global references (which goes against everything that AngularJS stands for). That said, after my conversation yesterday, I wanted to give Base Controllers one more try.

NOTE: This is just an experiment in using Factories to generate Controllers. I am not necessarily advocating this approach - see final paragraph.

In JavaScript, when you invoke a constructor function, the return value of the construtor matters. If you don't return anything, JavaScript will use the instantiated object as the result of the invocation. If, however, you return a value (other than "this") from the constructor function, JavaScript will use that return value as the result of the invocation.

When it comes to AngularJS, we can leverage this language feature to fake the ability to create Controllers inside of Factories. The idea is simple, but a bit confusing. And, after some trial and error, I finally got it to work. What we're going to do is turn our Controller into a factory.

So it's probably fairly easy to see, if I like JavaScript and I like static typing, why TypeScript could seem apper attractive prospect. And here was a nice little project that was non-trivial but still pretty compact that I could try it out with.

The type annotations in TypeScript are optional, but since I'm writing the code from scratch it makes sense to use them throughout. Interfaces are defined but do not need to referenced by types that implement the interface - so long as they have all of the required properties and methods then they will implicitly be considered to implement the interface. This is like Google's Go language and not like C#.

One thing that I don't like too much is that it isn't currently possible to specify an interface with readonly properties. It must be a property with a getter and setter or nothing. So I've resorted to specific Get methods on the interfaces instead, such as GetColour() and GetState().

In Ember.js, routes and templates dictate the architecture of your app. This presentation will talk about why this is, and what tools Ember provides to manage architectural complexity.

The topic of Search Engine Optimization (SEO) pops up quite often, when disadvantages of Javascript MVC frameworks are discussed. Naturally webapps written entirely in Javascript are not crawable without any actions taken by you. In this article i will discuss the fundamental problems of javascript mvc apps in this topic and then i will present a solution for EmberJS Apps.

All crawling approaches basically need to solve two problems:

* Search Engines must be able to discover URLs, which should be crawled.

* Your server must be able to respond to these URLs, when the Search Engine crawler asks for it.

Let’s first discuss these two problems and possible solutions. Afterwards i will discuss two common approaches adressing both problems.

We ran into a situation where we wanted to be able to close our ember.js view (a modal) when the user pressed the esc key.

We could have also just defined a keyUp method directly on the view, but it's always fun to play with new stuff. Unfortunately, this didn't work. It looks like it should and it fact it does exactly what you've asked it to do. It watches for keyUp events on the view, but not global keyUp events. The user has to click on some part of your view to give it focus and then press the esc key. We even tried setting the focus and add tabIndex="0" to our top level div. Those techniques kind of worked, but it still didn't feel right. We found that we still had to click on the page to get the keyUp event to make it into our view. For end users that wasn't going to work so back to our original code we went.

PHP is not going to disappear soon, but its position is being undermined even further by the nascent Node.js. When the Internet exploded in the 2000′s, PHP was the thing ”all the cool kids” did.

Over the years, PHP and its apps became vulnerable to security threats (e.g., SQL injections), lacked a centralized packaging registry (was Composer inspired by Node Package Manager?), had an inconsistent API and suffered from subpar performance. It’s easy to argue that there are better alternatives to PHP, for example Ruby on Rails and Django, however nothing is as approachable as Node.js.

For those of you who aren’t familiar with Node.js, or who have heard of it but can’t quite grasp the concept, I like to say that it is functionally similar to the PHP + Apache or ASP + IIS stacks. Nowadays, it is also gaining momentum.

Many people, whether software engineers or entrepreneurs, are often faced with the decision: “What tech stack should I use?” In this article, I’ll try to compare PHP and Node.js using an apples-to-apples approach, looking at the question from different angles including:

* Syntax

* Context switch

* Modules
* Ecosystem
* Frameworks
* Real-time apps
* Database apps
* Third-party services apps
* Web servers
* Hosting
* Performance

ExtJS is a powerful Javascript framework for developing rich Internet applications—but with great power comes great responsibility. If you are inexperienced or careless with your implementation, your development effort can quickly spin out of control. Your project structure might grow to become unruly, steepening the learning curve for developers new to the framework. Worse yet, performance issues may arise that can be tricky to deal with once they have a foothold within your application.

Equipped with some tips from Senchacon ‘13 and my past experience with ExtJS, I’d like to share some knowledge that will help you be proactive against these issues and avoid potential roadblocks.

I am currently working on a project called Cloak, which is a network layer for multiplayer HTML5 games that handles lobbies, rooms, chat, reconnection to games, and so on. Cloak has both a client and a server component and handles all the communication between them. Traditionally this would be a huge hassle to write automated tests for, but Node.js has made it easy. Our tests use Nodeunit to run the actual Cloak server and actual Cloak clients at the same time! For example, one test configures a server to automatically create rooms when two users connect, then fires up two clients, connects them both, and confirms that a new room was created for them.

I have always been in favor of writing the types of tests that are most valuable for the application they’re testing. What I just described might be called integration testing(as opposed to unit testing), and to me that is exactly the kind of testing Cloak needs in order to really build confidence in the correctness of the library. Integration testing can be quite challenging on many platforms. Consequently, I’m all the more pleased with my results doing integration testing for Cloak.

As awesome as Google's crawlbot is, it doesn't view your website like a real human does. If your page requires ajax requests to fire and javascript code to populate the DOM in order to view anything useful, Google won't see that. Here's how I've solved this problem for this blog.

I know you're like me and want a recipe instead of pouring over official documentation, so here it goes.

Google requires you to have not just a hash (#) be the delimiter right before your webapp's route, but a hashbang (#!). Ember doesn't support this out of the box, so we need to register a new type of location implementation.