JavaScript for Line of Business Applications

Tracking down memory leaks with node.js has always been a challenge. The following discusses how to track memory leaks from within a node application itself with the help of two awesome node modules – memwatch and heapdump.

Creating realtime web applications has been possible for a while now, however up until recently it’s been kind of a pain and required a big engineering effort.

I think this is largely because the tools haven’t provided exactly what we needed to do realtime in a simple and painless way.

Luckily this has all changed, now it’s pretty easy to build realtime applications and it’s my goal to prove that to you in this episode.

The best way to prove this is by showing you, so we’ll build a simple single page application the uses realtime features from top to bottom.

Features of the SPA in this Article:

Angular.js for client side development – Single Page Application (SPA)
Cross Domain Communication in between Angular.js and Node.js Application Server through Custom Middleware
Node.js for server side application development
Rest based web service creation with Minimalweb
Datastore – MongoDb
Node.js MongoDb Module Extention (mongojs)
Reader can download the complete source-code in GitHub.

I've spent a good deal of the past year working with React. I've written, refactored, and re-written many components in that time, and I've seen some best practices and anti-patterns emerge.

Contents:

* Use the PureRenderMixin

* Use Prop Types
* Avoid State
* Centralize State
* Do More in render()
* Mixins are awesome
* It's Okay to use Instance Properties
* Think in Elements

Dealing with memory leaks in JavaScript applications can be a complex process. In this article I'm going to show you how to identify whether you have memory leaks, analyse them and ultimately resolve them.

I'm using an AngularJS application to demonstrate the concepts and approaches, but much of this material applies to any JavaScript application.

Contents:

• Understanding Memory Leaks What is a Memory Leak? Why is a Memory Leak Bad?
• Identifying Memory Leaks Method 1: The Wrong Way Method 2: The Timeline Method 3: Recording Heap Allocations Method 4: Heap Snapshots
• Analysing Memory Leaks Analysing the leak in Scenario 2 More on Graphs
• Fixing Memory Leaks Three golden rules Anti-patterns to avoid
• The Future Weak Maps AngularJS 2 Even Better Browsers
• Appendices Thanks Mysteries Futher Reading

Managing the synchronization of app state and the user interface has long been a major source of complexity in UI development, and by now we have several different approaches to dealing with it. This article explores a few of them: Ember's data binding, Angular's dirty checking, React's virtual DOM, and its relationship to immutable data structures.

Where things start to get more challenging is when we start talking about data changing over time. This can happen when the user interacts with the UI, or when something else happens in the world that updates the data. The UI needs to reflect this change. Furthermore, because rebuilding DOM trees is expensive, we'd like to do as little work as possible to get that updated data on the screen.

In this post I am going to introduce you to some of these features used inES6 Fiddle. I recommend you to play with them and get a feeling of what’s to come. These are the features that are being covered:

• Arrow functions and let keyword; Block scopes
• Classes and inheritance; Default parameters
• Destructured assignment
• Generators; Iterators; Maps
• Promises; Rest parameters; Sets
• Spread operator; Template Literals

Let’s get started! You can follow this post with ES6 Fiddle side by side.