JavaScript for Line of Business Applications

Page is a small client-side routing library that can be used to build single page applications (SPAs). It has a simple API which is inspired by Express. It utilizes the HTML5 history API under the hood, which is what allows you to build smooth user interfaces while still having linkable URLs for different pages within the app.

Handy provides all the basic functionality of a web app freeing you to focus on the features that make your app truly unique.

Out of the box user account management

• Account registration
• User authentication - login / logout
• Password reset
• Email address verification

Dead simple content management

• Define new content types
• Save or retrieve content from the database
• Delete content
• Publish or unpublish content
• Rate content

Easy role based access control

• Assign roles to users
• Grant access permissions
• Check user permissions to access resources
• Manage permissions with a graphical UI

I've been playing around with Vert.x for a couple of weeks and I'm really starting to like the simplicity of the framework. With very little configuration you can quickly get impressive results. In this article I'm diving a bit deeper in how to set up browser to browser communication using the Vert.x eventbus by using the javascript client side API. In short I'm going to show you the following things:

• Use Vert.x as a simple web server
• Configure vert.x on the serverside to act as bridge for the browser eventbus implementation
• Create a simple example that shows how to use the eventbus from javascript

I'm going to skip the explanation on how to set up Vert.x. If you want more information on that look at this article where I explain the setup I've used in this example. So let's get started with the first step.

Techy is a flat CMS based on Node.js and Markdown. I made it because I wanted to write my articles in Markdown format and avoid the time-consuming publishing workflow which I’ve been using. This post will cover a little bit about how why I created the project, how it works and how you can use it.

The idea is simple. We write Markdown files and by running the techy command in the terminal these files are converted to beautifully looking HTML pages. The final result of this article could be seen here. The home page of the blog looks like that...

If you render a React component with the same data, it will always return the same result. It makes absolutely no difference whether you do that rendering on the client or the server.

That brings us to the official front end buzzword of 2014: Isomorphic JavaScript.

The Holy Grail. The united UI layer. Serve up real HTML on first page load, then kick off a client side JS app. All without duplicating a single line of UI code.

React makes this really easy if your back end is Node.js:

In this tutorial about React I want to teach you some of the best practices of using  it in real world applications. If you didn’t heard about React, then you can learn more about it on their site. Anyway without opening the link, React is “A JavaScript library for building user interfaces”.
React is not opinionated about the style of your application and just does one thing, user interfaces, and does good.

In order to be easy for you to follow the tutorial, I will use the jsfiddle online code editor.

I received a question over email asking about how Knockout’s dependency detection actually works and thought that I would share an answer in this post. I know that I feel a bit uncomfortable whenever a library that I am using does something that I don’t fully understand, so I hope that I can help ensure that this part of Knockout is not misunderstood or considered “magic”.

Knockout has a middle-man object that is signalled on all reads to computed/observables and tells the current computed being evaluated that it might want to hook up a subscription to this dependency.

One big source of confusion when writing web apps powered by Node.js is the fact that both the front-end code (i.e. runs in the browser) and the back-end (i.e. runs on the server) are JavaScript. It gets even more confusing when both have controllers, models, views, etc.

Synth makes this easier by having any JavaScript, images, html, or other assets that are sent to the browser in the root folder frontand code that runs on the server is in the back folder.

Generators have been all the rage lately. Many Node developers (including myself!) are excited and intrigued about writing their asynchronous code like this:

However, this is just one use case (although a clever one) of using generators.

In this article, we will explore the strengths of using generators. 

Now that I can suspend functions, I can run all this stuff in parallel right? No. JavaScript is still single-threaded, but now we have the ability to say STOP in the middle of a function.

If you are looking to bolster raw performance, generators may not be your ticket. Here’s a sample CPU intensive task, calculating a Fibonacci sequence number:

This article details the way that property and variable lookups are performed in JavaScript and the resulting performance ramifications to be aware of.

In this simple step-by-step guide you will learn how to install node.js and how to build your first application with it. Read more!

The most striking similarity was the use of a virtual DOM. Like Ractive, React had discovered that creating an abstract representation of the DOM allows for lightning-fast operations by minimising the amount of DOM manipulation (the bottleneck in most webapps) that needs to take place. It also facilitates server-side rendering without some of the crazy hacks users of other tools have had to employ.

Another was the focus on reactive programming. This is one of those phrases that threatens to become meaningless with overuse, but it's a useful concept. Put simply, in a reactive system where the value of bdepends on the value of a, if a changes then b will also change. Applied to user interfaces, that means that when your application state changes, your view also changes. With traditional MVC libraries you typically have to implement all your render logic manually and wire it up with a web of publish/subscribe events; with React and Ractive you're spared that (tedious, error-prone, hard-to-optimise) step when building your apps.

Finally, both libraries believe that the way to help developers build complex apps is to give them tools that encourage simplicity and composability and then get out of their way.

Having said all that, there are also some stark differences.

ReactJS is a JavaScript library built by Facebook and Instagram which makes it easy to build large, complex user interfaces. It is intended to be used in combination with another framework which provides the backend. While Angular, Ember, and Backbone are popular choices for that, Firebase provides the easiest and quickest integration of a persistent, realtime backend into a React app - and it takes only a few lines of JavaScript.

Firebase is a natural complement to React as it provides React apps with a persistent, realtime backend. The first thing we need to do is add Firebase to the project...

As you might have seen my older posts about React js you might also know that I've been used too manystate. After building 2 medium sized apps and reading the whole React js documentation I've came to new practices. I strongly recommend to minimize the state of any React js application as it will help a lot when you will need to make server side rendering.

In this post I will briefly make a basic tutorial about how to properly use React js because is better than my older post. It will also introduce you to write React js applications that are server side renderable and of course, Google indexable.