skysight-inc/HackerNews huggingface dataset:
Really nice docu. Regarding A* sorry, but QTFPS is superior.

https://github.com/spring/spring/tree/9bec15418279f1ecd87a55...

Always fascinating is the actual Edge-Case Handling (UnitsStuck). Setting Collission off and sending Units back shortest path can yield unexpected results there.
It clearly did reduce work, and the article spells out how.

You're just okay with the reasons for that reduction, which is quite a different thing to claiming there was no reduction.
I'd have thought so as well, but the github repo was the first result for "lego encrypt", and this thread the second. Not so bad.
ASNtryst
Ravens can talk
Uninstall Notepad++ if you have voted for FN
> Proof-of-Stake is nothing new, and it has serious problems: https://en.bitcoin.it/wiki/Proof_of_Stake

Would you mind pointing to the relevant sections?

I wasn't able find criticism about Proof-of-Stake there. Instead, the beginning describes the problems with Proof-of-Work (which Proof-of-Stake tries to address). The large middle part describes some systems which mix both PoW and PoS.

> People just don't like it because it challenges their economic worldview

Not sure how this is relevant to the discussion about Bitcoin hypes and Ethereum.

In particular, I don't see why the people who implemented Ethereum shouldn't like Bitcoin. And even if they do dislike Bitcoin, I'm pretty sure this is not because it challenges their economic worldview, as Ethereum challenges the common economic worldview even more.
It's similar in C. C11 Standard chapter 7.1.3:

>All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use.

I doubt the library is usable in C++ though, since longjmp doesn't play well with the destruction of local objects.
https://en.wikipedia.org/wiki/Music_engraving
I would suggest "He introduced himself as Jack." since we don't actually have access to the name property of people.

Perhaps English speakers found his real name too hard to pronounce, or perhaps he lives under an alias after joining the witness protection program, or perhaps he works as a super spy.
You can say British instead of Great Britain Residents;
Attempting the first unsupported, unassisted solo crossing of Antarctic landmass
Otherwise known as an "abstract". Arguably this document has one, but it's a few lines down behind what would in the printed original be on the inside front cover.

"Here is some little known data which may be of interest to computer hackers. The items and examples are so sketchy that to decipher them may require more sincerity and curiosity than a non-hacker can muster. Doubtless, little of this is new, but nowadays it's hard to tell. So we must be content to give you an insight, or save you some cycles, and to welcome further contributions of items, new or used."
I like it! Always wondered why some of the built in commands don't evolve in more holistic ways, like 'cd to wherever I usually go after here'
Agreed. I remember unpacking binary data in Python 2.7 during my late undergrad and found it much more cumbersome. I bookmarked the article in celebration the next time I'm doing something like that again.
A lot of business services companies, providing a registered address, etc, do this (for individuals, brass-plate overseas offices, or individuals that don't want their own address known). It costs around GBP 90 for a London (UK) registered address and unlimited mail forwarding (physical or scanned email).
Not very much surprising in here, including the overwhelming preponderance of London. London is popular not only because of job availability but because it has much better public transport than almost every other UK city. This is because it gets a disproportionate share of public money for it.

http://blogs.new.spectator.co.uk/2013/12/london-is-different...

http://www.transportnorth.org.uk/london-versus-the-regions/r...
"no, there is nothing wrong with Go’s map implementation."

"Getting your locking wrong will corrupt the internal structure of the map."

Ahem.

If you have a non-concurrency-safe map implementation in a language that's advertised as being good for concurrency, there is definitely something wrong.
It's still very cumbersome, especially compared with state of the art. You may want to look at how it works in Erlang.
Are purity checks that hard to implement?

I don't know much about this...

Check that the function only writes on local variables and only reads closure variables and only calls other pure functions.
Which makes no difference to me.

If I can’t say in court "I believe the patent is invalid", then I can’t use the software.

It’s not "free" if they require you to believe their political ideas to use it.
Auto Date and Time Stamp on Photo
The two sentences are consistent once you read that Go maps are not designed to be safe for concurrent access.
Watch Comet Catalina Fly by the Moon and Venus in the Coming Weeks
Scripting language PHP releases PHP 7.0.0
Yes definitely. I am become deliterised.
> we still aren’t writing about tshirts and xrays.

You and I might not be but a lot of other people are. Google returns 54M hits for x-rays and 28M for xrays.

The status of T-shirts is a bit clearer 340M versus 18M.

And of course I haven't taken into account how Google handles word variants.
How do audiophile consumers rate and rank over-ear headphones? I'm wondering what criteria they use. I'm talking about good quality cans for listening to music, not fashion statements.

I'm sure this has been discussed on HN before.
I work professionally with audio to some extent, and I can hear the difference between 320 and wav in some cases (on my own home setup, of course) — but if a layperson asks, I'd advice them to buy Beats instead of professional monitor headphones which have better sound quality for less money. It's simple: if you can't tell the difference between 192 and 256, and are going to listen to Spotify stream anyway, it makes more sense to invest more into the appearance than in sound.
I have suspect that naive architecture of a program is heavily affected by native language of the programmer. My native language is easy to parse (14kb parser can parse 98% of technical language, while 200Kb parser can also fix errors), logical and composable, which may be the reason why there is so high rate of good developers from my country: not because we are smarter than average, but because we are taught from birth to think logically.
I have doubts about the fairness of voting in general. I would prefer https://en.wikipedia.org/wiki/Sortition to select members of the parliament. And to add another smart quote:

"It is accepted as democratic when public offices are allocated by lot; and as oligarchic when they are filled by election." (Aristotle)
I found construct quite good to parse binary data too. Had used antlr with java but needed something simpler and for python.

https://pypi.python.org/pypi/construct
> Ahem

Maps are not concurrency-safe, you know what else isn't? Integers, floats, pointers, structs. And not only in Go, but in pretty much almost all languages with mutable state, like C and C++.

The map implementation in Go is consistent with the rest of the language, plus it allows for great performance under some rather common scenarios.

But I guess it's fashionable to snark on message boards than rather understand all these facts.
Java's (pre-concurrent) HashMaps aren't designed for concurrent access.

Do you know what they do? They throw a ConcurrentModificationException.

Do you know what they don't do? Silently corrupt themselves.
On the other hand, grid refs are a bit more human friendly, and can be used much more easily on OS maps than lat/long. They clearly wouldn't work on a global scale, but generations of Scouts would be lost without them!
Computer Science High School Coming to Richmond VA
Just Video Feeds for Facebook
I apologise for expecting better of language designers. After all, the solutions to these sorts of issues has only been around for a couple of decades. Far too soon.
Humans Are Draining Even More of Earth's Freshwater Than We Thought
Sometimes I use E-Prime as sort of a verbose flag for English.

Instead of: "Mount Everest is almost 8 km tall."

A verbose E-Prime version would sound something like: "I recall having read an Wikipedia article that reported the height of Mount Everest as almost 8 km."

Notice all the extra verbs in there.

"Recall"? Could I have mis-recalled?

"Read"? Could I have misread?

"Reported"? Could Wikipedia have misreported it, intentionally or unintentionally?
If I stay at my current employer, in 2025 I'll most likely be maintaining an MFC application in VS2015, quite possibly on the same workstation I'm using at the moment.

We don't update very often. Currently I'm using VS2008.
Not everyone who lives in the UK is a British National
Yeah, but the parent's phrase was:

"If you have a non-concurrency-safe map implementation in a language that's advertised as being good for concurrency, there is definitely something wrong".

If we accept his premise, then the fact that "they wasn't designed for that" is no excuse. It's like selling a kids toy that has tiny choke-inducing parts. In that case, just saying: "It wasn't designed to be eaten by kids" is not really an excuse.
The sad part about the headphone market - especially over the ear models - is that the sound they produce is so far from natural, that no one knows what thinks actually sound like anymore. Beats headphones are a perfect example and are probably the worst offender of them all. This ends up affecting everyone - even those of us who choose a pair of headphones that are "flat" or better at being acoustically transparent. Just as recording and mastering engineers learned to change the sound of their albums to sound better on small little "boom boxes" in the 80's and early 90's, today they alter the sound so they work on these grossly inaccurate headphones.
"A boy called Jack"
Can you tell what your native language is? Finnish?
From HashMap JavaDoc:
Note that the fail-fast behavior of an iterator cannot be guaranteed
as it is, generally speaking, impossible to make any hard guarantees in the
presence of unsynchronized concurrent modification. Fail-fast iterators
throw ConcurrentModificationException on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators
should be used only to detect bugs.

So even while Java tries to find concurrency bugs, it does not promise it.
Possible biochemical mechanism underlying long-term memories identified
OP here. Short on details right now since this was just released. CodeVA doesn't have anything even on their website yet. http://www.codevirginia.org/

If anyone can make this work Code VA can. Code VA is already making a difference in the state of Virginia for k12 Computer Science education. They have been writing curriculum for K12 in I beleive 8 counties. They teach teachers how to teach CS and pre CS concepts (math, critical thinking, problem solving...) My youngest daughter has worked with them from time to time with helping disadvantaged students start to learn CS. We have been impressed with their ability to execute every time we have seen them in action.

As a member of the RVA community I really hope this is a successful venture.
Not to mention that Go does have the race detector, which does the same thing in this case (although it does so much more in general).
Seems like a bit of chicken-and-egg problem; overcrowded city leads to better public transport, which leads to more overcrowding, which leads to...
That check probably comes at a performance cost that the Go standard library designers found unacceptable. You don't even need to be modifying it concurrently to read inconsistent state, it's enough to write on one thread and read on another, while the map is updating internally. So in order to prevent inconsistent reads you would have to check for concurrent access on all reads. The .NET BCL Dictionary is just like the Go one: it does no checking for you and will silently corrupt or return an inconsistent view if you access it concurrently.

The whole reason there are two implementations of the dictionary (Concurrent and Non concurrent) is that the performance cost of the concurrent implementation is too high to carry for the non-concurrent one. Depending on the cost of checking for concurrent access, a lot of the gain of using a simpler non-concurrent one could be lost.
Worked at a sales department in 2010, my office (or closet) was in front of the main A3 printer. It was running dusk till dawn. Most of the employee despise computers (partially for good reasons: bad IT contracts and not tailored tools and devices => rageprint).

Most of the prints had a lifespan of 1 hours before being thrown out. Mostly scratchpad for too large spreadsheets.
All the language designer can do is throw in a lock that you may or may not need if you're already locking properly. ConcurrentModificationException is nice, but comes at a performance cost.
If looking at the common pipe chains from shell histories tells me anything, it is that people are not very familiar with the tools at their disposal.

Just look at some of these chains:

ps | grep
cat | grep
find | grep
find | xargs
grep | wc
ls | grep
echo | grep
grep | grep

The legitimate uses for those pipe chains (while they do exist) are few and far between...

A particularly odd one on the list was `type | head`. Does anyone know the purpose of this?
Show HN: DroidLane – Android Studio upload apk helper plugin
$548M to Be Paid by Samsung for Copying Apple iPhone Designs
From performance viewpoint the concept is far from practical right now, and I don't mean practical implementations, I mean the current best theoretical limits for overhead.

Basically the encrypting process itself takes longer than any operation that can be done on the on the cloud. Thus it's better to just run the software without the encryption on the device that would normally contact the cloud itself.
Have a look at the information available at http://www.head-fi.org
Can also download in JetBrains site: https://plugins.jetbrains.com/plugin/8068
Just got me thinking, shouldn't we try to have a spectrum of antibiotics switched regularly as some form of 'wear levelling' for bacterial resistance ?
And I here thought FIX is a fictional protocol devised specifically for this game...
This is a library thing, not a language thing. And it's a performance tradeoff: they could have shipped with a concurrent map only, that is 1/10 as fast as the current one, but never causes a data race. However everyone that isn't doing anything concurrently would be paying for it. Not very clever. I trust the class library designers thought this through. They reached the same conclusion as pretty much every other library designer in every other language. For the same reasons.
Within E-Prime some people think that using the verb "to be" for expressing stay, location etc should be allowed. For example: "The shop is over there" or "the cat is on the map" should be allowed. However I think the majority of E-Prime likers think that these should be excluded.
Thanks. I've looked at etherium and it's an intriguing idea. How do you think it stacks up vs something like ripple or hyperledger, which are based on the byzantine fault tolerance idea?
For those of us who know little about all of this can you explain in simple terms the different approaches and why you think one might be better.
I guess because it's historically interesting.

For your convenience, the paper mentioned in this article, "Goethe's Second-Price Auction", can be found at https://www.econ2.uni-bonn.de/pdf/goethes_second.pdf
Why couldn't I figure this out by myself?! Thanks!
It was that easy? Man. Looking forward to giving these a shot...
Any data structure that isn't explicitly designed for concurrent access will not work when used concurrently.

Since a concurrent map (aka. Dictionary aka. Hashtable) is a lot more complex and slow than a non concurrent one, it's very very unlikely that Go would ship with its standard map type being a concurrent one. It would be a huge waste.

More likely there is a separate concurrent map type. It's exactly the same in other languages with mutable collections (Java, .NET, C++, ...).
Erlang's binary matching is beyond awesome, and OCaml has a pretty good implementation of it as well (Bitstring) [1].

Cool thing about Elixir is of course that awesome Erlang binary handling is available and very easy to use.

Lots of people have been lobbying for something like this in Rust, given its low-level orientation, but there's been resistance to the idea from the core devs, who want it to be done using syntax extension.

1. https://rwmj.wordpress.com/2010/02/03/on-the-awesomeness-of-...
I think there is a big difference between "being good for concurrency" and preventing all concurrent programming problems - concurrency is hard and while go does seem to provide a lot of nice structures to make it more straightforward it can't, and doesn't appear to claim to, hide all the complexities of concurrency from developers.
Know of any video links to talks that you could share?
I'm very excited for dynamic, succinct templating.
Generally speaking, the audiophile world falls into two camps. Those that think particular makes and models of audio electronics and speakers are somehow "magic" and those that simply want their systems to measure "flat". The first camp are the ones that used to put weights on their speakers, used "magic" green markers to color the vertical edge around the outside of a compact disc, and would spend tens of thousands of dollars on a plinth for their turntable or a magic tube driven preamp.

The rest are simply concerned with scientific measurement of the system. Does it produce a reasonably flat sound in frequency and phase that remains undistorted at volumes at which they listen to music.

The latter camp will highly rate headphones (or any other piece of audio equipment) that can produce a the full bandwidth of human hearing while keeping distortion low over a useful range of amplitude.

Comfort, cost, and construction quality would also be considered in the ranking.
How to tell if a FLOSS project is doomed to Fail (2009)
First, that statement was not present in grandparent's post when the parent posted his message.

Second, that premise is completely untrue. Go, and most other languages give you more-or-less orthogonal primitives and let you combine them. It's okay for your types not to be thread safe, if by combining them with some other primitive you can make them thread safe.

Every other language does this. Some offer you a concurrent map along with a non-concurrent map. For many reasons I won't get into, Go only has one kind of map and lets the user do the rest (which is an extremely easy idiom in Go). Note that even though many languages conveniently offer concurrent maps, no languages with mutable state that I know of offer concurrent integer and concurrent structs. The user is still responsible for ensuring the safety of those.

This is perfectly fine because the grandparent's premise is wrong. In concurrent language, by far the most common case is by data to be owned by a goroutine/thread/whatever. It's very easy to reason about code this way, and it's the way you are encouraged to write code.

Only when you need to share data you need to worry about concurrency-safety, and in that scenario you have available all the tools to ensure it.
Thanks. This is much more interesting :)
Most of the grunt work of coding will be a matter writing a set of Cucumber tests (or whatever language you prefer, but it'll something close to formal English) and having a solver/fuzzer do the actual coding for you. There'll be some things that a solver can't do, but for the majority of simple things (generating models, CRUD operations, database interaction, networking, testing, maybe some aspects of the UI) I don't imagine we'll need to write any actual code ourselves. A lot of this stuff already exists; we just don't use it because it's unreliable. That will change.
A lot of comments that just seem to ignore the fact that noone would actually want standard collections to be thread safe! Concurrent collections are slow. That's why class libraries use different types for a therad safe collection and a regular non-thread safe collection. If you are using concurrency you have to use concurrent collections.

You could argue that if most Go code is concurrent then the regular collections should be the thread safe ones, and for code that is known to be single threaded there would be simpler/faster non-concurrent collections. That is a completely valid argument to make, but I think that design would be too confusing for new Go developers, since in most other languages the standard collections are the non-concurrent ones, and the concurrent ones are special, and it's an explicit design goal of Go to be easy to adopt coming from another language.
I guess the link no longer works, the correct seems to be:
http://sockpuppet.org/blog/2015/07/13/starfighter/
I have spent an entire week writing everything in E-prime. All texts, all IRC chats, all postings, every email.

I also spent the following week trying to speak in E-Prime. This proved very difficult but worth it. I had a notepad with me with several useful phrases in it. Even simple things like ordering from a coffee shop made me stumble. But I would try my best to speak in E-prime. I failed several times!

Writing appeared much much easier. It made emails and other postings less personal, less objective and more subjective and relative. I believe "Non Violent Communication" has many similarities to E-Prime.

Robert Anton Wilson wrote a very good introductory text explaining E-Prime. http://www.nobeliefs.com/eprime.htm I suggest you all check it out!
Best Practices for Open Source Software
I'm increasingly convinced that Go is the new PHP, designed and used by the kind of people who know just enough to be incredibly dangerous to themselves and everyone else they touch.
You are not expecting better. You are expecting worse. Plenty of use cases involve maps without concurrent modification, e.g., when used as a local variable. Your "better" version of maps will slow down all of them.
If I didn't embed C, many of the terms (eg. File, BlockDevice) would have to be "magical".
There are also two sorts of hacker news commenters, those who divide people into two camps and those who don't. :-)
You mean like every package manager of every programming language ?
Earlier this year I was looking for the flattest (least "colored") pair of headphones I could get for under $100 and after lots of reading finally went with the ATH-M40x. You all might have seen this model headphone go on sale now and again with mic bundles on Amazon/B&H, and wondered if these headphones are any good. This video (https://www.youtube.com/watch?v=udLoAV7YmjA&feature=youtu.be...] (linked to 83s) really puts into perspective how muddled - aka "colored" - the popular pairs of headphones can sound.

I was skeptical of how this works - how do you record what the headphones sound like? This must surely be fake. However here is the making-of video and it really put into perspective for me how detailed sound engineering can get: https://www.youtube.com/watch?v=jnK1Gq7txYA
How We Skyrocketed Our Blog Traffic Conversion in 7 Steps
A Renaissance alchemist pioneered feedback control
Ask HN: Are services like chargify/recurly worth it?
Are services like chargify/recurly worth it for SaaS businesses? or should we just go with Stripe/Braintree since both of them provide basic subscription management tools( upgrade/downgrate , plan creation , etc)?
We appreciated your answer.