Mr_P

Masks are effective at stopping people from unintentionally infecting others.

See: https://www.nytimes.com/2020/04/10/well/live/coronavirus-fac...

"Even a simple mask is very effective at trapping droplets from your coughs and sneezes. A recent study published in Nature from the University of Hong Kong and the University of Maryland asked 111 people, infected with various viral illnesses (influenza, rhinovirus and a more-mild coronavirus), to exhale into a giant funnel. Sometimes their noses and mouths weren’t covered; other times they used a simple, not-particularly-well-fitted mask.

Without the masks, the infected people exhaled contagious droplets and aerosols, tiny particles that linger in the air, about 30 percent of the time they were tested. When the infected patients wore a mask, it blocked nearly 100 percent of viral droplets and some of the aerosol particles."

Researchers at Adobe published similar work several months ago:

https://news.ycombinator.com/item?id=20978055

Interestingly, FB folks used a vastly simpler network architecture, but it probably still works because they have access to so much real data. In contrast, the Adobe paper had a fairly involved network with pretrained VGG features, possibly to compensate for only having synthetic data to train on.

> For visualization, I prefer the way H3 looks over S2. While that’s just an opinion, H3 grid is exposed directly to drivers and in lots of tools.

Ah, yes this makes a lot of sense. The video in the link actually does have a nice comparison at 17:30, where this is called out. It seems to me to be the most compelling argument for hexagons.

I'd be curious to see a more thorough comparison to S2, which IMHO seems simpler (it's just quadtrees) and likely faster (it supports O(1) lookup vs. needing a hierarchical search).

This may be a reference to texture streaming. While I've never developed for consoles, I do know that texture streaming on desktop & mobile can be challenging.

Being able to mmap a texture directly from ssd (as if it were RAM), with the hardware & os taking care of all the details, could be a big deal for developers.

Edit: To get a sense of how challenging this can be, see this recent talk from GDC for texture streaming in Titanfall 2: https://www.youtube.com/watch?v=4BuvKotqpWo . Literally all of this complexity would go away if you could mmap textures directly from disk and let the gpu handle it.

This happened last year:

https://arstechnica.com/gadgets/2018/02/internet-rages-after...

If you take a step back, Google's launch & deprecate cycle for new products actually kind-of makes sense.

Internally, Google is not so different from an ecosystem of VC-funded startups. They try a lot of things. Some ideas work and others don't.

The alternative is to never ship new products out of fear of failure. Or, to indefinitely support everything, regardless of how tiny. Or, to wait so long to derisk a new product that they possibly miss out on a new market (I'm looking at you, HomePod).

At the end of the day, this strategy has worked out well for them, so why stop? For every failure like G+ or Allo, there's a success like Google Photos or Duo.

Ceres is great for sparse, structured non-linear-least-squares problems (that is, problems where levenberg-marquardt is applicable). I believe it was initially designed for bundle-adjustment problems arising from structure-from-motion applications.

Ceres also does work for dense problems and general convex optimization, but it doesn't provide as much of an advantage over other packages (that is, you could just call into any existing l-bfgs implementation and wouldn't benefit much).

For some other problems, Ceres doesn't scale or can get in the way. For example, if you have a single value to maximize and a large number of variables, then ceres' auto-diff system won't work (ceres::Jet is based on "forward-mode" automatic differentiation, storing partial derivatives on the stack. If you have a high-dimensional gradient, it can exhaust stack space). On the other hand, Ensmallen doesn't seem to come with any auto-diff functionality.

How is this #2 on Hacker News? There's literally nothing here about how to actually build a database (yet?)

Instead, there's just a key-value store implemented on top of a javascript hashmap and a filesystem.

This isn't the first time something like this has happened.

Pinscreen was also accused of faking results, including those shown off at Siggraph 2017. https://www.theregister.co.uk/2018/07/18/pinscreen_fraud_cla...

This used to be the case, but these days many fundamental Google tools are open.

Borg is Kubernetes, flume is externally available as Google Cloud Dataflow (it's basically Apache Beam), Tensorflow is open source, many of Google's internal java libraries and tools are available externally (Guava, Guice, Dagger), and absl (c++ common libraries) are also available externally.

More importantly, assuming you land on a team with strong software engineering culture (this is likely, but admittedly not guaranteed, even at Google), the general skills you pick up for software design, planning, testing, etc. are transferable anywhere.

That said, all of this applies mostly to software engineers. If you're applying for an SRE position, then I've heard the experience is less transferable, but it's not something I could comment on first hand.

To put things in perspective, though, Zuckerberg is CEO of an international company that's constantly under attack by state-sponsored actors. He also spends $10 million on physical security.

In contrast, a non-famous person probably doesn't have as much to worry about, hence why I personally don't cover my smartphone camera.

Alex Evan's talk on developing the renderer for Dreams:

He's given several versions of this talk (including the Advancements in Real-time Rendering course at Siggraph), but here's one available online: https://www.youtube.com/watch?v=u9KNtnCZDMI

One of the best talks at Siggraph last year was on Bungie's particle system Destiny 2 (slides are here: http://advances.realtimerendering.com/s2017/index.html). The talk was an elegant breakdown of how they (1) created a CPU interpreter for a domain specific language describing particle parameters, (2) ported it to the GPU (even running an interpreter on the GPU for parts of the production game!), and (3) how they converted it into a compiler for the obvious performance wins.

Apparently running bytecode interpreters on the GPU is not uncommon: https://dolphin-emu.org/blog/2017/07/30/ubershaders/

Seriously. S2 is just quadtrees over a cubemap, with a nice mapping from integers to cells.

So, instead of using a quadtree (because it's "complicated"), they chose to make their own two-level tree requiring O(N) linear scans at both levels, as opposed to O(1) with a simple trick.

> If cryptotocurrencies continue down this path, it’s quite likely these types of organizations could cease to exist. Resulting in a huge energy savings.

These people will still be employed, and other people will be consuming energy maintaining bitcoin farms, designing new mining hardware, etc.

> As for my goals, it is to work in high-performance computing, in particular with aerospace. My example: adaptive resolution grids for fluid simulations.

If this is what you really want, then just do it!

Research whatever you need to implement a fluid simulation program, stick it up on github and put it on your resume.

Doing so accomplishes several major things

1) it makes it extraordinarily clear to employers that you can actually do the work that you want to do

2) it makes it clear that you can teach yourself to learn whatever else you might need to know to do the job

3) it demonstrates the kind of self-motivation that "reputable tech companies" look for

Alternatively, find a Coursera course on something you're interested in and just do it. You won't get much more out of college than you can from free online courses.

> I keep hearing about outrageous training times for GPUs on the order of weeks with something like 4-8 GPUs

This is for training a competitive model from scratch on a fundamental problem like image recognition. If you don't care about the last 1-2%, it's possible to train a useful model in a few hours (but still on a GPU).

> is anyone actually using CPUs instead

There are useful things you can do without a GPU. For example, "Transfer learning", which can be as simple as chopping off the last layer of someone else's GPU-trained model and substituting your own, can be done on a CPU in reasonable time. This is because you typically need less data and because far fewer parameters need to be fit.

For example, HBO's "Hotdog/Not-hotdog" app was done this way. See their description of "V1" here: https://medium.com/@timanglade/how-hbos-silicon-valley-built...

They already check fingerprints. I don't see how this would be significantly different.

That animated gif is ridiculously misleading. To someone who doesn't know what's going on, it would look like this can hallucinate Emma Watson's face out of a 5x5 px image.

Instead, this is essentially a fancy 2x upsampling, and the gif shows every other frame as a super-resolution result. In fact, if you look at details like her eye, it's not even doing that great of a result (unsure if this is supposed to be impressive given the current state-of-the-art).

When I was in college, 2 fire trucks would be dispatched for some burnt toast (on an unfortunately regular basis).

I think it makes sense to be conservative when responding to a fire at a battery plant.

Simplex. If you can transform your NP hard optimization problem into an LP, simplex can often work like magic.

The rendering equation. Because the fact that it's hard to evaluate means I have a job.

Some basic suggestions:

All of the blur/ functions could see big improvements with some simple changes:

* Use separable kernels whenever possible (this reduces a O(K^2) evaluation to 2K evaluations)

Some filters (like your box filter) can be done efficiently as a linear combination of IID filters (i.e. implicitly computing a pair of running sums, subtracting one from the other as you go).

* The convolve/ package could use some cache blocking, and should definitely have the conditionals on the inner-loop removed.

Unfortunately, these changes will likely make your code a bit more difficult to read.

This is one of the reasons Halide has become so popular for image-processing (if you're interested in high performance image processing without sacrificing maintainability, Halide is definitely worth looking into!)

> one about unlimited unpaid overtime

Am I misunderstanding something, or isn't this the definition of a salaried position?

> second one about losing all intellectual rights to ANYTHING done/written/created ANYTIME and ANYWHERE (including things not related to company's business and/or technology in own spare time, holidays and so on).

This also seems extremely standard (at least it's in every employment contract from the big tech companies), and probably exists more so to protect the company from extreme circumstances than anything else (although I am not a lawyer).

Google's Native Client was exactly this, but it never caught on. PNaCl is a proper subset of LLVM bytecode.

Could it be because golang supports unicode identifiers? For non-native English speakers, it must be more difficult to program in ASCII-based languages, right?

From the demo video (and the ugly tearing artifacts in the image shown at the end), this looks like someone took seam carving (http://en.wikipedia.org/wiki/Seam_carving) and made an IOS app from it. This isn't even close to state-of-the-art in image retargetting.

So, it's an RSS reader with a hard-coded list of sites?

> It's essentially a list of projects that every single individual and team is working on. Each task shows what needs to get done, what has already been completed, and how many hours it should take. It also shows what everyone is working on at a given time. If someone needs something, he just creates a new project.

It sounds like they made another bug tracker.