Altometrics Blog

Intelligence Amplification, Data Visualization



The Art and Science of Prediction by Philip E. Tetlock & Dan Gardner

The authors claim that by properly selecting questions and keeping predictors accountable, certain events can be predicted more accurately than chance.

The book describes an experiment that Tetlock designed like a forecasting tournament. He and his team selected questions that were time limited and verifiable so that the scoring wasn’t arbitrary.

Time Series Exploration


[Regretfully, the web application discussed here has been lost in a botched site migration. Apologies. -Editor]

My goal is to introduce our Time Series Explorer tool.

I wrote the tool as a small demonstration of the power of interactive visualizations. I wanted to find data that was easy to relate to, and show how a single interactive visualization could allow somebody totally new to the data to quickly absorb the meaning of the data into their minds.

Stop Using JSON for Configuration Files


Here at Altometrics, we often use Amazon Web Services for deploying web applications. Out of the AWS suite of tools, we are very fond of Amazon CloudFormation. CloudFormation provides a way to specify your application’s entire infrastructure in a single, declarative template. The associated tools handle creating and connecting all of the necessary resources (auto scaling groups, load balancers, etc.) at once, as well as updating your stack when the template changes.

But we have one grievance with CloudFormation. The configuration file needs to be formatted as JSON.

On Business




This is an explanation of modern business. It introduces you to the six main roles in a business as characters: owners, directors, officers, managers, contributors, and customers. It starts with the relationship between owner and customer. In the early story–really a sort of prologue–that shows the evolution of a man into the owner of his own business. He begins as a man with some property and, through a series of mostly glossed interactions becomes first a “property owner,” the lowest form of owner in the business sense, then a “seller” and a “businessman.” Through an unexpected twist, the businessman becomes a property owner again, but this time on a different level, with a more complex relationship to his original property.

Reducing the Conceptual Load of Reduce


Abstract: calls to reduce are difficult to understand. An example reduce in a code sample is analyzed and discussed to explore the reasons. An alternative version without the reduce is offered and compared.



by Nassim Nicholas Taleb

The sub-title, “Things that gain from disorder” clarifies the meaning of the title.

The author claims that almost everyone says the opposite of fragile is something like robust or resilient. Whereas fragile things are harmed by disorder, robust things are unaffected by disorder. There wasn’t a word for things that benefit from disorder, so he coined the word “antifragile”. Much of the book is giving examples of things that are antifragile and exploring the concept.

The previous book in this series was Black Swan, the author’s term for an extreme event so rare you can’t predict it. For example, a catastrophic flood many feet above the 100-year flood line would be a Black Swan. (In other words: an unpredictable rare event of large consequence)

A Difficulty With Modals in the Om Model


ABSTRACT When you’re building a frontend with Om, it gives you a couple of ways to store data. Fundamentally, Om mediates between data (which the user can’t see) and the DOM (which they can). Because of this, it’s important to think about where you keep the data.

Lazy Reduce in Clojure


We’re big fans of Clojure at Altometrics. It really gets out of the way and lets us get stuff done without a lot of fuss. Like many functional programming languages, Clojure features lazy sequences, which are especially useful if a given sequence is too big to fit into memory. (I’ll call such sequences “large” for the purposes of this post.)

I recently wrote the following Clojure function to lazily reduce a large sequence. I couldn’t find a Clojure function that does this, so I figured it would be worth sharing. The discussion follows, but first, here’s the code: