JavaScript for Line of Business Applications

JavaScript is a nice language but it does not offer static type checking and object oriented programming. There are ways to simulate object oriented behavior but still there is no in-built way. Hence things gets really complicated while developing large scale applications in JavaScript.

To deal with this situation, developers have come up with new languages which offer more functionality and features but they still get compiled into JavaScript only. So, you can develop applications and games in languages other than JavaScript but they will still run on web browsers as the compiled output will be a JavaScript only.

Several languages have been built upon JavaScript including some famous ones like coffee script, type script, Dart, etc. In this blog, we will talk about TypeScript.

Odds are you have been asked recently: “How does KnockoutJS compare to AngularJS?” There seems to be a lot of attempts to compare these two awesome libraries. We can certainly compare them, but will this really get you where you want to go?

If you hear this question, ask “why” the person is asking it. If s/he wants a JavaScript/HTML based presentation framework then suggest that you compare Durandal to Angular. Why? Because Knockout is at heart a data-binding library, while Angular and Durandal are presentation frameworks. This is a hugely important concept to grasp, so let’s break down what’s at the heart of these questions and how Knockout, Durandal and Angular approach them. But let’s be clear: Knockout rocks. Durandal rocks. Angular rocks.

I have a guilty pleasure. I admit it… I really like Node.js. Node.js is a framework for writing Javascript applications outside of a web browser. In the spirit of Atwood’s Law, it has a number of powerful facilites for writing networked applications. Not only can you use Node.js to build server-side webserver/websocket code, but I’ve found that I like to use it for my random scripting needs. So I set off looking at what web scraping libraries were available for Node.js and found Cheerio. Cheerio is a library for Node.js that allows you to (with no browser required) construct a DOM out of a given piece of HTML and do jquery-like CSS queries on it. Brilliant! Given the advent of CSS and CSS driven styling… What is just about the only organizing factor within web pages out in the wild?… Well CSS of course. These days folks more often than not use CSS classes to style various structural aspects of their web pages. 

The PeepCode Ordr app is an excellent video tutorial for learning Ember.js and also a great example of a browser application for writing tests in JavaScript. Learning Ember.js is a task in itself, learning to test an Ember.js comes with an equal level of challenge. This article is a collection of observations for an exercise in testing a non-trivial Ember.js application, specifically the Ordr app code from the PeepCode tutorial Fire up Ember.js video.

These comments on testing are based on a exercise with a group of hackers from the Ember-SC meetup group in Southern California. Drew, Scott, Ty and myself spent some time trying out various ways to test an Ember Application.

The journey went something like this…

* Try Jasmine because we love BDD

* Try Mocha because it’s newer and it’s used with Konacha

* Try QUnit because it may be better with async tests then the above and the Ember.js project uses it anyway

* Wow Ember.js has testing helpers in the ember-testing package, lets rewrite the integration tests

* Try Pavlov since is provides BDD style spec runner on top of QUnit

* Just use TDD QUnit test runner

In getting started with the exercise we talked and asked…

* What is important in testing an app built with Ember.js?

* Because the Ember.js framework has solid test coverage for the API it provides, is the main gap making sure an application’s compontents or modules work together?

* The underlying behavior of the framework features and API should just work, what should we not test?

* Unit tests are needed, but it would be great to have integration tests that run super fast in a JavaScript runner.

* Perhaps integration or end-to-end testing is the main objective for our exercise.

This paper provides best practices and guidance to web developers who are interested in AngularJS or other client-side MVC technologies and want to optimize their server backend for these technologies. You will learn how to leverage AngularJS with Google Cloud Platform and, in particular, Google Cloud Endpoints, a technology that let developers expose their backend APIs of Google App Engine applications through service-based API, instantly with simple annotations.

Google Cloud Endpoints makes it easy to build a server-side API and encapsulate the backend boilerplate logic. Incorporating the Google Cloud Endpoints JavaScript client library into AngularJS is so straightforward that you can write a single line of code to call server logic and a callback function to update model properties with the result.

The intended audience for this paper is Java developers with some experience with App Engine and a basic knowledge of JavaScript. Links to the AngularJS and Cloud Endpoint web sites with reference guides are provided in another section and troubleshooting tips are provided in the Appendix. If this is your first time writing Java applications for App Engine,the Getting Started pages on the App Engine site provides a good introduction.

Most web-developers know about KnockoutJS, and I hope that most of them have heard about (or used) the amazing stuff that Wijmo delivers. If you do not know about Wijmo, here a short summary…

The goal with this post/tutorial is (as stated above) to create a Wijmo line-chart and make it alive with some real-time data. To have some data to display I will just randomize some numbers server-side.

NOTE: If you want to implement a working example your self, now is the time to create a new Visual Studio project (MVC3/MVC4) and add a default.html to the root of the project.

There's no shortage of Node.js tutorials out there, but most of them cover specific use cases or topics that only apply when you've already got Node up and running. I see comments every once and awhile that sound something like, "I've downloaded Node, now what?" This tutorial answers that question and explains how to get started from the very beginning.

Rich tools for instrumenting, analyzing, and visualizing web apps.
Make your app jank-free at 60fps! Squeeze every drop of performance out of your code.

* Rich Tracing
Choose what methods to trace and add custom data to each event. Track asynchronous flows and actions.

* Slick Visualization
Smoothly dig through millions of events in an awesome UI. See patterns and understand your code like never before.

* Extensible Framework
Write extensions to capture more data or visualize it in new ways. Write small node.js scripts to process traces and pull out useful data.

* Canvas & WebGL
Capture and replay HTML5 <canvas> and WebGL content. Write tools to analyze and test your drawing.

* Track Memory Usage
Find every byte allocated by every function via heap tracking. See not just the what but when and who of every allocation.

* Remotely Trace Android
Grab captures and analyze pages running on Chrome for Android using a simple remote controller.

Web Components have come a long way in the past few months and one of the technologies that I’m most interested in is HTML Imports (or “imports”, for short). Imports allow you to load additional documents into your page without having to write a bunch of ajax. This is great for Custom Elements where you might want to import a suite of new tags. I spent the day playing with imports and thought it would be useful to write up my progress.

A technical look at the reason why MongoDB sucks, why I'm migrating from MongoDB and goodbye MongoDB community posts. Is everyone leaving MongoDB?

For a guaranteed surge of traffic and to hit the Hacker News homepage, all you need to do is write about why you hate MongoDB and/or migrated to some other database. We’ve been using it to power our server monitoring service, Server Density, for over 3 years now and so with experience, many of the problems cited in these posts seem like basic mistakes in deployment and understanding.

Here are some of the things we wanted to do originally:
* Preprocess the index.html template
This lets us distinguish between builds for different platforms. E.g. Android vs. iOS vs. Web
* Compile the templates into a single template file
Less requests means faster load times. The single most important load time to minimize is the first one.
* Minify the CSS and JS
Both are interpreted languages which parse and run faster when there’s less characters to be parsed.
* Lint the existing codebase for semantic gotchas
A standard software engineering practice that catches subtle kinks in the code before they get out of hand.
* Run shell tasks as build phases
Handy for moving files around or further automation during intermediary stages of a build process.
* Connect to the PhoneGap Build system
We used this system in the early stages of the app to keep things relatively uniform across Android and iOS platforms.

a humble 115 slides about JS and its programming patterns in a practical context

Part of the KoLite tools created by John Papa for knockoutJS was the activity indicator. The nice thing about it (as it claims) is that it supports starting IE 6.0 (ughhhh….) For those who don’t have the luxury of developing for modern browsers ONLY  (i.e. CSS3 animations), this utility is very appealing.