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.
Continue reading “Superforcasting”
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.
Continue reading “Time Series Exploration”
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.
Continue reading “Stop Using JSON For Configuration Files”
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.
Continue reading “On Business”
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.
Continue reading “Reducing the conceptual load of reduce”
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)
Continue reading “Antifragile”
Yesterday, we published a post about limitations of the Om model. Several people responded, including Peter Jaros, Vesa Marttila, Brian J. Rubinton, and Mark Stang. A common suggestion was to use a core.async channel, which is essentially what we did. This post gives more details about the solution we chose.
Continue reading “How We Solved Our Om Problem”
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.
Continue reading “A Difficulty with Modals in the Om Model”
About 3 weeks ago, I switched to the Colemak keyboard layout. It’s much more efficient than the standard Qwerty layout but not as alien as the more well-known alternative, Dvorak.
Continue reading “Mapping will to keystrokes: an experiment in the Colemak keyboard layout”
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:
Continue reading “Lazy reduce in Clojure”