Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

No, the public has to be scared into standing by while the courts force Apple to unlock a phone for the FBI, so there will be adequate precedent for doing so later in in more mundane cases, like drug dealers, gangs, and so on.

The thing that scares law enforcement is that in recent years, they've been handed piles of easy evidence that is recorded permanently and easy to access. While before you actually had to do an active man-in-the-middle attack, known as "wiretapping", and that required a court order with good evidence, now there's a ton of communication that is already recorded on persistent media, and all they have to do is find some excuse for taking a look at it to get a lot of extra information without much trouble.


This is the most reasonable explanation I have read so far.

Especially given that surveillance tools tend to "trickle down" wrt the severity of the alleged crimes required to use them.


Perfect description of how we "just" need to see a return of "good-old police work" combined with modern high-level training.

This stuff is hard and should be hard - apropos jobs and automation: it's also a great opportunity for politicians to align income levels with the private sector to attract only the best of the best (humans vs. "high-tech" toys).


The term "closure" is used in Rust for that syntax, regardless of whether it actually closes over its environment. You need some term for the syntax, and closure is used even if it doesn't necessarily close over anything; because much of the time, you do use it because you want it to close over its environment.

And, you can pass a pointer to a function just fine:

  fn call_twice<F>(f: F) where F: Fn() {
      f();
      f();
  }

  fn hello() {
      println!("Hello");
  }

  fn main() {
      call_twice(|| println!("Hi!"));
      call_twice(hello);
      let x = 5;
      call_twice(|| println!("{}", x));
  }
And all of this optimizes down just fine; if the environment being closed over is empty, it will just be an anonymous function with no extra overhead. Heck, if you try it out yourself on the playpen in release mode, and take a look at the asm, all of these just get inlined right into main: http://is.gd/p9Kd9y


How about memory size? A pointer to a function is just a single pointer to the called code, while a pointer to a closure has at least 2 pieces of data (pointer to code + closed over data or reference) which seems incompatible.


Generics are monomorphized, so this isn't an issue.


Should really use "git filter-branch", not "git rebase -i", for automated history modifications. "git rebase -i" is good for interactive usage, not scripting.


  A digital clock is a type of clock that displays the time
  digitally (i.e. in numerals or other symbols), as opposed 
  to an analog clock, where the time is indicated by the 
  positions of rotating hands.
https://en.wikipedia.org/wiki/Digital_clock


Don't use it day to day; we use Google Docs at my company, so that's what I happen to use for most of that kind of stuff.

But one day Google Docs happened to be down while I was doing a phone screen using Google Docs as a whiteboard for the candidate, and I'd heard about Sandstorm's Etherpad, so I signed up, launched that, and shared it with the candidate. Was quick and easy and we were able to go on with the phone screen.


When talking about a publicly traded company, "most valuable" generally means "market cap", and indeed, that's what it means in this case.


I don't really see why it would be odd, other than the ecosystem not having quite caught up yet with some other languages. It's an expressive, high level language, which makes being explicit about error handling very easy, the type system makes it a lot easier to guarantee at compile time that a number of errors possible in dynamic languages will never happen, and it's quite efficient.

The efficiency and explicit memory ownership in Rust makes it a lot easier to avoid some of the scalability problems you run into in dynamic languages. The amount of material you can find online on people discussing hunting down memory leaks in Rails, or discussing how they just scale up by throwing gobs of RAM and extra servers at the problem or restarting their app every day or two, is all stuff that is much easier to avoid in a language like Rust. It is possible to leak memory in Rust, but due to how explicit you are about how memory is owned, it's less likely and more likely to be easier to track down if you do.

It is a bit more conceptual overhead to learn Rust than many dynamic languages, but I think that overhead is well spent as it can pay off in performance, stability, and maintainability later on.


It's unfortunate that the ecosystem is such a strong point for so many people.

Sure I might need 250mb of RAM for a Rails app but there's 10+ years of real life thought and care put into the framework and about the same in external gems/blog posts/etc..

I'm ok with spending $5/month on an instance to serve a Rails app for 95% of use cases and I'm a load balancer away from multiplying my throughput if I need to scale out.

If I could snap my fingers and have the same ecosystem in Rust I would switch instantly but it's not the world we live in.

I'm not sure if even 5 years will be enough because Go 1.0 has been out almost 4 years and it's still not even in the same galaxy as Rails in terms of ecosystem.


Of course, now that increasingly more work is being done on the client side, or by communicating with microservices, Rust makes more sense for a pure API backend. There's a lot less ecosystem needed there; mostly just bindings to whatever database you need to talk to, possibly some other stuff.

So if you're just going to be exposing a RESTful API backend for a JavaScript based frontend, or even for a Rails app frontend to talk to, Rust makes a lot more sense.

Also, the only way an ecosystem gets bootstrapped up is by people scratching their own itches. By starting to write web services in Rust now, and implementing those things that aren't yet implemented, you can help to bootstrap it up. Of course, that only works if you have the extra time to spare to do so, but for those things that only need one or two extra things that don't yet exist, it may pay off due to the lower chances of having to debug runtime errors, less time and complexity spent trying to make it scale out, etc.


I would still prefer to use ActiveRecord and a whole lot of other pieces of Rails for an app that's purely an API backend.

Ex: http://edgeguides.rubyonrails.org/api_app.html

On the Python side of things, I'd use tools like SQLAlchemy and a few other packages.

Every web application I've built can still be efficiently modeled with a relational database. An ORM that lets me model things quickly and allows me to avoid shooting myself in the foot by easily monitoring raw queries is going to win in my book when it comes to picking a tech stack to work with.

The major ecosystem problem is that no one can just wake up and be like... I'm going to spend the next year making a Rust version of Rails. These features and ideas need to come from real life use cases, that's really 99% of Rails' success.

It can be done in any language of course, but you're 10 years behind the curve.


The current maintainer of ActiveRecord is writing an ORM in Rust: diesel. It's not a port, but still, you might be interested in checking it out.


Definitely interested on keeping tabs on it. Thanks for the heads up.

In a perfect world, it wouldn't be a port, but something that meshes really well with real world use cases while taking advantage of what Rust has to offer.

I don't mind change (I embrace it), but it needs to be for a REALLY good reason.


I don't necessarily think that it's an either/or situation. I started out with dynamic languages, then did a mix of dynamic languages and C++ for a while (C++ engine with Scheme based scripting language), then went back to dynamic languages, and am now getting into Rust.

You are likely to have a mixed audience as well; even if not everyone has that mixed experience like I do, there will probably be a mix of people in the audience. So, it would probably be a good idea to have some examples and descriptions tailored towards those with a C++ background, and some towards those with dynamic language backgrounds.


He's a professional 2 Dan in the Chinese Weiqi (Go) Association (source: http://gobase.org/information/players/?pp=Fan%20Hui).

EGF and AGA have only just in the last couple of years started giving professional rankings, so most professionals in Europe and the US still have their professional rankings from China, Japan, or Korea, rather than European and American associations.


When someone calls that, they wouldn't expect the input to be consumed.

  >>> list = [1,2,3]
  >>> sum(list)/len(list)
  >>> Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ZeroDivisionError: integer division or modulo by zero


Thanks. I keep forgetting py isnt working on a copy of the var. copy.deepcopy() kinda fixes it, but then memory use is doubled, and the recursion limit kills it all anyway. I better go read my py code...


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: