text:
O'Reilly Radar - Insight, analysis, and research about emerging technologies http://radar.oreilly.com/feed/atom 2014-07-30T11:44:38Z Insight, analysis, and research about emerging technologies WordPress 38.393314-122.836667oreilly/radar/atomhttp://feedburner.google.comThis is an XML content feed. It is intended to be viewed in a newsreader or syndicated to another site. Nat Torkington http://radar.oreilly.com/nat/ http://radar.oreilly.com/?p=69836 2014-07-30T11:44:38Z 2014-07-30T10:00:59Z Offline First is the New Mobile First — Luke Wroblewski's notes from John Allsopp's talk about "Breaking Development" in Nashville. Offline technologies don't just give us sites that work offline, they improve performance, and security by minimizing the need for …

Offline First is the New Mobile First — Luke Wroblewski's notes from John Allsopp's talk about "Breaking Development" in Nashville. Offline technologies don't just give us sites that work offline, they improve performance, and security by minimizing the need for cookies, http, and file uploads. It also opens up new possibilities for better user experiences.

Winograd Schemas as Alternative to Turing Test (IEEE) — specially constructed sentences that are surface ambiguous and require deeper knowledge of the world to disambiguate, e.g. "Jim comforted Kevin because he was so upset. Who was upset?". Our WS [Winograd schemas] challenge does not allow a subject to hide behind a smokescreen of verbal tricks, playfulness, or canned responses. Assuming a subject is willing to take a WS test at all, much will be learned quite unambiguously about the subject in a few minutes. (that last from the paper on the subject)

Reclaiming Your Nest (Forbes) —  Like so many connected devices, Nest devices regularly report back to the Nest mothership with usage data. Over a month-long period, the researchers' device sent 32 MB worth of information to Nest, including temperature data, at-rest settings, and self-entered information about the home, such as how big it is and the year it was built. "The Nest doesn't give us an option to turn that off or on. They say they're not going to use that data or share it with Google, but why don't they give the option to turn it off?" says Jin. Jailbreak your Nest (technique to be discussed at Black Hat), and install less chatty software. Loose Lips Sink Thermostats.

SyncNet — decentralised browser: don't just pull pages from the source, but also fetch from distributed cache (implemented with BitTorrent Sync).

 http://www.oreillynet.com/pub/au/149 text http://radar.oreilly.com/2014/07/four-short-links-30-july-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/vMJrIP5YLNs/four-short-links-30-july-2014.html Nat Torkington http://radar.oreilly.com/nat/ http://radar.oreilly.com/?p=69816 2014-07-30T11:43:47Z 2014-07-29T10:00:22Z Online Community Detection for Large Complex Networks (PLosONE) — readable recount of earlier algorithms and inventions in the area, as well as a new algorithm with linear time complexity for large complex networks. sel4 — open source OS kernel (GPLv2, …

Online Community Detection for Large Complex Networks (PLosONE) — readable recount of earlier algorithms and inventions in the area, as well as a new algorithm with linear time complexity for large complex networks.

sel4 — open source OS kernel (GPLv2, most userland is BSD) with end-to-end proof of implementation correctness and security enforcement. (For a discussion of what's verified, see this blog post)

mapgraph.io — Massively Parallel Graph processing on GPUs. (via Leo Meyerovich)

tracking.js — browser framework and algorithms for computer vision algorithms and frameworks.

 http://www.oreillynet.com/pub/au/149 text http://radar.oreilly.com/2014/07/four-short-links-29-july-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/FU_KhKH6ZT8/four-short-links-29-july-2014.html Nat Torkington http://radar.oreilly.com/nat/ http://radar.oreilly.com/?p=69718 2014-07-29T11:48:48Z 2014-07-28T10:00:59Z streisand — sets up a new server running L2TP/IPsec, OpenSSH, OpenVPN, Shadowsocks, Stunnel, and a Tor bridge. It also generates custom configuration instructions for all of these services. At the end of the run you are given an HTML file …

streisand — sets up a new server running L2TP/IPsec, OpenSSH, OpenVPN, Shadowsocks, Stunnel, and a Tor bridge. It also generates custom configuration instructions for all of these services. At the end of the run you are given an HTML file with instructions that can be shared with friends, family members, and fellow activists.

Angular.js Style Guide — my opinionated styleguide for syntax, building and structuring Angular applications.

How Recursion Got into Programming — Committee member F.L. Bauer registered his protest by characterizing the addition of recursion to the language as an "Amsterdam plot".

aerospike — open source database server and client, with bold claims of performance.

 http://www.oreillynet.com/pub/au/149 text http://radar.oreilly.com/2014/07/four-short-links-28-july-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/R2Y6OXawEeU/four-short-links-28-july-2014.html Andy Oram http://radar.oreilly.com/andyo http://radar.oreilly.com/?p=69676 2014-07-28T19:32:40Z 2014-07-25T22:00:00Z Graph databases haven't made the news much because, I think, they don't fit in convenient categories. They certainly aren't the relational databases we're all familiar with, nor are they the arbitrary keys and values provided by many NoSQL stores. But …
Graph databases haven't made the news much because, I think, they don't fit in convenient categories. They certainly aren't the relational databases we're all familiar with, nor are they the arbitrary keys and values provided by many NoSQL stores. But in a highly connected world–where it's not what you know but whom you know–it makes intuitive sense to arrange our knowledge as nodes and edges.

Ted Nelson, inventor of the hyperlink, recognized the power of viewing life in graphs. After the implosion of his historic Xanadu project, he embarked on a graph database tool called ZigZag. The most modern instantiations of graphs–the Neo4j store and the Alchemy.js tool for interactively visualizing graphs–were well represented this year at O'Reilly's Open Source convention.

Both projects are growing impressively and finding users in domains they didn't expect. According to Huston Hedinger, Founder and CEO of Portland startup
 GraphAlchemist, "Graph visualization can provide insight into information ranging from how communication flows across a social network to where vulnerabilities exist in a supply chain network."

Some unusual domains where results pay off

Epidemiologists use graphs to trace or predict the flow of infections through populations. Similar techniques can be used by network administrators to determine which computer systems are most likely to be compromised by an intruder, a use case documented in the O'Reilly book Network Security Through Data Analysis. In Byron Ruth's presentation on ETL in health setting, Neo4j was used to store provenance data (sources and transformations applied to data).

Graphs are natural representations for the relationships encoded in web sites through RDF, as well as the more formal and intimidating Semantic Web. The RDF uses are echoed in a proposed Open Graph protocol to provide more meaningful links between web pages than the familiar  tags provide.

Social networks use graphs. That's how we get recommendations to add people whom they think we know. (When are the social networks going to realize that it is not in my best interest, or ultimately theirs, for me to make every person I know a "friend"?) And LinkedIn can tell me exactly how many degree separate me from another member–obviously the application of a graph.

Improving user experience

Why don't the social networks go all the way and let us directly view our own graphs? It would be neat to find out how many people I know in common with my children or with the person I worked with ten years ago.

Perhaps the incumbent social networking services don't believe we could understand the graphs or use them without frustration. According to Neo4j's Product Designer, Andreas Kollegger, they would have a good point. He says that graph databases have not learned the means to expose the deep information they hold–that they won't catch on until their advanced features are as easy to use as spreadsheets.

Alchemy.js is a good start. It's a graph drawing engine built in d3 by Portland startup GraphAlchemist. You can ask it to color nodes and edges by attribute, and to cluster related nodes.

Complementary views

Graph architecture is simple–just two nodes connected by an edge, over and over and over again–but the fascination of graphs comes from the emergent properties such as connectedness, how easy it would be to sever parts of the database by removing nodes, etc. All of these things are calculated on the nodes and edges, but they are deeply associated with the graph, being characteristics or parts of the whole.

For balance, on Tuesday evening I attended the PostgreSQL birds-of-a-feather session. Leaders presented glowing visions of new features in the upcoming version (9.4) along with more cautious assessments of complex security enhancements. One new feature will eliminate the need to outsource work to a programming language, while another will take the place of NoSQL competition. By the time the presenters were done, I was convinced PostgreSQL 9.4 is so powerful that if you run it you won't even need a computer.

Like graph databases, advanced relational databases like PostgreSQL create higher-level metadata that can be retrieved directly from the database, and therefore represent hidden characteristics of the data.

Kollegger says, "An RDBMS and a graph database are equally expressive, allowing you to capture the same kinds of information, but allow you to ask different kinds of questions. Taking OSCON as a data set, you'd ask PostgreSQL questions like 'How many people attended' or 'What was the most popular session', then turn to a graph database to ask questions like 'Did people like me go to OSCON?' and 'What was the most popular sequence of sessions?'"

What would be great, in my view, would be a way for a graph database to provide key statistics such as connectedness (for instance, whether everybody tends to know everybody else in the database) and for Alchemy.js to display such characteristics.

Databases are advancing on all fronts. The mathematical rigor underlying relational databases continues to keep them appealing when you have to investigate many fixed relationships and not leave anybody out. The quite different complexity of graph databases will reveal a power of analysis that is yet to be fully explored.

 http://www.oreillynet.com/pub/au/36 text http://radar.oreilly.com/2014/07/graph-data-tools-forge-path.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/rLIyXjysQ1k/graph-data-tools-forge-path.html Nat Torkington http://radar.oreilly.com/nat/ http://radar.oreilly.com/?p=69685 2014-07-28T19:32:41Z 2014-07-25T11:00:50Z What is Public? (Anil Dash) — the most cogent and articulate (and least hyperventilated dramaware) rundown of just what the problem is, that you're ever likely to find. talon — mailgun's open sourced library for parsing email signatures. Signals from …

What is Public? (Anil Dash) — the most cogent and articulate (and least hyperventilated dramaware) rundown of just what the problem is, that you're ever likely to find.

talon — mailgun's open sourced library for parsing email signatures.

Signals from OSCON — some highlights. Watching Andrew Sorensen livecode synth playing (YouTube clip) is pretty wild.

Two Cultures of Robocars (Brad Templeton) — The conservative view sees this technology as a set of wheels that has a computer. The aggressive school sees this as a computer that has a set of wheels.

 http://www.oreillynet.com/pub/au/149 text http://radar.oreilly.com/2014/07/four-short-links-25-july-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/0KoZChPgBY4/four-short-links-25-july-2014.html Federico Castanedo http://radar.oreilly.com/?p=69660 2014-07-28T19:32:41Z 2014-07-24T21:30:13Z The R programming language is the most popular statistical software in use today by data scientists, according to the 2013 Rexer Analytics Data Miner survey. One of the main drawbacks of vanilla R is the inability to scale and handle …
The R programming language is the most popular statistical software in use today by data scientists, according to the 2013 Rexer Analytics Data Miner survey. One of the main drawbacks of vanilla R is the inability to scale and handle extremely large datasets because by default, R programs are executed in a single thread, and the data being used must be stored completely in RAM. These barriers present a problem for data analysis on massive datasets. For example, the R installation and administration manual suggests using data structures no larger than 10-20% of a computer's available RAM. Moreover, high-level languages such as R or Matlab incur significant memory overhead because they use temporary copies instead of referencing existing objects.

One potential forthcoming solution to this issue could come from Teradata's upcoming product, Teradata Aster R, which runs on the Teradata Aster Discovery Platform. It aims to facilitate the distribution of data analysis over a cluster of machines and to overcome one-node memory limitations in R applications.

In some business areas, such as telecommunications, social graph analysis offers high business benefit. However, it is difficult to compute this kind of analysis on the full user base using R on a single node due to memory limitations. To overcome this limitation, sampling-based approaches are commonly used, but they are restricted to a subset of users. Moreover, social graph analysis is not easily parallelizable because friendship connections are difficult to isolate following partition-based approaches. At WiseAthena.com, we've spent a lot of engineering effort building in-house graph-mining algorithms needed for machine-learning-based churn prediction and fraud-detection systems.

An example of two social graphs. The image on the left shows a legitimate user network among millions of Telco call records; the image on the right shows a fraudster graph in the same network. Photo copyright: WiseAthena.com, used with permission.

One of the benefits of graph analysis in telecommunications is the ability to detect influencers. For example, we recently discovered for one of our clients that for each influencer that becomes a churner, the company will lose 4.4 more customers in the next three months.

In order to compute influencers in a network, first we need to count the number of interactions among each user. Based on documentation provided by Teradata, I will illustrate an example of how to compute the interactions among users in a telecommunication network using call detail records (CDR) of six months. A similar example can be executed on plain vanilla R using the standard functions instead of Aster R ta.*( ) family functions. However, when the size of the input data is greater than the available memory, we will get a typical memory error like, "Error: cannot allocate vector of size 10 GB."

When Aster R becomes available (targeted for the fourth quarter of 2014), it will make it possible to load and analyze input data, regardless of size. The first step in the process will be to connect to the Aster cluster by using the Teradata Aster package.

R>library(TeradataAsterR)

R>ta.connect("AsterDSN", uid = "ABC", pwd = "123″, database = "CDR", dType = "odbc")

Then, we can create virtual data frames that provide access to the outgoing and incoming calls per each user. These data were previously stored into the database CDR within the tables "outgoing_calls" and "incoming_calls". Note that this virtual data frame can be extremely large, and it provides access to data stored in the Teradata Unified Data Architecture.

R>outgoing.calls <- ta.data.frame("outgoing_calls")

R>incoming.calls <- ta.data.frame("incoming_calls")

Now, lets have a look at the first and last records of each virtual data frame:

> ta.head(incoming.calls)

ID_CELL_A NUM_A ID_CELL_B NUM_B DAY HOUR DURATION

1: 380030021 f2187c6d2ee8c15fcfaef5a8e16bc13e 380030021 000000c861763358b3a68c346cd8103e 28/02/2013 11:28:59 167

2: 380030172 cabceccf96498011e7f9b1eb4efb2154 380030021 000000c861763358b3a68c346cd8103e 28/02/2013 11:40:12 86

3: 380030021 f2187c6d2ee8c15fcfaef5a8e16bc13e 380030021 000000c861763358b3a68c346cd8103e 28/02/2013 11:50:52 110

4: 380030021 f2187c6d2ee8c15fcfaef5a8e16bc13e 380030021 000000c861763358b3a68c346cd8103e 28/02/2013 13:08:30 301

5: 380030021 f2187c6d2ee8c15fcfaef5a8e16bc13e 380030021 000000c861763358b3a68c346cd8103e 28/02/2013 19:09:30 407

6: 381180045 f2187c6d2ee8c15fcfaef5a8e16bc13e 381180045 000000c861763358b3a68c346cd8103e 01/03/2013 08:15:51 765

> ta.tail(outgoing.calls)

ID_CELL_A NUM_A ID_CELL_B NUM_B DAY HOUR DURATION

1: 380170648 ffffe1a2a4dd2a6ef5cdfc4f99404d82 380170217 e7e8953caafe1ee9f19754368be57ce2 30/09/2013 15:43:51 118

2: 381181812 ffffe5d38cf3cc937c37f3fdaab705fa 381180542 ecd03464c3771a92660184365f9f3596 30/09/2013 09:03:21 171

3: 381180587 fffff973cfd726cf4d723f7d249b32e0 381180698 d6752c8f1466b7d619726dd970163d80 30/09/2013 13:38:41 134

4: 381180853 fffff973cfd726cf4d723f7d249b32e0 381180853 f30af0ffbe00838a37d99482a17ba2be 30/09/2013 18:37:53 20

5: 380060339 fffffa3d16ef46fc51886f753933c4a7 380061087 9b4b60ecfa08b22aefc2ecae798cf5aa 30/09/2013 18:02:16 59

6: 380060339 fffffa3d16ef46fc51886f753933c4a7 380060339 d8aa7a8ca273ba78a9e37dc3d58ab1d7 30/09/2013 18:24:09 1821

In each virtual data frame, NUM_A, refers to the phone number that is making the call, and NUM_B refers to the one that is receiving the call.

Now, we only get those interactions from calls with a duration greater than five seconds:

R>incoming.calls <- ta.subset(incoming.calls, DURATION > 5)

R>outgoing.calls <- ta.subset(outgoing.calls, DURATION > 5)

Since we are only interested in the interactions from one user to another, we can skip the cell towers, date time, and duration information:

R>incoming.calls <- incoming.calls[, c(2,4)]

R>outgoing.calls <- outgoing.calls[, c(2,4)]

Now, we can combine both data frames into one data frame by concatenating rows:

R> friends.calls <- ta.rbind(outgoing.calls, incoming.calls)

We assume a User A is a friend of User B if they called each other. We can compute the number of closed loops per friendship link by creating a dummy variable just with ones and using the Aster R parallel constructor to run this code in parallel across all the nodes and count closed loops:

R> friends.calls["DUMMY"] <- 1

R> counting.friends.calls <- ta.tapply(friends.calls$DUMMY, list(friends.calls$NUM_A, friends.calls$NUM_B), sum)

Finally, we can have a look at the number of closed loops of each user and another one.

As an example, lets query the closed loops among number 9f2dc668556ec6353d5a197d8aabaf2 and f84af42b298dacd1cc479d8c814fac1a4:

R> counting.friends.calls <- ta.as.data.frame(counting.friends.calls)

R> counting.friends.calls[c("9f2dc668556ec6353d5a197d8aabaf2"),c("f84af42b298dacd1cc479d8c814fac1a4")]/2

206

Note that we are dividing the total number by 2 because we are counting closed interactions, that is the number of times NUM_A calls NUM_B and NUM_B calls NUM_A back.

Benefits of an integrated scalable R solution

Aster R virtual data frames can be used directly with existing R functions (ta.* family), which is an important advantage over current open source solutions, such as the bigmemory R package. For example, matrices provided by bigmemory cannot be used directly by functions such as base::summary. Therefore, analysis must be done on subsets of the big.matrix using the available RAM, as with common R matrices. Furthermore, bigmemory only supports numeric matrices instead of more flexible data structures such as data frames.

It is also possible to use parallel programming abstractions in R programs. However, there are different mechanisms, and each one has its own interface, like the multicore, snow, parallel, and Rmpi packages. Therefore, different versions of the same code are required for each parallel mechanism. Another option is to use the foreach package, which is a framework that encapsulates the underlying parallel environment; however, this is not completely transparent to the developer because it requires use of the specific %dopar% syntax in the loops.

Teradata's forthcoming Aster R product might provide solutions for managing and analyzing massive data using standard R syntax and allow the application of statistical analysis, regardless of the size of the problem and without requiring you to hire senior engineers to develop an in-house solution.

James Taylor, CEO and a Principal Consultant of Decision Management Solutions, and Bill Franks, Chief Analytics Officer of Teradata, will explore a day in the life of an R analyst during a free webcast on Tuesday, July 29th at 10 a.m. PDT / 1 p.m. EDT. Register for the free online event, presented in collaboration with Teradata.

This post is part of a collaboration between O'Reilly and Teradata. See our statement of editorial independence.

 text http://radar.oreilly.com/2014/07/new-scalable-solutions-for-data-analysis-with-r.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/GYMuZTKMKT8/new-scalable-solutions-for-data-analysis-with-r.html Mac Slocum http://radar.oreilly.com/mslocum http://radar.oreilly.com/?p=69637 2014-07-28T23:01:37Z 2014-07-24T14:44:16Z Experts and advocates from across the open source world assembled in Portland, Ore. this week for OSCON 2014. Below you'll find a handful of keynotes and interviews from the event that we found particularly notable. How tiny satellites and fresh …
Experts and advocates from across the open source world assembled in Portland, Ore. this week for OSCON 2014. Below you'll find a handful of keynotes and interviews from the event that we found particularly notable.

How tiny satellites and fresh imagery can help humanity

Will Marshall of Planet Labs outlines a vision for using small satellites to provide daily images of the Earth.

Tim O'Reilly on empathy amidst technology and transformation

Tim O'Reilly discusses the importance of values, empathy, and culture in technology. He asks: "What kind of world do we want to build?"

A reasonable call for paranoia

If you don't have anything to hide, you have nothing to worry about, right? Tim Bray explains why that's a wrongheaded conclusion.

Check your privilege and evaluate your defaults

"When all of the defaults are configured to work for you out of the box, it never occurs to you that those defaults exist, or to question them." Leslie Hawthorn explores the systemic problems of privilege and how we can tackle them.

The concert programmer

Artist-programmer Andrew Sorensen live-codes to produce an improvised musical concert.

Getting kids interested in programming

Fourteen-year-old programmer Shadaj Laddad shares his tips for getting kids started with code.

You can see more keynotes and interviews in our OSCON 2014 playlist.

 http://www.oreillynet.com/pub/au/3515 text http://radar.oreilly.com/2014/07/signals-from-oscon-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/QTj2rGfrfsc/signals-from-oscon-2014.html Beau Cronin http://radar.oreilly.com/beauc http://radar.oreilly.com/?p=69303 2014-07-28T19:32:43Z 2014-07-24T11:00:39Z Editor's note: this post is part of our Intelligence Matters investigation. In my last post, we saw that AI means a lot of things to a lot of people. These dueling definitions each have a deep history — ok fine, …

An orrery, a runnable model of the solar system that allows us to make predictions. Photo: Wikimedia Commons.

Editor's note: this post is part of our Intelligence Matters investigation.

In my last post, we saw that AI means a lot of things to a lot of people. These dueling definitions each have a deep history — ok fine, baggage — that has massed and layered over time. While they're all legitimate, they share a common weakness: each one can apply perfectly well to a system that is not particularly intelligent. As just one example, the chatbot that was recently touted as having passed the Turing test is certainly an interlocutor (of sorts), but it was widely criticized as not containing any significant intelligence.

Let's ask a different question instead: What criteria must any system meet in order to achieve intelligence — whether an animal, a smart robot, a big-data cruncher, or something else entirely?

To answer this question, I want to explore a hypothesis that I've heard attributed to the cognitive scientist Josh Tenenbaum (who was a member of my thesis committee). He has not, to my knowledge, unpacked this deceptively simple idea in detail (though see his excellent and accessible paper How to Grow a Mind: Statistics, Structure, and Abstraction), and he would doubtless describe it quite differently from my attempt here. Any foolishness which follows is therefore most certainly my own, and I beg forgiveness in advance.

I'll phrase it this way:

Intelligence, whether natural or synthetic, derives from a model of the world in which the system operates. Greater intelligence arises from richer, more powerful, "runnable" models that are capable of more accurate and contingent predictions about the environment.

What do I mean by a model? After all, people who work with data are always talking about the "predictive models" that are generated by today's machine learning and data science techniques. While these models do technically meet my definition, it turns out that the methods in wide use capture very little of what is knowable and important about the world. We can do much better, though, and the key prediction of this hypothesis is that systems will gain intelligence proportionate to how well the models on which they rely incorporate additional aspects of the environment: physics, the behaviors of other intelligent agents, the rewards that are likely to follow from various actions, and so on. And the most successful systems will be those whose models are "runnable," able to reason about and simulate the consequences of actions without actually taking them.

Let's look at a few examples.

Single-celled organisms leverage a simple behavior called chemotaxis to swim toward food and away from toxins; they do this by detecting the relevant chemical concentration gradients in their liquid environment. The organism is thus acting on a simple model of the world – one that, while devastatingly simple, usually serves it well.

Mammalian brains have a region known as the hippocampus that contains cells that fire when the animal is in a particular place, as well as cells that fire at regular intervals on a hexagonal grid. While we don't yet understand all of the details, these cells form part of a system that models the physical world, doubtless to aid in important tasks like finding food and avoiding danger — not so different from the bacteria.

While humans also have a hippocampus, which probably performs some of these same functions, we also have overgrown neocortexes that model many other aspects of our world, including, crucially, our social environment: we need to be able to predict how others will act in response to various situations.

The scientists who study these and many other examples have solidly established that naturally occurring intelligences rely on internal models. The question, then, is whether artificial intelligences must rely on the same principles. In other words, what exactly did we mean when we said that intelligence "derives from" internal models? Just how strong is the causal link between a system having a rich world model and its ability to possess and display intelligence? Is it an absolute dependency, meaning that a sophisticated model is a necessary condition for intelligence? Are good models merely very helpful in achieving intelligence, and therefore likely to be present in the intelligences that we build or grow? Or is a model-based approach but one path among many in achieving intelligence? I have my hunches — I lean toward the stronger formulations — but I think these need to be considered open questions at this point.

The next thing to note about this conception of intelligence is that, bucking a long-running trend in AI and related fields, it is not a behavioralist measure. Rather than evaluating a system based on its actions alone, we are affirmedly piercing the veil in order to make claims about what is happening on the inside. This is at odds with the most famous machine intelligence assessment, the Turing test; it also contrasts with another commonly-referenced measure of general intelligence, "an agent's ability to achieve goals in a wide range of environments".

Of course, the reason for a naturally-evolving organism to spend significant resources on a nervous system that can build and maintain a sophisticated world model is to generate actions that promote reproductive success — big brains are energy hogs, and they need to pay rent. So, it's not that behavior doesn't matter, but rather that the strictly behavioral lens might be counterproductive if we want to learn how to build generally intelligent systems. A focus on the input-output characteristics of a system might suffice when its goals are relatively narrow, such as medical diagnoses, question answering, and image classification (though each of these domains could benefit from more sophisticated models). But this black-box approach is necessarily descriptive, rather than normative: it describes a desired endpoint, without suggesting how this result should be achieved. This devotion to surface traits leads us to adopt methods that do not not scale to harder problems.

Finally, what does this notion of intelligence say about the current state of the art in machine intelligence as well as likely avenues for further progress? I'm planning to explore this more in future posts, but note for now that today's most popular and successful machine learning and predictive analytics methods — deep neural networks, random forests, logistic regression, Bayesian classifiers — all produce models that are remarkably impoverished in their ability to represent real-world phenomena.

In response to these shortcomings, there are several active research programs attempting to bring richer models to bear, including but not limited to probabilistic programming and representation learning. By now, you won't be surprised that I think such approaches represent our best hope at building intelligent systems that can truly be said to understand the world they live in.

 text http://radar.oreilly.com/2014/07/in-search-of-a-model-for-modeling-intelligence.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/KD6MP7qu0Ig/in-search-of-a-model-for-modeling-intelligence.html Nat Torkington http://radar.oreilly.com/nat/ http://radar.oreilly.com/?p=69646 2014-07-28T19:32:43Z 2014-07-24T11:00:29Z Neglected Machine Learning Ideas — Perhaps my list is a "send me review articles and book suggestions" cry for help, but perhaps it is useful to others as an overview of neat things. First Crowdfunded Book on Booker Shortlist — …

Neglected Machine Learning Ideas — Perhaps my list is a "send me review articles and book suggestions" cry for help, but perhaps it is useful to others as an overview of neat things.

First Crowdfunded Book on Booker Shortlist — Booker excludes self-published works, but "The Wake" was through Unbound, a Threadless-style "if we hit this limit, the book is printed and you have bought a copy" site.

Watson Can Debate Its Opponents (io9) — Speaking in nearly perfect English, Watson/The Debater replied: "Scanned approximately 4 million Wikipedia articles, returning ten most relevant articles. Scanned all 3,000 sentences in top ten articles. Detected sentences which contain candidate claims. Identified borders of candidate claims. Assessed pro and con polarity of candidate claims. Constructed demo speech with top claim predictions. Ready to deliver."

ipfs — a global, versioned, peer-to-peer file system. It combines good ideas from Git, BitTorrent, Kademlia, and SFS. You can think of it like a single BitTorrent swarm, exchanging Git objects, making up the web. IPFS provides an interface much simpler than HTTP, but has permanence built in.. (via Sourcegraph)

 http://www.oreillynet.com/pub/au/149 text http://radar.oreilly.com/2014/07/four-short-links-24-july-2014.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/5a_1zqytej8/four-short-links-24-july-2014.html Jenn Webb http://radar.oreilly.com/jennw http://radar.oreilly.com/?p=69597 2014-07-28T19:32:44Z 2014-07-24T11:00:15Z Editor's note: this podcast episode is the first in our new bi-weekly O'Reilly Radar Podcast series. You can subscribe through iTunes, SoundCloud, or directly through our podcast's RSS feed. As the Internet is increasingly embedded into our physical world, it's …
Editor's note: this podcast episode is the first in our new bi-weekly O'Reilly Radar Podcast series. You can subscribe through iTunes, SoundCloud, or directly through our podcast's RSS feed.

As the Internet is increasingly embedded into our physical world, it's important to start designing for physical and intentional interactions with interfaces to supplement the passive, data-gathering interactions — designing smart devices that service us in the background, but upon which we also can exert our will.

In this episode, Josh Clark (in an interview) and Tim O'Reilly (in a keynote) both address the importance of designing for contextual awareness and physical interaction. Clark stresses that we're not facing a challenge of technology, but a challenge of imagination. O'Reilly argues that we're not paying enough attention to the aspects of people and time in designing the Internet of Things, and that the entire system in which we operate is the user interface — as we design this new world, we must think about user needs first.

Related fodder from this episode:

Benedict Evans: Ways of thinking about Google

Aral Balkan and his Grab Magic hack

Drum pants

Taktia Smart Router

Disposable architecture?

One Wheel

Larry Legend

Makani Airborne Wind Turbines

Happy Together

Jon Postel

Apple Continuity

Saul Griffith

Scott Jenson

Robustness principle

Solid Conference

Cover App

Liza Kindred

MakeSpace

 text http://radar.oreilly.com/2014/07/podcast-design-for-how-the-world-should-work.htmlhttp://soundcloud.com/oreilly-radar/design-for-how-the-world-should-work/download.mp3http://feedproxy.google.com/~r/oreilly/radar/atom/~3/f5PjBenErE0/podcast-design-for-how-the-world-should-work.html Andy Oram http://radar.oreilly.com/andyo http://radar.oreilly.com/?p=69588 2014-07-28T19:32:45Z 2014-07-24T05:11:01Z When does a software project grow to the point where one must explicitly think about governance? The term "governance" is stiff and gawky, but doing it well can carry a project through many a storm. Over the past couple years, …
When does a software project grow to the point where one must explicitly think about governance? The term "governance" is stiff and gawky, but doing it well can carry a project through many a storm. Over the past couple years, the crucial OpenStack project has struggled with governance at least as much as with the technical and organizational issues of coordinating inputs from thousands of individuals and many companies.

A major milestone was the creation of the OpenStack Foundation, which I reported on in 2011. This event successfully started the participants' engagement with the governance question, but it by no means resolved it. This past Monday, I attended some of the Open Cloud Day at O'Reilly's Open Source convention, and talked to a lot of people working for or alongside the OpenStack Foundation about getting contributors to work together successfully in an open community.

When software is no longer just the domain of inquisitive college students and such, but comes mostly from large corporations (as commits to the Linux kernel now do), the risk of fake openness grows. I got a lesson in fake openness an embarrassingly long time ago when I worked for a company that was part of the Open Software Foundation (OSF).

The OSF was formed by major computer vendors in the 1980s as a defensive move, in reaction to a partnership between AT&T (the owner of UNIX) and Sun Microsystems (the most successful minicomputer vendor). The half-dozen leading member companies in the OSF agreed to combine their most advanced technologies to create interoperable products. They defined openness as interoperability, with no intention of providing open software as we know it today.

The companies' actual strategy was to give the OSF a pile of crap (an appropriate technical term for the state of their software), take back the incompatible mess of overly ambitious components that the OSF created from the contributions, and then assiduously fix bugs internally without sharing fixes with other companies.

The OSF obviously could not survive this behavior. (Nor did most of its member companies.) The OSF merged with X/Open and still exists in some evolved form as the Open Group, but its main legacy is Microsoft's Component Object Model, which the company copied (in a largely compatible fashion) from a contribution to the OSF by Apollo Computer.

Fast forward to more contemporary actors. The OpenStack Foundation was formed by companies that understood openness as a business strategy and community value. It has truly open software as defined by the license and by a contribution process that follows four "Open" promises: open source, open design, open development, and open community. According to community manager Stefano Maffulli, however, more recent corporate members joined up in a rush from market pressure. These corporations may have had little time to learn and understand the open collaboration that makes OpenStack so different from most open source projects, and they risk reverting to zero-sum thinking, like the members of the old standards groups.

In a recent presentation, Maffulli says that "committed companies" are deeply involved in the decision making process, know how and with whom to communicate, help fix things when they break, etc. (slide 26 in Maffulli's presentation). In contrast "involved companies" are part of the Foundation for tactical reasons and their developed are "involved on the outskirts first" (slide 29).

To get the most from both groups, the Foundation is conducting an ongoing effort to sustain OpenStack's growth with more education in the values of open innovation. Before each OpenStack Summit, the Foundation offers a free two-day training session to teach developers the social skills required to successfully contribute new code. This upstream training teaches developers the values of collaboration across corporate boundaries, hoping they can explain to their managers that paying a fee to the Foundation qualifies them to be members but that successful collaboration requires more. The call for speakers at the next OpenStack Summit in Paris has a track on How to Contribute, designed to share best practices and success stories.

Contributing a driver or a plugin to an OpenStack component is as valuable as contributing a new core feature. "Where would Linux be without device drivers?" asks Maffulli. "And where would device manufacturers be without solid memory management and other core features of the kernel?" They're two sides of the same coin, but some people don't yet see that.

It's important to explain to companies that when they contribute a driver or some other small piece of code to any open source project, they are responsibility for the success of the whole. Dropping 10k lines of code at the periphery of a project with 2M lines of code means taking ownership of the whole 2M: it's a responsibility toward its customers not to repeat the mistakes of the Open Group.

Federico Lucifredi told me that OpenStack was at risk of spreading itself too thin by embracing too many new projects, a problem similar to the OSF's adoption of overly complex and immature technologies. In the case of OpenStack, many companies are pressing the community to embrace new modules that are addressing decidedly non-urgent requirements. This reached a zenith at the November 2013 Hong Kong summit, and a reaction set in among community leaders. The OpenStack Foundation is now working to identify the select Core modules that correspond to the use of the OpenStack trademark. Projects deemed worthy of support and recognition will continue to receive Incubator status, in a model similar to the Apache Foundation's.

At the Open Cloud Day, OpenStack's Release Manager, Thierry Carrez, was asked how the project could maintain forward momentum with a distributed, decentralized decision-making structure. He answered, "The benevolent dictator model is great if you can afford it," but few projects can find someone who functions over the long term as both technical lead and release manager as Linus Torvalds does. The OpenStack Foundation is trusting the community to restore balance through voluntary measures. Its experience is a case study in the blending of structure with letting a thousand flowers bloom on a massive scale for open source technologies.

 http://www.oreillynet.com/pub/au/36 text http://radar.oreilly.com/2014/07/openstack-creates-a-structure-for-managing-change-without-a-benevolent-dictator.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/Oh5ZbkXzvRU/openstack-creates-a-structure-for-managing-change-without-a-benevolent-dictator.html Hew Wolff http://radar.oreilly.com/?p=69082 2014-07-28T19:32:45Z 2014-07-23T12:00:00Z "Red-Green-Refactor" is a familiar slogan from test-driven development (TDD), describing a popular approach to writing software. It's been both popular and controversial since the 2000′s (see the recent heated discussions between David Hansson, Bob Martin, and others). I find that …
"Red-Green-Refactor" is a familiar slogan from test-driven development (TDD), describing a popular approach to writing software. It's been both popular and controversial since the 2000′s (see the recent heated discussions between David Hansson, Bob Martin, and others). I find that it's useful but limiting. Here I'll describe some interesting exceptions to the rule, which have expanded the way I think about tests.

The standard three-step cycle goes like this. After choosing a small improvement, which can be either a feature or a bug fix, you add a failing test which shows that the improvement is missing ("Red"); add production code to make the test pass ("Green"); and clean up the production code while making sure the tests still pass ("Refactor"). It's a tight loop with minimal changes at each step, so you're never far from code that runs and has good test coverage.

By the way, to simplify things, I'll just say "tests" and be vague about whether they're technically "unit tests", "specs," "integration tests," or "functional tests"; the main thing is that they're written in code and they run automatically.

Red-Green-Refactor is a very satisfying rhythm when it works. Starting from the test keeps the focus on adding value, and writing a test forces you to clarify where you want to go. Many people say it promotes clean design: it's just easier to write tests when you have well-separated modules with reasonable interfaces between them. My personal favorite part, though, is not the Red but the Refactor: the support from tests allows you to clean things up with confidence, and worry less about regressions.

Now for the exceptions.

Read-Groan-Refactor

Sometimes I see code that just needs refactoring. Maybe I'm preparing to make some changes, but it's hard to see what's going on because the old code is painfully cluttered. So I start by cleaning it up. I do run the tests periodically to keep them green, but there is no Red step here.

This includes refactoring of test code as well as production code. We forget sometimes that tests are code and they can rot. In fact they may be more liable to rot: they tend to be longer than the corresponding production code, stuffed with a bunch of very similar cases, and not closely reviewed. So sometimes it's worth pausing to clean up a test which is redundant or confusing.

A similar case is when I want to refactor a method and then find out that it has no test coverage. In this case I'll try to add a test, even if it's just a crude one. Rough tests are better than no tests.

Rest-Grin-Refactor

Sometimes I never write the test. Say the task is to move a button to the right by 20 pixels in a web page. That's a change in production code, perhaps even an important change. So how would I capture that change in a test? Maybe the test could interpret the stylesheet well enough to check the button's horizontal position. Or maybe a browser simulation tool, driven by a script, could load the page and check the position, or compare the rendered image with a screenshot from the spec.

But there's a trade-off here. The risk of subtle side effects for this change is low, and the change is easy to test by loading the page manually and eyeballing it. In this case, writing a test is not worth the effort. So again there are no Red and Green steps here. I would still run the tests when I'm done, just to verify that the change has no impact on them.

On the other hand, if I'm fixing a bug that made it into production, that's a good indication that we need the test and I should not skip it.

Reddish-Greenish-Refactor

Sometimes the tests are really slow. This is not a disaster; tests that run only once a day are still providing useful information. But I can't run a 10-minute test suite every time I change the code. Some people really want their tests to run in under a second; I find I can keep a reasonable flow going even if the tests takes 30 seconds, but not much more than that. So I make an educated guess about which tests are relevant, and I run only those tests. That way, at least I know that the tests are "greenish." I try to run the full tests pretty often, say for every major commit.

Red-Red-Green-Refactor

Sometimes I add a failing test, but it fails for the wrong reason. So even after I implement the change correctly, the test is still failing…because the test was broken. Then there's an extra step for fixing the test. This is generally easy, though, because all the changes were small.

Rats-Green-Relax

Sometimes the tests are broken, but in a subtle way. Maybe they passed yesterday but they don't pass today. Or they pass on your local machine but not on the continuous-integration server.

Once I mocked up some behavior in a Rails model class by modifying the class itself, forgetting that this was a permanent change that would leak into subsequent tests that used the same class. So the tests would fail depending on the order in which they ran, which might be different in different environments.

Another time, I found a test was failing because it depended on the current system time, rather than mocking up a test clock. A test like this might fail only on Mondays.

One more example: there was a race condition between two items in a hash. Both items had the same key, but one value was good and the other was bad. The insertion order depended on the hash table algorithm, and each would win half the time, so the test was a random coin toss.

Obviously at a time like this, I'd get back to a stable test suite before adding any more features.

But seriously

Clearly the relationship between tests and code is more complicated than the basic Red-Green-Refactor suggests. This doesn't mean TDD is broken, but it does mean we need to add some nuance.

A tight loop is still important. You should have your hands on both the tests and the production code often, and run them, even if you're not using the classic cycle. If you're spending all day without touching one or the other, that's a red flag.
Tests are code too. Tests and production code are not completely different beasts. Tests need debugging and refactoring just like regular code does. In Rails Test Prescriptions, Noel Rappin says, "Your code is verified by your tests, but your tests are verified by nothing." But when you're running the tests to verify the production code, the production code is also verifying the tests. You run them together and they verify each other. Without getting too philosophical, we can take this a bit further…
Tests and production code are full partners. When you're maintaining both tests and production code, it's tempting to think of one of them as the core of the product and the other one as support.

You might say that the production code is really the core, because there's no product without it. It's nice to add the tests if you have time, but they don't bring any real value to the product, because the user will never run them.

Or you could look at it the other way around, taking the name "test-driven" seriously, and say that the tests are the core. Although production code is important, the tests come first because we need them to be confident that the product is correct and that we can maintain it in the future. (Some say that code is mostly to communicate with other programmers, and the fact that it runs on the machine is just a happy side effect — this is a similar idea if we think of tests as executable documentation.)

I think neither one is the core. There is no single main artifact. Tests and production code are two different perspectives, two complementary ways to describe the product. Another perspective is the documentation; another is the product knowledge inside your team members' heads. All these perspectives are important, and for the same reason: they have value because they contribute to the product quality and make the user's life better.

As long as the code and tests are growing together, it doesn't matter how they grow.

Photo via Wikimedia Commons.

 text http://radar.oreilly.com/2014/07/reddish-greenish-refactor.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/d9AXBGhr0O4/reddish-greenish-refactor.html Pete Warden http://radar.oreilly.com/petew http://radar.oreilly.com/?p=69533 2014-07-28T19:32:46Z 2014-07-23T11:00:58Z When I first became interested in using deep learning for computer vision I found it hard to get started. There were only a couple of open source projects available, they had little documentation, were very experimental, and relied on a …

When I first became interested in using deep learning for computer vision I found it hard to get started. There were only a couple of open source projects available, they had little documentation, were very experimental, and relied on a lot of tricky-to-install dependencies. A lot of new projects have appeared since, but they're still aimed at vision researchers, so you'll still hit a lot of the same obstacles if you're approaching them from outside the field.

In this article — and the accompanying webcast — I'm going to show you how to run a pre-built network, and then take you through the steps of training your own. I've listed the steps I followed to set up everything toward the end of the article, but because the process is so involved, I recommend you download a Vagrant virtual machine that I've pre-loaded with everything you need. This VM lets us skip over all the installation headaches and focus on building and running the neural networks.

Setting up the virtual machine

You'll need an OS X or Linux machine and the free Vagrant virtualization software to run the virtual machine. If you don't already have Vagrant, go to http://www.vagrantup.com/ and follow the "Getting Started" instructions.

Once you have Vagrant installed, open up a new terminal window. The first step will be to create a directory for the VM to use, by running these commands:

mkdir ~/dl_webcast
 cd ~/dl_webcast

Then you'll download the image of the virtual machine, which is almost 2GB, so it may take a while.

vagrant box add dl_webcast https://d2rlgkokhpr1uq.cloudfront.net/dl_webcast.box

Now that you have the box downloaded, we'll spin up a new virtual server:

vagrant init dl_webcast
 vagrant up

Next, you'll log into the virtual machine:

vagrant ssh

Running a pre-built network

I'm going to show you how to use the Caffe deep learning framework started by Yangqing Jia and the Berkeley Vision and Learning team. It has an active developer community, the code is entirely open source (though you can't use the pre-built networks commercially), and there's a lot of documentation, so it's a great starting point. To begin, move into the project directory:

cd ~/caffe

You're going to run a network that's based on the architecture used by Krizhevsky et al to win the Imagenet 2012 contest. The BVLC team trained the network themselves, but because it's built on a set of images that are only available for non-commercial use, it's not licensed for anything other than research. It attempts to recognize 1,000 different categories of objects, and running it is as simple as this:

python python/classify.py --print_results examples/images/cat.jpg foo

You should see a whole stream of logging messages, with a final line that looks like this:

[('kit fox', '0.27215'), ('red fox', '0.19984'), ('wood rabbit', '0.13209'), ('hare', '0.07283'), ('Egyptian cat', '0.06632')]

Congratulations — you've just run your first deep neural network! The output is an array of guesses about what the image contains, with the numbers representing how confident the algorithm is, and the text describing each category. If you check out the image it's being run on, you'll see it's not quite a Kit Fox, but you can understand the mistake.

To try it on your own images, copy them into the ~/dl_webcast/ folder from your main OS, and they'll show up inside /vagrant/ in the VM's file system.

Training your own network

The Imagenet network you just used had a thousand categories, so it requires more than a million different images in its training set, and takes more than a week to train even on a high-end GPU. Luckily, there are simpler image recognition problems that take a lot less time to teach a network how to solve, and I'll show you how to train a network for one of those.

One of the first tasks that convolutional neural networks were used for was recognizing handwritten digits. Yann LeCun did a lot of pioneering work on this in the 90s, and a version of his LeNet architecture is included in Caffe. You'll need to download his MNIST database of 70,000 examples of handwritten digits:

cd data/mnist
 ./get_mnist.sh
 cd ../..
 cd examples/mnist

Once those images have been downloaded, you'll need to make one change to the settings for the training process. I've already done this on the supplied VM, but if you're starting from scratch you'll need to run nano (or your favorite editor) on lenet_solver.prototxt, and update the final line to specify CPU rather than GPU, since there's no usable graphics card within the virtual machine. Then, running a supplied script will kick off the training process:

./train_lenet.sh

You should see a lot of logging messages, and after a few minutes a completion message. If you do an ls -l, you should see a recent lenet_iter_10000 file that contains the weights of the trained network. Now you can run that network on a test image to check its performance. I've supplied several inside the VM, but you should be able to use any white-on-black digit.

python python/classify.py --print_results --model_def examples/mnist/lenet.prototxt --pretrained_model examples/mnist/lenet_iter_10000 --force_grayscale --center_only --labels_file data/mnist/mnist_words.txt --images_dim 28,28 data/mnist/sample_digit.png foo

The final output should be a score indicating a 100% probability that this digit is a 4, which it is!

Setup instructions

Below you'll find the commands I ran to build the Vagrant VM this section uses. If you're using Vagrant, create a clean Ubuntu 14.04 box like this:

vagrant box add ubuntu-14.04 https://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-amd64-vagrant-disk1.box

Once you've created and initialized your VM, or if you're using another method of running 14.04, log into the machine and start the CUDA setup. Caffe relies on the CUDA headers and libraries being present to build, even if you're only going to run on the CPU, so you have to install the 900Mb package.

sudo apt-get install linux-headers-uname -r
 curl -O "http://developer.download.nvidia.com/compute/cuda/6_0/rel/installers/cuda_6.0.37_linux_64.run"
 chmod +x cuda_6.0.37_linux_64.run
 sudo ./cuda_6.0.37_linux_64.run --kernel-source-path=/usr/src/linux-headers-3.13.0-30-generic/

At this point, you'll see a series of prompts. You want to answer 'No' to installing the driver (since we don't have a compatible GPU), but yes to the samples and SDK, leaving the paths at the default. Once that's complete, you'll need to update the library path to include the SDK.

echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64' >> ~/.bashrc
 source ~/.bashrc

Now we need a grab bag of dependencies installed via apt-get:

sudo apt-get install -y libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev protobuf-compiler gcc-4.6 g++-4.6 gcc-4.6-multilib g++-4.6-multilib gfortran libjpeg62 libfreeimage-dev libatlas-base-dev git python-dev python-pip

Google's logging framework isn't available through a repository, so you have to build that from source:

wget https://google-glog.googlecode.com/files/glog-0.3.3.tar.gz
 tar zxvf glog-0.3.3.tar.gz
 cd glog-0.3.3
 ./configure
 make
 sudo make install
 cd ..

You should be ready to pull down the Caffe source code:

git clone https://github.com/BVLC/caffe.git
 cd caffe

CUDA has problems with the default gcc 4.8 compiler, so you'll need to switch to 4.6:

 sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc-4.6 30
 sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++-4.6 30

There's a list of Python module dependencies inside the Caffe project, so you'll use PIP to install those, which can take a while:

sudo pip install -r python/requirements.txt

The current version of Caffe isn't set up to allow compiler switching, so you'll need to do some patching of the make files:

cp Makefile.config.example Makefile.config
 echo "CXX := /usr/bin/g++-4.6" >> Makefile.config
 sed -i 's/CXX :=/CXX ?=/' Makefile

The next step is compiling the project itself:

 make all
 make test

Finally, download the pre-built neural network and label data:

examples/imagenet/get_caffe_reference_imagenet_model.sh
 mv caffe_reference_imagenet_model examples/imagenet
 data/ilsvrc12/get_ilsvrc_aux.sh

What now?

You've run and even trained deep neural networks, but you haven't been able to see very far inside the black box. I'm betting you need to recognize more than just digits and kittens, so in my next installment I'll go into more detail about what's happening under the hood and how you can start adapting them to the problems you want to solve!

Image on home, topic, and article pages by aman_geld on Flickr, used under a Creative Commons license.

 text http://radar.oreilly.com/2014/07/how-to-build-and-run-your-first-deep-learning-network.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/iOyGFoXjfSs/how-to-build-and-run-your-first-deep-learning-network.html Andy Oram http://radar.oreilly.com/andyo http://radar.oreilly.com/?p=69088 2014-07-28T19:32:47Z 2014-07-23T11:00:50Z Jeremy Rifkin is always predicting an avalanche of change: substitutes for human labor in The End of Work, pervasive genetic engineering in Algeny, and so on. Several interlocking themes run through his latest book, The Zero Marginal Cost Society. Behind …

Stratasys' Education, R&D departments and MIT's Self-Assembly Lab are researching 4D printing — manufacturing one-off objects that can change their shapes or other physical characteristics in response to their environment. (View the video.)

Jeremy Rifkin is always predicting an avalanche of change: substitutes for human labor in The End of Work, pervasive genetic engineering in Algeny, and so on. Several interlocking themes run through his latest book, The Zero Marginal Cost Society. Behind everything lies the renewed importance of local resources: local energy production, local manufacturing, local governance. And the Internet that ties us all together (evolving into the Internet of Things) will, ironically, bolster local power.

To explain this apparently contradictory evolution, let me summarize the main trends Rifkin covers in this book. He combines a number of themes that appear often on Radar — and in his usual head-spinning style, predicts how they will totally change humanity:

Renewable energy sources, mostly set up locally but tied together through a smart grid, will literally empower small producers and communities.

3D printing will move a good deal of manufacturing to the user. Since I got the book, I found an even newer trend called 4D printing: manufacturing one-off objects that can change their shapes or other physical characteristics in response to their environment.

The Internet of Things (IoT) will help individuals determine their place in this intelligent, distributed network and cut inefficiencies.

The free exchange of information over the Internet, including designs for 3D-printed objects, will eliminate almost all further dependence on centralized, patent- and copyright-protected industries.

 Oh, and just to throw in a few other little things: humans everywhere will gain control over their lives through online education, a collaborative ethos that nearly replaces capitalism, and a sense of empathy that expands to include all peoples and perhaps the entire biosphere.

Let's have a trailer-length look at each of these feature-film topics.

Local energy sources

Rifkin expects a transition to solar, wind, geothermal, and other renewables to take place much faster than it seems to be happening right now. Part of the drive for the switch is, of course, climate change, along with the other ecological downsides of fossil fuel use. But the cost savings are even more motivating.

After installation, maintenance costs for renewable energy sources are tiny — so small, in fact, that after a while they approach what economists call zero marginal cost, hence the title of the book.

The relation between the homestead, the community, and the larger society becomes complex with renewable energies. In many places, residents might be able to power everything they need for daily living just from what they put on their homes. More flexibility might apply at the community level, where a wind farm could supply a large geographic area. And sometimes it might make sense to ship energy long distances as we do now, and let people trade their excess production — making a smart grid important.

Local production through global knowledge sharing

Already the 3D and emerging 4D movements are producing two important lessons in the new balance between local and global. First, tinkerers can share empowering innovations with everyone in the world, whether it's as supportive as a wheelchair or as dangerous as a gun. Second, recipients of the designs can adapt them to local needs.

Thus, if someone can locally obtain a much cheaper material, or finds the design ill-suited to local heat and cold conditions or rough ground, they can play around with a design and then share the changes with other people under similar conditions. Whereas traditional trade eliminated local entrepreneurship — bringing in mass-produced goods that displaced domestic production — the 3D/4D printing revolution will boost local entrepreneurship.

Rifkin also suggests that old junk can be recycled and turned into new wares. This lowers the cost of rapid prototyping, which I believe Rifkin failed to mention. When one can try out and throw away material products almost as fast as you can recompile and test software, you get a whole new approach to innovation and a dizzying pace of new products. 3D and 4D printing also allows prototypes to be quickly and widely distributed for testing, also speeding up development. Such new practices should help developing regions create tools and materials appropriate for their climates and cultures.

Free education

MOOCs, which take up Chapter 7 of Rifkin's book, illustrate the mutual benefits of local and global activity. Many professors have found that students who meet in small, local groups — with peers, with teaching aids, or with professors — in between viewing MOOC offerings do better than those who take MOOCs in isolation.

The continuing role of big

Rifkin sees a future of loosely collaborating communities that eschew payment and intellectual property in favor of altruistic knowledge sharing. He claims that capitalism itself will shrink to become a bit player in the new economy. Many of these ideas will be familiar to Radar readers, perhaps through the works of Yochai Benkler (whom Rifkin cites several times), Clay Shirky (whom Rifkin doesn't refer to), and Aaron Swartz (who is inexplicably missing from the book — perhaps because he was not well-known outside the computer field until his tragic death last year).

I see much better prospects for the continuation of capitalism. After all, who will grow and transport our food? It can't all be grown locally in large cities, particularly in cold climates. Who will produce the computer chips, optical fiber, and plastic upon which the Collaborative Commons and 3D printing depend? And who will maintain the international communications cables across which we will all send our open designs? Although Rifkin doesn't investigate these topics, he admits that large, centralized institutions will continue to play a role in the new paradigm.

Finally, I have a tremendous appreciation for human entrepreneurship (as does Rifkin, an admission that comes to full fruit in the book's afterword). So long as some medium of exchange (that is, money) needs to exist, people will find unique goods and services that appeal to buyers. Like all the other changes to come, this will be enabled by the Internet commons and will have strong local components.

 http://www.oreillynet.com/pub/au/36 text http://radar.oreilly.com/2014/07/jeremy-rifkin-unveils-a-return-to-the-local-in-an-interconnected-future.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/28r5M4W8vqM/jeremy-rifkin-unveils-a-return-to-the-local-in-an-interconnected-future.html Max Shron http://strata.oreilly.com/maxs http://radar.oreilly.com/?p=69408 2014-07-28T19:32:48Z 2014-07-23T11:00:07Z Editor's note: This is part two of a two-part series reflecting on the O'Reilly Solid Conference from the perspective of a data scientist. Normally we wouldn't publish takeaways from an event held nearly two months ago, but these insights were …

Editor's note: This is part two of a two-part series reflecting on the O'Reilly Solid Conference from the perspective of a data scientist. Normally we wouldn't publish takeaways from an event held nearly two months ago, but these insights were so good we thought they needed to be shared.

In mid-May, I was at Solid, O'Reilly's new conference on the convergence of hardware and software. In Part one of this series, I talked about the falling cost of bringing a hardware start-up to market, about the trends leading to that drop, and a few thoughts on how that relates to the role of a data scientist.

I mentioned two phrases that I've heard Jon Bruner say, in one form or another. The first, "merging of hardware and software," was covered in the last piece. The other is the "exchange between the virtual and actual." I also mentioned that I think the material future of physical stuff is up for grabs. What does that mean, and how do those two sentiments tie together?

In the first sense, "exchange between the virtual and actual" isn't that different from "merging of hardware and software." Clearly, when we move more of the intelligence of our machines into software, some of the actual is becoming virtual. There's that, but there is a deeper trend that came up repeatedly at Solid that I'd like to flesh out a bit more.

My ability to articulate these trends is even less sophisticated, in part because most of these ideas came from future-focused keynotes and some follow-up reading. I am even more out of my depth here, so apologies if I butcher anything on either the manufacturing or the biology I'm about to discuss.

What is our world made of?

The materials of today include the likes of plastic, particleboard, glue, copper, and silicon. At the Ft. Mason center where Solid was held, it was clear which things were from our current age (the laminate signs, the plastic convention tables, the particleboard bookshelves). Had someone set down a chrome and steel appliance in the middle of the convention floor, it would have been just as obvious that it was from the first half of the last century.

Our age is an age of CNC (computer numerical control). Our factories mill, cut, and injection mold to make our personal possessions. Almost everything made today is cut away by computer or melted into shape in something else that was cut away by computer. The prior age was an age of bent metal and cast steel. The age before that was an age of cast iron and wood. Of course, we continue to make things in older ways, but that doesn't detract from the fact that each age has characteristic materials and manufacturing practices that define its look and feel.

What will the future look like? What will be the default manufacturing style in 50 or a 100 years? I'm speaking more here about small possessions, not buildings or infrastructure, which naturally change more slowly.

The consensus seems to be that the future will be pixelated. Everything today is made of unique components that are cut, melted, or shaped into just the right shape and stuck together. A chair is made of a few curved pieces of particleboard glued together, a smoke detector is made of a few injection molded pieces of plastic screwed together, a lamp is made basically the same way — topologically smooth, continuous parts, joined roughly.

By contrast, in a pixelated world, our things will be made out of reusable, identical parts, the same way that our computer images are made of reusable pixels that can display any number of pictures. What might that mean?

One vision came from Neil Gershenfeld. He made a compelling case that there are immense benefits to making our things Minecraft style, out of reusable blocks at various scales.

Gershenfeld calls this "digital" manufacturing, and not because the machine that makes the thing is digitally controlled, which is the current meaning of digital manufacturing. Instead, the manufacturing is digital because the component pieces are discrete; made of distinct pieces; and, like a digital signal, either connected or not connected — on or off, with no free-form interfaces, more like Legos than brick and mortar. And just as digital signals permit better copies and lower errors compared to analog ones, so do, in theory, digital things.

I think I have seen the future, and it is reusable, composable, and rapid from top to bottom.

What do I mean? Let's take an example. Before the advent of digital telephony, call quality degraded over distance. If a person in New York called a friend in Ohio, the quality of the audio would be better than if someone in New York called a friend in California. When Bell switched (no pun intended) to digital representations of calls, it didn't matter whether you were in Ohio or California because digital signals can be copied with far fewer errors in them than analog ones can.

We take for granted that if you copy a file and then take a copy of that copy, the second copy will be identical to the first. We expect little to no corruption in our data from repeated copying, even after transmission over phone lines and satellite links. By contrast, when you photocopy a photocopy, or make a tape of a tape, quality rapidly degrades. These are analog processes. At the moment, the same thing is true of most of our stuff.

By contrast, to use Gershenfeld's favorite example, consider a Lego castle. A Lego castle, made from Lego bricks, can be assembled to be exactly the same every time. It can be made, then broken apart back into its pieces, then remade again, without any flaws. The child who assembles the Lego castle doesn't even need very fine motor control to get it exactly right. All of the intense manufacturing can happen once, at the level of the brick, and after that, the final result can be made (and repaired) very quickly.

There are already examples of this, from digitally made digital circuits to digital polyhedra for arbitrary shapes. We may not be far from being able to build a toy car on a desktop that drives off of the construction bed. The future of desktop manufacturing may be more pick-and-place than plastic squirt gun.

Obviously, it's not digital all the way down, just as computers ultimately at their smallest level are continuous wires, doped silicon, and plastic parts. We will still need to manufacture the pieces, and the pieces will require large factories and big expensive shipping containers, at least for awhile. But having a layer where things switch from analog to digital can clearly bring huge benefits.

So far we've looked at things made digitally at the scales of millimeters and centimeters. What about much smaller components?

The point was made several times at Solid that reusable, composable, repairable digital manufacturing is how biological manufacturing is done. We have small, reusable pieces (amino acids) that are combined together to make objects with highly complex properties that can then be recycled to make new objects. When leaves fall off trees in autumn, those leaves are digested back into the same materials that new leaves will be made from, with no loss other than the energy it takes to remake them. Try doing that with Ikea chairs.

Living objects are much more similar to an LED TV than to an old-style cathode ray tube: small component parts with a large number of discrete states are organized hierarchically, with a lot of repetition to give the desired result. By contrast, with a cathode ray tube, the only guarantee that the light ends up in the right part of the TV is the precision of the electron gun.

This kind of digital manufacturing is also on the horizon. DIY bioengineering is now a thing. Carl Bass, CEO of Autodesk, showed off designs in the latest version of Autodesk 360 for tiny baskets, structurally made of DNA, that release a payload on contact with a protein. Though the manufacturing hasn't been able to make it as far as the design has, the immediate potential is still huge.

There are other ways the world may become more pixelated. Hiroshi Ishii discussed the possibility of reactive surfaces, able to come up and meet us rather than being pictures under glass. In his vision, our current things are just too darned still, unable to bend or change themselves in any useful way beyond displaying pictures on their surfaces. When our things are made of voxels and tightly coupled actuators, they may cease to be so dormant.

Exchange between actual and virtual

It would seem, then, that we're only a generation out from something like a replicator, albeit far from the Star Trek kind, able to produce objects with built-in sensors and electronics, constant connectivity, and reactive surfaces. At that point, the distinction between hardware and software basically collapses. When most objects are software-built, highly networked, and full of ubiquitous, built-in, cheap computing, we are really in a science fiction scenario. I may live to see it happen during my career.

Nanotech fabricators promised to us in the 1980s turned out to be premature. We were likely taking on too much, too fast. Getting good at programming matter on a large scale is probably a prerequisite to getting good at doing it on a small one. I think I have seen the future, and it is reusable, composable, and rapid from top to bottom.

What does all of this mean for data science? I don't know. I think it's possible that even the people who are promising an explosion of data as we make our toasters and aspirin tablets smart are vastly underestimating just how cheap and ubiquitous data collection and automated decision making will become. I'm definitely looking forward to being along for the ride.

Image on category, container, and content pages cropped from Benjamin Esham's Lego Bricks on Flickr, used under a Creative Common's license.

 text http://radar.oreilly.com/2014/07/materials-that-make-up-our-world.htmlhttp://feedproxy.google.com/~r/oreilly/radar/atom/~3/6jVPjNtUgNE/materials-that-make-up-our-world.html


text:
Sign up to receive information about new books, author events, and special offers.
Sol Stein is the author of several novels, including the million-copy bestseller The Magician. As an editor, his authors included James Baldwin, Jack Higgins, and many others. Stein has lectured widely on creative writing, and was given the Distinguished Instructor Award by the University of California at Irvine in 1993. His columns appear regularly on America Online and elsewhere.
Sol Stein

subset: commoncrawl


text:
While you have spent your day working, the Buffalo Bisons have been doing likewise and working over their record books during an incredible romp past the Syracuse Chiefs.
The Herd set modern-era records in both runs and hits with a 27-9 demolition of Syracuse at NBT Bank Stadium. The win completed a four-game sweep on the road, Buffalo's first since 2004, and improved its record to 8-4.
For posterity, there's the lineup card at left as posted on Bisons.com (manager Marty Brown has some high-quality printing!)
Here's the rundown of the team's accomplishments today, as it smashed, equaled or approached several records in its modern era dating to 1985:
---Most runs, breaking the mark of 25 set in a 25-13 win at Rochester in 2004).
---Most hits (29), breaking the mark of 26 set in a 15-9, 10-inning win in Indianapolis in 1985.
---Most runs in an inning (10 in the 7th), tying the mark set in the third inning of a 14-0 win over Richmond on May 6, 2001.
---Most hits by a player: 6, by OF Moises Sierra, tying the mark set by Justin Turner at Rochester in the season finale on Sept. 4, 2010. Prior to that game, no Buffalo batter had collected six hits since 1936!
---Margin of victory: The 18-run win breaks the record of 16, set in a 17-1 win over Toledo on July 17, 2012
---St. Francis product Jim Negrych went 4 for 7 and hit for the cycle, the first Bison player to do that since Turner. Negrych leads all of affiliated baseball with an XBox-like .515 batting average. Oddly enough, no Bison has ever hit for the cycle at home in a regular season game (Alex Ramirez did it during the 1998 playoffs), but there have been five on the road.
Most runs by a player (5), by Ryan Langerhans and Sierra, equaling the mark set by Brent Abernathy in 2004. Langerhans had two homers and six RBIs.
---Luis Jimenez had 8 RBIs, falling one shy of the mark set by Dusty Wathan during his three-homer game vs. Toledo in 2005 at Coca-Cola Field. Jimenez's eight are the most ever by a Buffalo player in a road game.
---This from the Bisons: "The International League reports that the 27 runs on 29 hits are both records in the circuit over the last 40 years. The Bisons' greatest win in 128 years of the team was a 33-6 win over Providence on July 26, 1902."
---The 36 combined runs are two shy of the modern-era mark, set in the 25-13 game.
---The Bisons hit a ridiculous 14 of 24 with runners in scoring position and are batting .333 as a team for the season. They have scored 85 runs in 12 games, an average of 7.1 per contest.
The linescore looked like this:
The Bisons hit the bus right after the game for Lehigh Valley and start a four-gamer with the IronPigs on Friday night. The next home game is Tuesday at 6 against Pawtucket.


text:
- Great silencing using as little as 1 nM siRNA
- Over 90% gene silencing in a wide variety of cells
- Easy standard protocol
- Gentle mode of action for more robust data and excellent cell viability
- Compatible with serum and antibiotics
INTERFERin® provides more than 90% silencing efficiency at 1 nM siRNA in a wide variety of cells; hence avoiding off-target effects.
For High Throughput Screening Applications, Polyplus-transfection developed a dedicated reagent: INTERFERin®-HTS.
More information:
|1 ml of INTERFERin® is sufficient to perform 500-1000 transfections in 24-well plates. Bulk sizes available, please contact us.
Several publications show that using low siRNA concentrations avoids off-target effects observed when transfecting siRNA at higher concentrations1,2. Ensure more reliable data by minimizing these unwanted non specific side-effects by using as little siRNA as possible. This is why INTERFERin® has been specifically designed to provide high silencing efficiency using low siRNA amount.
INTERFERin®-mediated delivery of 1 nM of a specific siRNA shows selective and highly efficient knockdown of gene expression, while a competitor (L2K) needs at least 10 nM siRNA to reach 50% silencing efficiency (Fig 1).
|Fig 1. INTERFERin® only requires 1 nM siRNA for efficient gene silencing. 3LL cells stably expressing firefly luciferase were transfected with an anti-Luc siRNA using INTERFERin® or competitor L2K according to the manufacturer's recommendation. Luciferase expression was measured after 48 h using a conventional assay. No inhibition was observed with control siRNA.
Amazingly, 50% silencing is still achieved at 10 pM siRNA (Fig. 2).
Transfection of 1 nM siRNA targeting endogenous lamin A/C with INTERFERin® drastically reduces lamin gene expression to barely detectable level (Fig. 3).
For adherent cell lines or primary cells, 1 nM siRNA is sufficient to obtain more than 90 % gene silencing. For suspension cell lines, 80% silencing can still be reached by INTERFERin® using 5 nM siRNA (Table 1).
|Table 1. Successfully transfected cell lines and silencing efficiencies obtained with INTERFERin®.
When it comes to cell viability, INTERFERin® outperforms other transfection reagents. 48 h after transfection with 1 nM siRNA, cells transfected with INTERFERin® appear healthy, while toxicity is clearly observed with reagent S (Fig. 4).
INTERFERin® is ready to use and the protocol is straightforward. Start with 1 nM siRNA as a starting concentration for silencing of most genes in most cell types (Fig. 5).
INTERFERin® is compatible with both serum and antibiotics, hence forget time consuming medium changes and washes; INTERFERin® can be left on the cells without any adverse effects.
|Fig 5. INTERFERin® standard protocolfor 24-well plate
Take a look at our Expert Tips in Genetic Engineering and Biotechnology News.
1. Birmingham, A. et al., (2006) Nature Methods, Vol.3, No3, 199-204
2. Caffrey, D. et al., (2011) PLoS One. 2011;6(7):e21503. Epub 2011 Jul 5.


text:
- Mobile site
- E-Newsletters
- News feed
- Find us on Twitter
Follow our reporters on Twitter
Follow The Northern Echo and ours reporters on Twitter for the latest breaking news
- Find us on Facebook
The Northern Echo
Like us on Facebook
11-year-old injured in Billingham car accident (From The Northern Echo)
For details on how to contact our editorial and commercial departments, click here
11-year-old injured in Billingham car accident
11:30am Wednesday 28th November 2012 in News By Joanna Morris
AN 11-YEAR-OLD girl suffered head injuries in a car accident while walking home from school.
The girl was involved in a collision with a red VW Polo on Walworth Road, Billingham, at around 3.50pm on Tuesday (November 27).
She was taken to the University Hospital of North Tees with a broken arm and head injury and was described as being in a comfortable condition.
Any witnesses should contact PC Tina Lackenby of the Cleveland and Durham Specialist Operations Unit on non-emergency number 101, quoting reference number 213880.
Comments are closed on this article.


text:
By Nita Johnson
Staff Writer
LAUREL COUNTY, Ky. —
A man who forged a signature on a plumbing inspection application and did work on a local business was indicted in a six-count indictment on Friday.
Derrick Feltner, 25, of 2228 Ky. 3434 in East Bernstadt, is charged with two counts of second-degree forgery, no plumbing license, no liability insurance, no plumbing installation permit, and false representation of a licensed electrical contractor stemming from work he performed at Mandy's Salon on Jan. 24.
Feltner is accused of signing the name of another person on an application for plumbing inspection, signing someone else's name to the receipt, and not having the proper licenses to perform the work. According to the indictment, Feltner did not possess the license or have liability insurance to perform plumbing and electrical work on the business.
Other indictments were:
• Erik M. Farmer, 25, of 2528 Somerset Road in London, was charged with the July 29 burglary of a residence in which he took a firearm, air compressor, and jewelry. He was indicted for theft of a firearm and theft by unlawful taking over $500.
• Stephanie Bumgardner, 19, of McFadden Lane in London, was indicted for theft by unlawful taking over $500 but less than $10,000 and four counts of theft by unlawful taking over $10,000. The indictment comes from an incident on Jan. 30 in which Bumgardner allegedly took cash, rings, bracelets, necklaces, a gold nugget watch, and other jewelry from a residence.
• Billy Gray, 28, also known as Billie Gray, of 519 Lost Fork Road in Manchester, was indicted for two counts of theft by unlawful taking over $500 and being a first-degree persistent felony offender. Gray is accused of taking a guitar from another person on Aug. 5 and again on Sept. 16. Gray has prior felony convictions in Laurel County in 2005 for theft by unlawful taking and received a five-year sentence. In 2012, he was convicted of attempted manufacturing of methamphetamine in Clay County and received a five-year sentence.
• Denver Bunch, 40, of 46 Norwood Drive in Gray, is charged with flagrant non-support of his child from July 2005 through February 2013.
• Melissa A. Thomes, also known as Melissa Graham, 33, of 13095 Kenton Station Road in Morning View, Ky., is charged with possessing a controlled substance on May 18, 2012. Thomes allegedly possessed a quantity of cocaine on that date.
An indictment is an accusation only and does not imply guilt or innocence.


text:
the gorge, and after leaving there could see a bad storm coming up from Mexico. By the time we reached Seeley, which is 9 miles from El Centro, I knew we were washed out on the mountain. Upon arrival at El Centro I received the report that not only were we washed out, but that the S. P. was also washed out between Niland and Indio. Also it was reported that the highway was washed out between Jacumba and El Centro.
After placing Mr. Sproule's private car on our passenger train for Yuma, I left El Centro by motor car to inspect the washout. We could only get to Coyote Wells. From there we could see the rails and ties suspended in the air sometimes for a distance of 300 feet. In other places the track was covered with earth for like distances. The bridge at Coyote Wells was washed out, so I returned to El Centro and started to make up the gangs so as to get started the next day. I found a man at El Centre by the name of Mr. Petzer. He had just finished a big construction job there. He had about 30 mules and Fresnos and I was able to hire about 200 men. We loaded the boxcars that night and were on the job the next day. It was necessary to get piling and a pile driver which happened to be at Yuma. The second day we closed the bridge at Coyote Wells. The bad part of the washout was west of Coyote Wells. On the ninth day we were able to operate our passenger train from El Centro to San Diego at limited speed. After 30 days we were once again back to normal operation. This washout cost $260,000 to repair. It was necessary for me to work with two crews, both day and night for 9 days.
But it seemed our railroad was not through with washouts. Again in February, 1927, we washed out between San Diego and Garcia in Mexico. This storm also took the railroad between San Diego and Lakeside and North Island. This of course stopped our whole operation as it affected our main line and branch lines.
We opened again in April after about a 60 day tie up. Now we were open again and in good shape, but we had lost most of our passenger business. It was necessary to discontinue our eastern connection with the Sunset Limited at Niland. It was not uncommon to see this train arrive in San Diego without a single passenger. We held on to our freight business to a certain extent, but later that year the plant at Potash was shut down.
In 1928, we were able to get some new business from the movie companies. While it was very good paying business, it was very dangerous to handle. We had three or four trains on this work for 30 days at a time working in Carriso Gorge.
In July, we had a change in our official family. Mr. A. T. Mercier was transferred and later became president of the S. P. in 1940.
We just barely made expenses in the years 1929, 1930 and 1931. Taxes alone to the State of California averaged $70,000 per month. From 1931 to and including 1935 we were not able to pay the interest on our bonds, and in 1932, when we lost 3 tunnels, one by slide and 2 by fire, it became a question if the line would be reopened. The cost was going to be $700,000, and it was considered only to operate the lines between San Diego and San Ysidro and El Centro and Coyote Wells.
At about 1:00AM on January 25, 1932, I was called at my home and advised that Tunnel No. 3 was on fire. This tunnel was 1297 feet long. As is usually the practice in such fires, I instructed the crews to barricade one end of this tunnel. Usually in such cases the fire will die for lack of oxygen. We usually have ties available along the line. I immediately left for the scene of the fire. I arrived about 3:00AM, and the barricade was complete. It so happened that there were plenty of ties near the entrance to the tunnel. As the fire did not die down as


text:
Mobile apps for hospitals are on the rise.
This year alone, 44 million health-related apps will be downloaded. For hospitals and health systems, a mobile application is no longer optional.
- The technical team that designed Axial Mobile has produced mobile apps for over 300 enterprise customers.
- Axial Mobile clinical features are overseen by Dr. Paul Takashi and Dr. Nathan Jacobsen of the Mayo Clinic.
Connect with your patient community. Get your hospital mobile app developed and up-and-running in 30 days.
Get the mobile app white paper
See how your hospital can use mobile apps to drive patient engagement.
Improve Patient Satisfaction with a Hospital Mobile App
Put hospital information at your patients' finger tips
- Wayfinding with floor plans and maps
- Click-to-call contact directory
- Real-time news and blog feed
- Electronic insurance card
- Mayo Clinic medical library
- ER wait times (optional)
- Personal health records (optional)
- Personal health trackers ... and more
We'll Help You Get the Word Out
- Promotional collateral for registration and waiting room areas
- Website promotion
- Newsletters
- Best practices for banners and outdoor advertising
- ... and more
Available for iPhone, iPad, and Android.
Healthcare software that people love to use
Hospital Information
Help your patients navigate your hospital or clinic with a click-to-call physician directory, maps and directions, and a continuously updated news feed.
First Aid + Health Library
Offer information from the Mayo Clinic - one of the world's most trusted resources - on over 1,000 conditions, including tests and procedures and first aid.
Online Insurance Card
Allow your patients to store insurance information, including a photo of the front and back of their card, on the one item they always have with them -- their phone.
ER Wait Times (optional)
Help your patients choose the appropriate Emergency Room location by posting continuously updated wait time estimates.
Digital Health Trackers
Offer your patients a way to track key health metrics, including weight, glucose, cholesterol, medications, pregnancy, migraines, depression, and more.
Self-Service Content Updates
Make changes to your content through a single web page and changes will get pushed out to all Apple and Android users - without having to resubmit to the app store. Also, get detailed usage analytics by location and device.
Ongoing Support + Updates
An Axial subscription has you covered for all new versions of Apple and Android. We provide ongoing support and updates to ensure that your users receive a first class mobile experience.
Patient Health Records (optional)
Boost the value of your EHR investment by enabling your patients to access their records on their phone.
Enhance Your Brand within Your Community
Don't be left behind. 56% of patients said they like the idea of remote healthcare services and 41 percent indicated they would like to see it delivered by mobile device. 1.4 Billion smartphones will be in market by 2015 and 500 million will have a health-related application loaded on it.
Increase Patient Loyalty
With the industry trend toward population management, patient loyalty is a priority for most hospitals and health systems. If you give your patients the information they need via their own mobile devices, you are building patient loyalty in an increasingly competitive healthcare environment.
Eliminate Waste
Frantic phone calls for basic information about your hospital from patients and their family members are not uncommon. Fielding these can add up to hundreds and thousands of staff hours. For smart phone users, Axial makes this go away via a beautifully-designed application.
Profit from health care reform (optional)
Meaningful Use requires you to provide patients with electronic copies of their medical records. Axial enables you to satisfy this requirement via a secure mobile application.
Get the mobile app white paper
See how your hospital can use mobile apps to drive patient engagement.


text:
Grid List
Mens Genuine Rabbit Fur Hooded Clearance JacketSoft and cozy but smart and masculine, our genuine rabbit fur jacket guarantees warmth with style. And if that wasn't enough on the warm front, the toasty hood, two outside pockets, leather-trimmed front zipper, and elastic wrists are sure to keep you protected from the elements. Poly/satin lining with polyfill. Imported. Fur clean.Learn More
Color: Chinchilla .
1297BC Men's Big (4-6X)
Regular Price: $239.99
Special Price $88.88


text:
With over a dozen unique tools, Auslogics
BoostSpeed is a powerfull all-in-one PC optimizer
that has everything you need to keep your
computer running fast and smooth.
I'm happy to write that Auslogics BoostSpeed is one of the most comprehensive and user friendly optimizers. Mark Oakley, Micro Mart
Here's an all-in-one speed - boosting utility that takes an everything-plus-the-kitchen-approach to speeding up your PC. Preston Gralla, PC World
I think it is the best program I have ever bought. I have tried them all: Norton, Fix-It Utilities and many more!More testimonials
It has helped my PC even more than I thought it would. It's like buying 18 different programs rolled up in one...More testimonials
...your software is solid and I never have to worry about installing anything you produce fuzzing up my system.More testimonials


text:
- Thursday, 13 Feb 2014
- Moss Theater
- 7:30 pm
- Margaret Batjer, curator & violin
- Arnold Steinhardt, special guest & violin
- Jeffrey Kahane, piano
- Tereza Stanislav, violin
- Trevor Handy, cello
- Joshua Ranz, clarinet
- Roland Kato, viola
- Andrew Shulman, cello
- Korngold "Marietta's Lied zur Laute" from Die tote Stadt, Op. 12
- Dahl Concerto a tre for Violin, Cello and Clarinet
- Schumann Piano Quintet in E-flat major, Op. 44
Arnold Steinhardt was first violin of the illustrious Guarneri Quartet for its 45-year run. Born in LA in the 1930s, Steinhardt in his youth studied violin with Toscha Seidel and Peter Meremblum, who were part of the émigré community that included musical giants Stravinsky, Korngold, Dahl, Rubinstein and Piatigorsky.
Following the Orchestra's signature "conversations" style, the musicians introduce the pieces from the stage. There is no intermission.
part of the
westside connections
special note
Concerts in this series are presented without intermission.
For the Westside Connections series, the introduction of the music from the stage takes the place of program notes.
venue note
Wondering where to grab a bite to eat near Moss Theater?
Try one of the nearby restaurants in Santa Monica.
box office info
Call Andrew or Carrie in the box office at 213 622 7001 × 1, Monday – Friday 9 am to 5 pm and on concert days from 9 am to 4 pm. The box office is closed on public holidays.
Single tickets start at $50.
For information or to purchase tickets, call Andrew or Carrie in the box office at 213 622 7001 × 1.
Program, artists and ticket prices subject to change.