new ListViewDataSource

    new ListView.DataSource

> Hydraulics are usually closed, but that adds mass vs short acting open systems. F9 fins only work for 4 mins. We were ~10% off.

https://twitter.com/elonmusk/status/554023312033341440

EDIT: never mind - I've learned that they have a steering function, as well as drag inducing function, and they ran out of hydraulic fluid required to induce more drag, which would thus slow the rocket down. Leaving my comment here in case anyone else is curious.

Basically, because they lost steering it came in too steep, and ended up falling onto the deck on its side because the engines couldn't compensate for that position.

If the rocket's trajectory is correct, all that is required is a final hard burn to negate all downward velocity a short distance above the barge deck.

We could have built Boxifier so that it requires you to login into Dropbox and get back an access token to be used by Boxifier with the Dropbox API.

If someone wanted to get access to the data in your Dropbox account, they could do that with an access token (that they received when you authorized their app to access your Dropbox). Then they could use that token from any computer to download data from your Dropbox, without you ever finding out about it.

Boxifier works completely offline so it doesn't need any network access (which could be misused). If you want to be 101% sure you can setup a firewall rule and block all network access for Boxifier. This way you can make sure it cannot get data from your Dropbox folder and upload it to a remote location.

On the other hand, with an access token you have no control on how it is used outside of your computer. You may argue that you can always revoke it, but the reality of today's attacks is that they go stealth for a long time before you find out about them.

We used to work in the antivirus industry so that's why we care so much about security and privacy. Boxifier has been designed with security in mind from its early days.

[1] http://en.wikipedia.org/wiki/Principle_of_least_privilege

Python, on the other hand, is definitely one of the worst at this. You can only create one-line, single-expression anonymous function with its lambda keyword. Of all the languages you want to convert to JS so that it runs on the browser, Python is probably the last.

I've had great usage from Javascript where I have separate functions with proper names and formatting, and then pass a reference to them into the code that asks for them.

Can someone please enlighten me about this whole anonymous functions thing that Javascript seems to have popularized? What are some of the pro's of using it over regular named/defined functions that sit by themselves and are reusable.

The OP is complaining about lambda functions in Python.

As to any complaint, lambdas exist in python (that is, are made accessible to the programmer) for the exact reason python also has a for loop in addition to a while loop -- because they make things easier and more maintainable.

  def myApplyAdd(func, x):
    return lambda y: func(x+y)

  applyAddInst = myApplyAdd(lambda z: z*2, 20)
  applyAddInst(3) #output 26

  def myApplyAdd(func, x):
    def innerAdd (y):
      return func(x + y)
    return innerAdd

  def mulByTwo(x):
    return x*2

  applyAddInstance = myApplyAdd(mulByTwo, 20)
  applyAddInst(3) #output 26

  lambda i: i**2

  result = [ i**2 for i in range(3, 30) ]

If a function is "assigned to a variable" then it's no longer a lambda, because it's bound to an identifier. But I suppose the lines are a tad blurred.

  x = lambda x: x+x #a lambda, but has a named pointer
  x = 5

  def x(y):
    return y+y
  
  x = 5 #the "named" function above is now without a pointer

  //lambda expression
  var x = function (){};

  //named function
  function x() {}

  //named lambda expression
  var x = function x() {};

  //self-executing lambda (returns 5)
  (function (x) {return x;}(5));

  (lambda x: x)(5)

  my_module = (function (self) {
    "use strict"
    self = self || {};

    //private
    //pretty much inaccessible to the outside scope
    var privateVar = 5;
    //lambda expression again
    var privateFunc = function () {};

    //public
    self.publicVar = 5;
    self.publicFunc = function () {};
    self.getPrivateVar = function () {
      return privateVar;
    };

    return self;
  }(my_module));

  my_module.publicVar = 8;
  my_module.publicFunc();
  my_module.getPrivateVar();

  func1(function () {
    func2(function () {
      func3(function () {
        func4(function () {
      })
    })
  })

Faced with squeezing an explanation into a limited post or recommending one of the best books on computer science (written by teachers with many years experience in teaching these self-same principles), should I not recommend the book that will allow the poster to expand his/her horizons?

The poster was sufficiently motivated to ask the question. I was willing to post what I believed at the time to be the best answer to the question. If the poster's desire to know is sufficient, then he/she will take the time to explore the suggestion. If not, then things will stay as they are. In either case, my only interaction is my choice to share a suggestion or remain silent.

However, I'm about halfway through the chapter on "Higher order procedures" in the book you linked to, and have skimmed the rest of that chapter. And I've yet to find a valid pro for anonymous methods. Nothing I've found so far as to the benefit of using anonymous functions.

It does however, continuously reiterate the benefit of being able to pass "procedures as arguments" and to be able to return them from normal functions. So far, that's been the only "pro" and it's one that's solved by function pointers or having functions as objects, and not by anonymous methods. I'm still open for convincing, genuinely.

Here's another jewel from that chapter: "The resulting procedure is just as much a procedure as one that is created using define. The only difference is that it has not been associated with any name in the environment."

On a side note, your initial post was a tad condescending. The other post at least gave me the relevant chapter, instead of saying "here, read this for yourself". The least you could have done was give me a few short points why you think anonymous methods are superior in some way. Perhaps pointing me to a large blob of text was your way of deferring your own justifications for their use by not having to explain it to me (and as a consequence, yourself)?

SICP's point with higher-order functions is that code is data and that functions are no different than numbers or lists or whatever. In the function below, I've named everything.

  def add4Mul2(x):
    z = 4
    y = 2
    return (x + y) * z

  lst = [1,2,3,4]
  x = map(add4Mul2, lst)

  x = map(lambda x: (x+2)*4, [1,2,3,4])