JavaScript for Line of Business Applications

If you’re developing web sites or web applications today, there’s a good chance you have data to communicate, and that data may be begging for a good visualization. But how do you know what kind of visualization is appropriate? And, even more importantly, how do you actually create one? Answers to those very questions are the core of this book. In the chapters that follow, we explore dozens of different visualizations and visualization techniques and tool kits. Each example discusses the appropriateness of the visualization (and suggests possible alternatives) and provides step-by-step instructions for including the visualization in your own web pages.

Contents:

1. Introduction
   1. Implementation vs Design
   2. Code vs. Styling
   3. Simple vs. Complex
   4. Reality vs. an Ideal World
   5. Source Code for Examples
   6. Acknowledgements
2. Graphing Data
3. Making Charts Interactive
4. Integrating Charts in a Page
5. Creating Specialized Graphs
6. Showing Timelines
7. Visualizing Geographic Data
8. Custom Visualizations with D3.js
9. Building Data-Driven Web Applications
10. Managing Data in the Browser

There is a trend in the software industry to sell "mostly functional" programming as the silver bullet for solving problems developers face with concurrency, parallelism (manycore), and, of course, Big Data. Contemporary imperative languages could continue the ongoing trend, embrace closures, and try to limit mutation and other side effects. Unfortunately, just as "mostly secure" does not work, "mostly functional" does not work either. Instead, developers should seriously consider a completely fundamentalist option as well: embrace pure lazy functional programming with all effects explicitly surfaced in the type system using monads.

fn.js aims to support functional practices over performance or established conventions. In order to guide you on the right path, fn.js internals force avoidance of side effects, object mutation, and function state.

fn.js runs in the Node.js or in the browser using normal script tags or via an AMD loader such as RequireJS. Support for Bower is coming soon.

JavaScript is a flexible language with first-class functions, so it supports a functional programming style. Usually people do this with a library such as Underscore.js, which provides array operations like “map” and “reduce” and function operations like “bind” and “compose”. This is very cool. For example, when you use “map”, you work at a higher level of abstraction. You don’t have to worry about a temporary index variable for iterating over the array, so the code becomes shorter and clearer.

However, this approach is not as functional as it could be. If you’re freely assigning values to variables, then you’re still relying on changing state. If your code is primarily a sequence of statements, it’s imperative or procedural, and you’re missing the peculiar beauty of functional code.

Today we want to let you know that RxJS 2.2 is now available via the Rx.js CodePlex project and includes various bug fixes and contributions from the community.

Reactive Extensions (Rx) is a programming model that allows developers to use a common interface for writing applications that interact with diverse data sources, like stock quotes, Tweets, UI events, and Web service requests. Since Rx was open-sourced by MS Open Tech in November, 2012, Rx has become an important under-the-hood component of several high-availability multi-platform applications, including NetFlix and GitHub.

One common question from our customers is, "Could we get a core of RxJS with a set of operators we use most often in a single, smaller library?" We hear you and have now provided rx.lite.js. This library consists of the most commonly used features, including factory methods for creating observable sequences, standard operators such as where, select, and zip, relative-time based operators and the most commonly used features from rs.async.js, including events, callbacks and promises bindings. The file size has is drastically reduced – currently just 7k when zipped. We also provide a compatibility build, rx.lite.compat.js to support older browsers.

So you're curious in learning this new thing called (Functional) Reactive Programming (FRP).

The hardest part of the learning journey is thinking in FRP. It's a lot about letting go of old imperative and stateful habits of typical programming, and forcing your brain to work in a different paradigm. I haven't found any guide on the internet in this aspect, and I think the world deserves a practical tutorial on how to think in FRP, so that you can get started. Library documentation can light your way after that. I hope this helps you.

To those not used to functional programming, Ramda seems to serve no purpose whatsoever. Most of its major capabilities are already covered by libraries like Underscore and LoDash.

These folks are right. If you want to keep coding with the same imperative and object-oriented styles you've been using, Ramda does not have much to offer you.

However, it does offer a different style of coding, a style that's taken for granted in purely functional programming languages: Ramda makes it simple for you to build complex logic through functional composition. Note that any library with a compose function will allow you do functional composition; the real point here is: "makes it simple".

Let's see how that works in Ramda.

Functional Programming is great. It allows for simpler programs which are easy to test and reason about. Unfortunately, not all languages are created equal. I've been writing a bit of Clojure and really enjoying myself. As I've ported my learnings and approaches to Javascript, I've encountered a handful of issues which I'd like to talk about.

Once you begin working with functions, you'll begin passing references of them to other functions. These are called Higher Order Functions and you may already be familiar with them. Take, for example, jQuery.fn.each:...