JavaScript for Line of Business Applications

For the past few months I’ve been sailing around the world of Angular. Today I can hardly imagine myself doing day to day coding on a large front-end web application without some kind of data binding framework, such as Angular.js,Backbone.js, and friends, and I can’t believe I’ve done so in the past.

This kind of interaction, data binding, and view synchronization would be easily be a maintenance nightmare if it wasn’t for a framework such as Angular. Being able to update a model in one place, and have Angular update all relevant views almost feels like cheating.

Angular enabled us to go places we wouldn’t ever have dreamt of, such as setting up a bunch of keyboard shortcuts that are enabled based on the current context of the application. For example, text editing shortcuts, such as ctrl/cmd + B to toggle bold text, are just enabled when we’re editing a text layer.

I will be showing how to build a grid that supports server side paging, sorting & filtering

My goal with this  is that i didn’t want to implement a more complex approach that will be hard to customize later, so what i ended up doing is implementing a solution that will show a list of data in a table like structure and implement a reusable solution for paging, sorting & filtering

Adam Stacoviak and Andrew Thorp talk with Sacha Greif about his new book Discover Meteor, Meteor.js, sustaining open source and more.

So you found Meteor, learned it in a day and started your next million dollar idea ... only to find your new masterpiece is slow as all get out. What happened? Well, the reactive nature of the framework needs to be used wisely.

When I first started exploring Meteor JS with the perspective of a PHP developer, I immediately applied my traditional thinking to Meteor's session: that they are a place to store data over time. Well kind of...

When you using your Collections, think about how that data is going to be used. If you can determine that you never need to update the DOM or HTML if the document(s) change, then you can tell Meteor not to make the query reactive. Then if data in the return documents changes, it won't cause your template to rebuild.

In this quick blog post I’ll show you how to create a simple VNC client in about 200 lines of JavaScript.
For our goal we’re going to use only HTML5 and JavaScript (client and server side).

Our application will have very simple architecture – a proxy server written in Node.js and a client in HTML5 and JavaScript. The Node.js server will stay between the browser and the VNC server. We need it because the client-side JavaScript does not supports TCP sockets so we can’t connect directly to the VNC server. The HTML5 client will have a canvas on which we will draw the frames we receive from the server.
For VNC server you can use the free version of RealVNC.

First lets start with the server. Make sure you have node.js installed. We will use four node modules: rfb2, connect, socket.io and node-png.

I was experimenting on creating an overall “busy” indicator for a current page. Normally, we would declare an ngClick directive if we want to implement some behavior/process when we click the button.

But if the operation takes  a long time, we have no visual clue (to the user) of what’s going on.

We want to change that! In my previous post, I used NETEYE activity indicator. This time, I will use spin.js (by the same author). What prompted me to use spin.js is that it doesn’t rely on jQuery anymore.

So how do we go about this?

This is the free online version of the DOM Enlightenment book in its pre-edited/draft form.

This book is not an exhaustive reference on DOM scripting or JavaScript. It may, however, be the most exhaustive book written about DOM scripting without the use of a library/framework. The lack of authorship around this topic is not without good reason. Most technical authors are not willing to wrangle this topic because of the differences that exist among legacy browsers and their implementations of the DOM specifications (or lack thereof).

For the purpose of this book (i.e. grokking the concepts), I'm going to sidestep the browser API mess and dying browser discrepancies in an effort to expose the modern DOM. That's right, I'm going to sidestep the ugliness in an effort to focus on the here and now. After all, we have solutions like jQuery to deal with all that browser ugliness, and you should definitely be leveraging something like jQuery when dealing with deprecated browsers.

Knockout is not meant to be a replacement for jQuery; jQuery is hugely popular, as you all know I'm a huge fan of it myself, and it's very good at what it does. But it's difficult to create complex user interfaces using jQuery alone; the bigger the application behind the interface, and the more the user can interact with it, the harder it gets to keep some semblance of order. Event handlers abound, and you quickly end up with literally hundreds of lines of code.

In this tutorial we'll build a simple interface that displays a list of contacts and then allows the visitor to interact with the UI to change how the data is displayed, such as filtering the list, or sorting it. We'll use knockout as a layer between our data and the page to simplify the creation and management or our UI.

In this article, we will explore how we can use the jQuery Validator in an ASP.NET MVC application that uses Knockout Templating. Traditionally, jQuery validator works out of the box with KO ViewModels that are statically bound.

But there are a couple of additional things that you’ve to do when templates are involved and the DOM is manipulated on the fly.

Today we use a slightly different harness from the first two parts because we need validations for the dynamic controls added by the template.

It’s a jungle out there, it is. And chances are that (in your manic hacking frenzy) you’ve committed some transgressions that will come to bite you when you finally float your app onto the stormy seas of Production.

How did we chance upon this knowledge? Well, first and foremost, through blood, sweat and tears from our own production resource planning app crashing repeatedly during its first week. Through this chaos we formed some assumptions about what was going on and remedied the situation with some hot-fixes.

So before we get started, let’s make a distinction between anonymous, unauthenticated users and logged in users. Their experiences are most likely completely different - and (importantly) there are some considerations that go along with this.

So some pages / content don’t need to be reactive. We’ve discussed making queries static in a previous post. But you can do this for templates too using #constant regions.

GREMLIN.JS will help you add modular, robust and well organized Javascript functionality to all the classic websites existing and created in the future.

Classic? GREMLIN.JS isn’t for every website: it is no MVC library, does not provide magic binding tricks, it was not created to add another SPA (single page application) client library to the list… It’s a library for the masses. All the sites currently built Spaghetti style without any supporting layer that helps you structuring the site and organizing the code at all will benefit greatly.

If this isn’t enough for you, think of your current way adding Javascript functionality to websites. In most cases jQuery will be used, plugins are included, and in the best case, there is some sort of main.js that handles all the magic inside a $(document).ready handler. This tends to end in a huge mess of hardly maintainable code snippets and it’s up to you to initialize new elements added with Javascript to the document.

GREMLIN.JS forces you to write modular and sandboxed Javascript that can be used everywhere. It will manage all components for you, takes care of them and initializes every single one when needed.