Links for 2015-11-30

  • Control theory meets machine learning

    ‘DB: Is there a difference between how control theorists and machine learning researchers think about robustness and error? BR: In machine learning, we almost always model our errors as being random rather than worst-case. In some sense, random errors are actually much more benign than worst-case errors. […] In machine learning, by assuming average-case performance, rather than worst-case, we can design predictive algorithms by averaging out the errors over large data sets. We want to be robust to fluctuations in the data, but only on average. This is much less restrictive than the worst-case restrictions in controls. DB: So control theory is model-based and concerned with worst case. Machine learning is data based and concerned with average case. Is there a middle ground? BR: I think there is! And I think there’s an exciting opportunity here to understand how to combine robust control and reinforcement learning. Being able to build systems from data alone simplifies the engineering process, and has had several recent promising results. Guaranteeing that these systems won’t behave catastrophically will enable us to actually deploy machine learning systems in a variety of applications with major impacts on our lives. It might enable safe autonomous vehicles that can navigate complex terrains. Or could assist us in diagnostics and treatments in health care. There are a lot of exciting possibilities, and that’s why I’m excited about how to find a bridge between these two viewpoints.’

    (tags: control-theory interviews machine-learning ml worst-case self-driving-cars cs)

  • The End of Dynamic Languages

    This is my bet: the age of dynamic languages is over. There will be no new successful ones. Indeed we have learned a lot from them. We’ve learned that library code should be extendable by the programmer (mixins and meta-programming), that we want to control the structure (macros), that we disdain verbosity. And above all, we’ve learned that we want our languages to be enjoyable. But it’s time to move on. We will see a flourishing of languages that feel like you’re writing in a Clojure, but typed. Included will be a suite of powerful tools that we’ve never seen before, tools so convincing that only ascetics will ignore.

    (tags: programming scala clojure coding types strong-types dynamic-languages languages)

  • RobustIRC

    ‘IRC without netsplits’ using Raft consensus

    (tags: raft irc netsplits resilience fault-tolerance)

  • Inside China’s Memefacturing Factories, Where The Hottest New Gadgets Are Made – BuzzFeed News

    On a humid afternoon, Zhou went shopping for some of those very parts at a Bao An market. As he pulled his maroon minivan into a crowded parking lot, the full scale of Depu Electronics came into view: a three-story concrete behemoth roughly bigger than a Costco and roughly smaller than the Pentagon. Inside, it looked like the world’s largest Radio Shack going out of business sale: an endless series of booths with cables and circuit boards and plugs and ports and buttons and machines piled so high on tables that the faces of the clerks who were selling them were hidden from view. Each booth seemed to argue: We have exactly what you want and we have enough of it for all of your customers. Short of motorized wheels and molding, the market offered nearly everything an ambitious factory owner would need to build a hoverboard, just waiting to be bought, assembled, and shipped.

    (tags: hoverboards memes china manufacturing future gadgets tat bao-an electronics)

This entry was posted in Uncategorized. Bookmark the permalink. Both comments and trackbacks are currently closed.

One Comment

  1. Nix
    Posted December 1, 2015 at 04:31 | Permalink

    “We will see a flourishing of languages that feel like you’re writing in a Clojure, but typed.”

    Maybe — but this is written by someone who finds Haskell pleasurable to write in, rather than an endless pain in which you spend far more mental effort trying to figure out how to prove things that are obvious to you to the machine so it will give you permission to run your code than you do actually writing code that does something, and where doing things that are trivial in most languages (like heterogenous lists) requires years of work, vast amounts of utterly incomprehensible terminology, and a PhD thesis or two in Haskell.

    I am not so confident in the inevitable victory of Haskell-like languages, particularly not given that there are more newish dynamic languages right now than there have ever been, and ever fewer with attempts at a rich type system (why bother? We know where that leads: we have Haskell). We need a type system, yes, but every attempt to make them significantly more intricate than those of Lisp’s has invariably led either to a top-heavy unextensible toppling monster like SQL or a monster of extensibility like every enforced-OO language out there or (if you try to do it right) a monster of formalisms and incomprehensibility like Haskell.

    Given that types are, fundamentally, proofs about the program, and proving things of any complexity is both painful and slow even when your intended recipients are other humans rather than something as stupid as a computer, I don’t see any way out of this dilemma. The better the type system the more what you’re doing becomes maths, and extremely difficult maths explained to an idiot at that. This does not square well with high productivity, despite the claims of Haskell advocates.