JavaScript for Line of Business Applications

It was 18 years ago today that JavaScript was announced in a joint press release by Netscape and Sun. That week, Michael Jackson's "Earth Song" was in the charts, and in 17 days Ruby would launch its first version too.

Netscape and Sun aren't with us any longer, but JavaScript is most definitely still with us. As those titles suggest, its original corporate parents had absolutely no idea what they were doing or what JavaScript would become. But there's a lot to be said for being given the opportunity to succeed by being put straight into the browser back when a single company could make a decision like that.

* Timeline of an unlikely evolution

* JavaScript in Numbers

* What next for JS?

The panelists discuss JavaScript tooling: how to select them, benefits of compiling to JavaScript, differences between MVC solutions, using one framework for both client and server, etc..

With Robert Hanson, Brian Ford, Tim Branyen, Yehuda Katz, Avital Oliver, Lukas Ruebbelke.

Welcome back to the PhoneGap and AngularJS series. In past articles we got your solution setup, dealt with the notification service, displayed some external web content, and next up we are going to search the contacts on your device.

The contacts API in phonegap is fairly extensive and has certain quirks depending on the device you are using so we are going to focus on a few simple actions which include finding, edit, and, creation.

PhoneGap and AngularJs, The Series:
1. The Start
2. Notification Service
3. In App Browser
4. Contacts

This article explores the various ways you can create objects with the JavaScript language, and through this exploration finds that there is much to learn about the language!

* Introduction
* Plain old objects
* Constructor functions
* The inner workings of 'new'
* Exploring the prototype chain and instanceof
* When is a prototype not a prototype?
* The constructor property
* The confusing world of 'this'
* Private parts
* Using closures for private state
* Summary
* Conclusions

* Videogular is developed with AngularJS and it will fit in your project like a charm.

* Videogular's directives are bindable, just try the demoand play with bindings.

* Thanks to our API you can develop your own plugins.

* Customize it with your own themes and change between them on the fly.

* Enjoy with native fullscreen support for Chrome, Firefox, Safari, iOS, Chrome for Android and Windows Phone.

* Videogular can detect mobile devices to show/hide components in case that aren't supported.

I have created this ember.js component that allows a user to hook up a data source that can be filtered via user input and then added to a destination...

You have most likely used something similar when you have been adding tags to some sort of entity.

The component is declared using the hyphonated convention like this...

I’ve recently been working on a simple Ruby on Rails web app that uses AngularJS on the front end. Angular provides us with a number of nice client-side features (two-way data binding, form validations, easy to use UI widgets, etc.), but we chose to use Rails for routing the entire site. Therefore, the Angular app is embedded within a rendered Rails view. This choice raised a practical question: how do we expose the Rails data (instance variables, params, etc.) to the Angular app’s controller(s)?

I’ve seen many developers asking how to access Rails params and instance variables within their own Angular controller code (often to make calls to $resource and $http for their CRUD operations). The purpose of this blog post is to describe four approaches I found to solve this common question.

In these examples, I have a single Rails model: Item. Each item has a name, a cost, and an id value...

In the current era of web application development, Single Page Applications (SPAs) are often demanded by customers. Currently there are lots of different frameworks available for developing web application, most of these are server side frameworks e.g. ASP.NET MVC. But one of the important aspects for Web development is to provide Rich user interface with UX (user experience). Thankfully there are several JavaScript client side frameworks available to get this thing done e.g. jQuery, Knockout, Backbone etc. Using these frameworks, a developer can develop Rich and better UX applications. 

Ember provides a LOT of powerful abstractions. With all that power, it can be difficult to know what tools will best add meaningful functionality to your app while gaining leverage for the future. The Ember docs will walk you through the roles of templates, controllers, models, and all the other pieces you’d expect in a modern JavaScript app framework, but what they don’t cover are tactics for using some of the deeper concepts of Ember (and functional JavaScript programming) to help you write less, but better, code.

Here are a few tools we’re using on my current project, a non-trivial Ember.js application, to do just that.

* Ember.computed Macros
* Inheritance
* Injecting other Objects
* Mixins
* Computed Property Generators
* Mixin Generators
* Further Reading

Under the hood only a few line items are important from a speed point of view in the average AngularJS application:
* DOM manipulation.
* The digest cycle that creates DOM updates when data models change.
* Latency for REST requests to the backend.

Vanilla AngularJS is usually fast enough on a desktop: modern browsers are very efficient when it comes to DOM manipulation, and small HTTP requests are fast over today's internet. Running the digest to process and update simple partials, directives, filters, and other code associated with the current view is also usually fast enough. When one of more of these items stop being fast, then that is when you start to run into issues and the need to spend time on optimization.

Most people considering Meteor for a production deployment are wondering if it can scale. Some say Meteor is a good framework for prototyping, but not for production. After you read this article, you’ll be able to decide for yourself.

Scaling Myth

With the emergence of cloud computing (and specifically Heroku), many have come under the impression that scaling means adding more instances of an application. That’s completely wrong.

Routing, sessions, job processing, static file serving, and database optimization are key concerns when it comes to scaling, among other things. Any Meteor app that intends to deploy into production needs to address–or at least consider–these issues. On top of that, Meteor has its own issues.

If you are a JavaScript developer, using MongoDB as your backend database is a joy. If for no other reason, you get to think of and interact with data as JSON objects. This serves to solidify the case for Node.js: those of us who live and breathe JavaScript on the client side, can now extend our skill set to include server-side development using the language we love.

The quickest way to get up and running with MongoDB in your Node.js application is to leverage Mongoose ODM. The Mongoose website defines it as a : “…straightforward, schema-based solution to modeling your application data…”. That’s a little deep for me. Suffice it to say, it makes interacting with MongoDB incredibly simple.

In this article, our goal is extremely simple: connect to MongoDB, create a record and then show that record in a web page. While we will barely scratch the surface of what is possible, we will, at minimum, accomplish our modest goal. I’m sure that, as a programmer, you’ll get halfway through this code and realize how much more is possible. You can then take this very basic code, copy and paste it into your own application and then build a more robust solution.

If you’ve done much reading about angularjs you’ve no doubt come across mention of karma, a test runner recommended especially for use with angularjs applications. The angular-seed project is a great way to get started with the basics of angular testing using karma, but for projects of any significant size you will soon hit the cieling in terms of organization complexity. What I want to share in this article is the approach I have taken using Grunt and the grunt-karma plugin to sustainably manage my projects’ client side unit tests and run them via TravisCI.

Web applications are useful, but there are some cases where it’s not desirable or necessary to host an application on a remote server. As HTML5 provides low-level functionality to modern browsers, such as the ability to read and write files, it’s now possible to create offline, single-page, JavaScript applications using a web browser as a platform.

The node-webkit project, which was created at Intel and open sourced in 2011, is an attempt to take the pain out of offline single-page application development.

The project provides a WebKit browser that has been extended with the the ability to control user interface elements normally off-limits to web developers. The browser’s security configuration is relaxed, assuming that the application code you’re runnning is trusted. And, most interestingly, the browser integrates Node.js, allowing node-webkit applications to leverage a wide array of functionality other than what HTML5 APIs provide.