ddinh

Something like this is already being done for made-to-measure apparel, e.g. https://www.mtailor.com/ for men's clothes and https://www.topologyeyewear.com/ for glasses (also - does anyone know if there's a service like this for women's clothing?). I do wonder how they're determining scale - seems fairly simple if you have two focal lengths, but these services seem to support single-camera phones as well. Are they getting data from the accelerometer to see how much you move your phone when you move it around your body/face?

The main problem now seems to be fully automating clothing manufacturing - it would be pretty cool to be able to scan your body and have a machine print out perfectly fitting clothes, no human required.

Just curious - why is looking up yourself an offense?

I wonder how long it will take before somebody figures out how to jailbreak BMW infotainment systems to enable CarPlay. This kind of stuff is not exactly without precedent: https://www.greencarreports.com/news/1099782_bmw-i3-rex-elec...

It's supposed to expire at the end of 2018: https://arb.ca.gov/msprog/carpool/carpool.htm

Whether or not it will be extended again is an open question.

Quick note that the article is from 2015, and the MSS result dates back to 2013.

There's a blog post by Nikhil here that explains the proof of the discrepancy result that implies Kadison-Singer: https://windowsontheory.org/2013/07/11/discrepancy-graphs-an...

The main result is a theorem that replaces a Chernoff bound (saying here that a random partition has discrepancy logarithmic in the number of vectors with high probability) with a bound that says achieves a better bound on the discrepancy, independent of the number of vectors, at the cost of replacing the "with high probability" with "there exists".

The proof uses some really beautiful techniques from the geometry of polynomial roots to prove this and is a pretty fun read: https://arxiv.org/abs/1306.3969

I imagine you could encode the problem as a CSP with each of the legal/contractual factors as a constraint. Despite NP-hardness of CSPs in general, CSP solvers are pretty efficient if the constraints are sparse enough and not chosen adversarially.

This is an awesome tool. Thanks!

Only issue I've run into so far is that cross-references to theorem numbers don't seem to always work correctly, e.g. you'll see a lot of "Theorem ?" in https://www.arxiv-vanity.com/papers/1607.06711/.

One other interesting example: Mahler's first symphony, third movement (https://www.youtube.com/watch?v=U5A5tFyXQio) which incorporates a minor-ized version of the classic (major) Frere Jacques tune as a motif.

...until people start dying and babies start getting born in space.

It's not rocket science by any means, and the 'well behaved' case for matrix multiplication (sufficiently 'squarish' dimensions, i.e. not too similar to a dot product, running on a known system configuration) has been beaten to death, revived, and beaten to death again many, many times and current libraries can get ~90% of theoretical peak.

That being said, there are a lot of nontrivial cases and pitfalls lying around that can cause some grief to someone trying to reinvent the wheel, as well as open theoretical problems that could lead to significant speedups if they're resolved. Here's a short and definitely not complete list of these:

- Communication costs (transferring data between fast memory and slow memory, e.g. cache <-> memory or GPU memory <-> main memory) is the bottleneck in most cases. The asymptotic communication costs (both in terms of lower bounds, and in terms of attaining said lower bounds through a judicious choice of tiling sizes) of many of these problems are well-understood (see [Irony-Toledo '04] for the classic work on this, extended to most of linear algebra by [Ballard et al. '14]), but these asymptotic analyses have lots of hidden constants and parameters that need to be optimized for not just a given architecture but also a given problem size. For instance, suppose you have an inner-product or an input of sufficiently similar dimension (i.e. multiplying matrix of dimension mn by matrix of dimension nk, n >> m, k). If you're going to split this thing up into parallel blocks (e.g. through divide-and-conquer along the 'middle dimension' n, since we assume the other dimensions are small enough that you can't split them up too much) you'll have to allocate nksizeof(double, or whatever your matrix elements are) additional memory for each thread, since each thread needs a place to store its sub-result before they're all summed together. The theory will tell you that replicating until you fill up your memory is "optimal" (i.e. within a constant factor of the theoretical communication lower bound), but that constant can be fairly large (integer-factor in many cases), and optimizing that mostly is a matter of experimentation and intuition. In fact, back in 2013 the latest release of both Intel MKL and PLASMA did not deal with this case particularly well, although I haven't tried more recent versions.

- Floating point addition is not associative and if you're using parallelism, there's no guarantee that two subsequent runs of the same program will give you the same result since the additions can happen in any order. For some cases, most notably debugging (but also times when you need code that meets certain verification or contractual requirements - you can't have code giving different results at different iterations) you want 'reproducibility', which is very nontrivial to implement (see: ReproBLAS project).

- Precision issues: Do you need double-precision numbers? or will a single-precision or something smaller work? Often problems are more sensitive to certain results than others, so you'd want to switch between different precisions at different stages in your problem for additional optimization (see: Rubio Gonzalez et al.'s paper on Precimonious).

- Matrix multiplication (and therefore all the other algorithms that depend on it, e.g. GEPP, TRSM, Cholesky...) has significantly faster algorithms than the classical O(n^3) naive one. Strassen's method (runtime ~O(n^2.8)) is sometimes used in practice, but there are algorithms with significantly better exponents (I believe the world record is currently held by Le Gall at somewhere around 2.37). Unfortunately, these algorithms tend to have massive constant factors render them impractical for real-world use, and as far as I know figuring out if these can actually be applied these in practice is an open problem. Reducing the exponent (or finding lower bounds for it) is also an area of active research of importance to not just the numerical linear algebra community but also to the complexity theory crowd (since a lot of problems can be reduced to matrix multiplication).

- Advances in taking advantage of matrix structure to speed up linear solvers, most notably with Laplacian/strictly diagonally dominant solvers started by Spielman and Teng in '04 and built upon in recent years. As with the faster matrix multiplication algorithms many of these solvers are not yet competitive compared to stuff used in practice (multigrid methods and the like), which don't have the same kinds of guarantees but run quickly in practice. (I don't believe that there's been a whole lot of work in terms of actually implementing and optimizing of Laplacian solvers either). In the theory world it's also interesting to ask how far these efficient methods will go (how large is the class of systems that you can solve quickly?) - Kyng and Zhang have a paper this year, for instance, stating that fast (nearly-linear in the number of nonzeros of the coefficient matrix) solvers for a slight generalization of Laplacian systems (multicommodity Laplacians) would lead to similarly fast linear solvers for all linear equations, so either there are limits on how much you can take advantage of structure or we're going to see some super-fast algorithms for general linear systems.

The iPhone does. The iPad does not. Why Apple hasn't made an official weather app for the iPad yet, I have no clue.

What about space artifacts? Out in the vacuum stuff corrodes/degrades much slower - would satellites still be around or would they have had their orbits degraded and burned up in the atmosphere? Also, how detectable would the stuff we've left behind on Moon (the mirror, perhaps? Only thing that can probably destroy evidence of our presence on the moon would be asteroid impacts) be to a civilization that doesn't know it's there?

You can block all cookies on the website if you want a paywall bypass that works without needing incognito - an extension like uMatrix [1] does this persistently (click on the plugin icon when your browser is navigated to The Economist, then click on the bottom half of the "cookie" box in the "all" row. The column should turn red, indicating that cookies are blocked).

[1] https://github.com/gorhill/uMatrix

It's fairly standard practice, as long as the aircraft involved are certified for it and flying on autopilot. Given that the planes involved were flying at FL350-60, they probably were (altitudes above a certain threshold - FL290 in the US) are restricted to aircraft operating under rules allowing 1000ft vertical separation.

https://en.wikipedia.org/wiki/Reduced_vertical_separation_mi...

Blocking javascript on that website also works.

Previous discussion: https://news.ycombinator.com/item?id=12759520

Non-paywall link: http://www.business-standard.com/article/beyond-business/why...

(The site will try to prevent you from reading the article if you have an adblocker, but you can bypass it by blocking all scripts.)

In terms of reducing the ability of speedy traders to gain an advantage in a continuous time market, how does IEX's fixed time delay compare to discretizing the timesteps, so all the trades within some finite interval [t, t+e] are treated as if they came at the same time?

This talk presents compares discretization to standard continuous-time bidding, but doesn't go into a lot of detail about how it compares to IEX-style delays: https://simons.berkeley.edu/talks/eric-budish-2015-11-19

The link seems to be invalid; here is a working one: http://www.americanbanker.com/bankthink/money-laundering-is-...

For local backups, Apple says [1] that "There is no way to recover your information or turn off Encrypt Backup if you lose or forget the password." so I'm inclined to thinking it's done with a secure symmetric encryption scheme with the key held by the user. If that's the case, since iTunes prompts you for a separate backup password (only used when restoring a backup), a security-conscious user would probably make that password sufficiently long as to be impossible to brute-force, regardless of any help from Apple.

[1] https://support.apple.com/en-us/HT205220

If the FBI were to do this, would it be possible for Apple to counter it in the future by splitting the key across multiple entities, some in non-US jurisdictions, in such a manner that all of them would have to agree to sign anything?

Previous discussion: https://news.ycombinator.com/item?id=10200249

Scott Aaronson wrote a survey about that topic here: http://www.scottaaronson.com/papers/pnp.pdf

If you have a pilot's license, yes. Big airports often have hefty landing fees, though, and you'll spend a lot of time waiting for your turn to take off or land, which is less of an issue at smaller general aviation airports.

I can't remember if there's a similar thing as a background compilation that highlight errors as you type.

Check out Flycheck: http://flycheck.readthedocs.org/en/latest/

Sebastian Mallory's More Money than God is another book worth looking into for a broad overview of the history of hedge funds.

It appears to be a page of stories with new users.

Possibly intended as a quasi-response to https://news.ycombinator.com/item?id=7445761 ?

I'm personally fond of Fantasque Sans Mono.

https://github.com/belluzj/fantasque-sans

I find homebrew-cask's font tap to be a particularly useful tool for managing fonts on OSX.

https://github.com/caskroom/homebrew-fonts

Yes, you can set an EFI password on Macbooks: https://support.apple.com/kb/HT1352

Here's the original post, in case the 4chan thread gets deleted:

A few months ago I posted here looking for help with a SD card I found while renovating a school. It was hidden in a wall outlet, and had several files with names on them, and obviously was a bunch of encrypted containers.

Well, I managed to brute force one of them and inside was more containers, but a month ago I managed to open another and this time there was videos and pictures, stuff that made me go to the cops right away.

So I turned over everything to them and told them all I knew, and that's when the bullshit began. Right from the start the police thought I had something to do with it. They took every device in my home that could store data, my phone, my laptops and computers, my PS3, even all my USB drives and camera. They questioned my family and went to my job and harassed everyone that I had any contact with,

Right now I still haven't gotten any of my property back, and my friends and family think I am a creep. I am writing this to give a warning to everyone that works with IT if they end up in a situation like me. Don't go to the authorities, don't try and do the right thing, don't say a fucking thing just destroy what you found and move on. Trying to be a good person is just going to fuck your life over