Lanzaa

Does anyone have any classic examples of zugzwang in the game of Go?

Having only hundreds of training examples and fitting hundreds of models seems like a good recipe for overfitting. Have you noticed any issues with overfitting? Or maybe there is something that I am missing.

This type of off-by-one error is so common it has its own name: fencepost error[1].

One little note, is that I would disagree with your correction.

> This should be corrected to:

> > The number of values between the two is 0x3f800000 - 0x00000000 == 0x3f800001

I think the value originally computed was correct. It would make more sense to correct the wording rather than just the computed value.

i.e.

> The number of values in the range [0x00000000, 0x3f800000] is 0x3f800000 - 0x00000000 + 1 == 0x3f800001

[1]: https://en.wikipedia.org/wiki/Off-by-one_error#Fencepost_err...

Once they have a collision in the sha1 portion, making changes so the md5 portion also collides should only take a few CPU seconds.

The complexity of creating a collision for both hashes is pretty much just a sum of the two complexities. Since the sha1 collision is more difficult, that dominates the cost.

Once you have the sha1 collision, making the md5 collide should only take a few seconds of CPU time.

The quality of game renderings will lag behind movie renderings for a long time. At 60fps there is about 16.7ms available to render each frame.

For a movie[1]:

> There's a principle I call The Law of Constancy of Pain. Back when we made The Adventures of André & Wally B. in 1983 a typical frame took from several minutes to a few hours to compute. Now computers are literally millions of times more powerful and a typical final render takes from a few minutes to a few hours to compute, averaging somewhere between 2 and 4 hours. Render times have remained flat for over 30 years because that's just how long people are willing to wait for them.

So movie artists are willing to have each frame of a movie take 2-4 hours to render vs 16.7 milliseconds.

[1]: https://www.quora.com/How-long-does-it-take-to-render-a-Pixa...

> it could give people gigabit level access, 20 to 30ms latency, everywhere on Earth

From:

http://shitelonsays.com/transcript/spacex-seattle-2015-2015-...

Via:

https://www.reddit.com/r/spacex/comments/5d9724/spacex_has_f...

You seem unable explain why she requires a diamond ring, which makes it very unlikely you would be able to change her mind.

Engagement/wedding rings are status symbols. Most women feel this more strongly than men. When first engaged most women will want the ring to be noticed and be rather conspicuous about making it visible. Many of her friends and colleagues will comment on it and having a high value ring will be a point of pride.

It feels good to show off. By saying you don't want to pay for a diamond, she may feel that she will be missing out on all of the pride and status effects.

My own tactic for convincing my wife to accept a moissanite stoned ring was simple. Reframe it as the higher status option. The moissanite stones are higher quality and have more brilliance. Moissanite are "conflict-free" stones. We went ring shopping together and allowed her to choose rings/settings that she liked. I pointed out that some of the settings would be out of our price range even with a flawed diamond, but we could substitute a flawless moissanite and people would notice the improvement.

Ultimately if she still wants a diamond stone, it is her choice and it is her status symbol.

If you spent much time looking at regexs you might enjoy this set of articles about improving regex engine performance:

https://swtch.com/~rsc/regexp/regexp1.html

The find utility is probably smarter than the other methods. I know two things to watch out for: sorting the directory entries and calling stat on each entry.

You might like to read the rationale section of PEP 471: https://www.python.org/dev/peps/pep-0471/

This looks like a very similar problem to the one dropbox wrote about in "Fast and Accurate Document Detection for Scanning": https://blogs.dropbox.com/tech/2016/08/fast-and-accurate-doc... https://news.ycombinator.com/item?id=12254517

This is exactly the link I was going to post. I think it does a great job showing that accuracy is not always the most appropriate metric for a model.

My bet is that Gavin was payed for his statement.

I think the issue is how quickly they identify the whales location. It seems like they have been able to track the movement fairly well. I imagine it takes a while to get a ship out to the identified location of the sound's origin, by which time the source has probably moved on.

Part of the reason is that humans are not run on batteries. Humans are more similar to fuel cells in that we consume oxygen to produce energy. We inhale oxygen, combine it with our energy stores and exhale 80% of the mass[2].

An average American man needs about 3400 Calories each day which corresponds to about 1 kg of oxygen consumed[1]. Similarly the average American woman uses 2550 Calories and .75 kg of oxygen.

[1] Design Rules for Life Support Systems http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/2004001... [2] http://www.livescience.com/49157-how-fat-is-lost-body.html

Orthogonal sparse bigrams (OSBs) have been implemented in CRM114 since the publication of that paper.

I think most proof-verifiable languages are too limited to prove many types of security correctness valuable to tor users.

For example, side channel attacks. A classic attack on computerized cryptography. I don't know of any proof language that can protect against side channel attacks.

If you look online there are a few lists of tor attacks. The attacks include: snooping on exit relays, application issues, traffic correlation, website fingerprinting, congestion attacks, blocking tor access (declining to extend). Most of these are issues in the design of the tor system, not something I think source code proof systems are capable of preventing.

I thought the article was good. It started with a basic premise, "Should we ditch Python and other languages in favor of Julia for technical computing?" Then the article shows several methods for speeding up python code to be faster than using julia. I was a little disappointed that pypy was not mentioned, but it is a good introduction to speeding up python code.

I think the flaw in the article is when it switches to answering, "did the Julia team [write] Python benchmarks the best way for Python?" Then it rewrites the fib implementation to use a cache, which makes the comparison to the julia version completely ridiculous. It also does all sorts of optimization which clearly deviated from the spirit of the benchmark, naive python vs naive julia.

I wish the conclusion had been written in a way that clearly answered the original premise, should we ditch python for julia? The article clearly showed that there are a lot of good ways to speed up python code. Looking for algorithmic complexity wins (like in the fib example), using cpython, using numba, and profiling all can be used to speed up python code to the level of naive julia code. Which leads to the conclusion, if all you want is faster code there is no need to ditch python for julia.

Very impressive. I'm sure people here would love to hear more about the challenges you faced and what kind of things were surprisingly easy to get working.

It looks like you followed the basic design of a Van de Graaf generator, so I imagine you had a very difficult time with static eletricity.

How did you handle alignment of the colors? Maybe a gray code and optical sensor on the back side of the bands?

One key thing that stood out to me was this:

> [GCHQ operatives] noted that the use of PGP could mean the contents were potentially valuable.

This good reminder that encrypting everything is important for security. Only encrypting valuable or sensitive information provides information to an attacker on where they should focus their efforts.

It sucks that so many servers are still vulnerable to the shellshock issue. I am impressed with OVH's openness in regards to reporting this issue. I am amused and impressed by their final comment/conclusion; "Obviously it is time to go to 2x100G on the private network between Europe and Canada."

Shock therapy had some interesting results in regards to this.

http://en.wikipedia.org/wiki/Electroconvulsive_therapy

I believe the network had become a bottleneck. As per the article:

> [O]ur Spark cluster was able to sustain ... 1.1 GB/s/node network activity during the reduce phase, saturating the 10Gbps link available on these machines.

If the network is the bottleneck it makes sense to reduce the number of nodes to reduce the network communications.

One basic difference between Count-Min Sketches and HyperLogLog is that Count-Min Sketches represent the cardinality of items in multisets while HyperLogLog represent the cardinality of sets.

For example, Put 3 of the item 'A' (where each 'A' is indistinguishable from another 'A') and similarly 5 of item 'B' into a Count-Min Sketch and a HyperLogLog.

When you query the Count-Min Sketch for 'A', you can probably get back 3. You can also query for 'B' and get back 5.

With you query the HyperLogLog you query how many unique/indistinguishable items are in the set, in this case 2. The HyperLogLog would return a number near 2. You could query the HyperLogLog for whether or not 'A' is in the set, but HyperLogLog are not designed to be accurate for that type of query. It would return true in this case and in general there are no false negatives for set membership queries in the HyperLogLog. I believe it would be less accurate than a Bloom Filter for set membership queries.

How are you determining which domain names are available?

Also, you may want to add some sort of contact feature for people to leave suggestions.

This is a very interesting way of solving the key distribution problem. It forces attackers to capture both the digital part of the key and the physical.

How do you encrypt data stored on your severs?

Also, the gli.ph https certificate will expire in less than two weeks. You may want to renew.

>> We encrypt data with 256-bit SSL in transit and AES-256 encryption before it hits disk.

> For us crypto-ignoramuses, what's wrong with what you quoted?

First off, it is very easy to get cryptography wrong. I wouldn't trust most people with being able to implement cryptography software correctly.

Buzzwords like AES and SSL are used to convey a sense of security. Their 256-bit SSL uses AES-256 to encrypt data in transit. While using AES-256 to encrypt a file doesn't mean it is secure. The mode of operation is very important. The following wikipedia page has a picture that was probably encrypted with something like AES-256. I will let you guess what the original picture was.

http://en.wikipedia.org/wiki/Block_cipher#Modes_of_operation

Another issue not discussed is key management. To encrypt the files with AES-256 they need to have the key. If someone breaks into their server, the server will have the key and the files. It becomes easy to break the security.

I don't think leaving and tweeting about how you feel is a very useful response. It could lead to a form of evaporative cooling[1] and cause the behavior of the group to worsen. It may be better to put pressure on the group to change. Find someone who is in charge and complain about the behavior you find inappropriate and encourage other people who find the behavior inappropriate to complain as well.

[1] http://lesswrong.com/lw/lr/evaporative_cooling_of_group_beli...

Verification is vital to security.

In your example having a self signed certificate would be worthless. If someone is performing a Man In The Middle attack on your users then they can also sign their own certificate while impersonating your site. Without verification your users would not know the connection to your site is compromised.

While the current system is not ideal, you should not try to completely do away with verification.