skysight-inc/HackerNews huggingface dataset:
"Yes, how positively odd that after giving you lots of money, they want something specific in return."

Then they got on Patreon for the wrong reason. You're supposed to back someone because you like what they're creating, and want them to continue doing so, not because you want to tell them what to do. If you want that, then just commission them directly.

And Patreon backers as individuals don't give a lot of money. It's when they come together that the money gets to be significant.
Myth: you have any idea what the probabilities are of most outcomes in real life.

Reality: you make a wild-ass guess, try your best, and try not to die if shit doesn't go your way.

Read up on absorbing conditions per Nassim Taleb. People should be be aiming for anti-fragility, not maximizing impossible-to-calculate utility functions.
big difference between a fable and an anecdote
3. SHOULD This word, or the adjective "RECOMMENDED", mean that there
may exist valid reasons in particular circumstances to ignore a
particular item, but the full implications must be understood and
carefully weighed before choosing a different course.

They seem to have fully understood and carefully weighted the implications.
I find the obsession with "jobs" to be one of the most sour elements of the corportocratic dialogue of the political and economic systems.

Umm -- what these people are "obsessed" with is feeding their families, paying for their mortgages and their children's education, and perchance, scraping together some semblance of a soft landing for when they hit retirement age (approaching for many of them like an... oncoming truck).

If you have (realistic) proposals for how they're going to manage this (forced) transition, by all means please come forth with them. Portmanteau words aren't going to help.
When you serve out an entire system for a group of diverse users with lots of installable programs, it's important to ensure that parts will work together. Especially in Unix where namespace clashes in /bin, /lib and /etc may cause serious problem for system administrators and users. Thus, every stable release has to ensure that none of provided software shall do nothing nasty.

But with bleeding edge, you lose the control over this. It may be worth it for some users, and not for some others. That's a trade-off, and I myself am at the maintained-package-repo+use-only-stable-releases side; thus I use FreeBSD. Debian and Ubuntu mainly provide stable server OSs, so they're on my side too. If you want bleeding edge software, you should migrate to an OS that provides bleeding edge software, tho should know that it's called bleeding edge is called bleeding for a reason. An OS that has to release a version that'll be stable for the coming five years simply cannot provide bleeding edge packages.
Happy to see Python getting first party support for concurrency.
the thing about ZFS is that it was an actual selling/functioning product before btrfs was in development (links at end). There always were people using it - whether through the main Sun/Oracle Solaris product or via one of the OpenSolaris / illumos / Freebsd / Bsd continuations.

Btrfs was not an fs in wide production use the way xfs or ext3 / ext4 were, so it's understandable that btrfs progress is slow. The two pieces of software are just really far apart in timelines and maturity. People are paying attention to ZFS mainly because it's had a history of working and functioning in production environments and in heavy load, for a decade now.

In my opinion, in order to have parity with ZFS, some big distribution (bigger than Suse, maybe Debian or Ubuntu) needs to set btrfs as its default fs, and have banks, stock exchanges, dns providers, virtual hosting companies, etc hammer the hell out of it for another 6 or 7 years and get all the bugs that come out of those experiences fixed. Then people will start paying attention to it.

afaik btrfs development started 2007 (https://en.wikipedia.org/wiki/Btrfs)

ZFS was introduced as a part of Solaris in 2005, released as openZFS in 2006 (https://en.wikipedia.org/wiki/ZFS)
Of course consent is relevant. According to her narrative though, she said she didn't want to get into the bath, and then after talking more, started taking off her clothes and put her feet in the water. Then Jake "kind of pulls her into the tub halfway" and starts to "nonconsentually wash" her. It's not clear from the story whether her shirt is still on at this point.

Jacob is certainly guilty of ungentlemanly behavior, lack of smoothness, and pushiness, assuming that her story is accurate and complete, but to call this sexual assault is crazy.

All you nerdy guys out there, if you don't want something like this to happen to you, learn the dance -- there is a sequence and a pace to these things if you want a woman to feel good.
Would be nice, but I think we can do much better than what TS gives us right now, on the level of the type system. What's really missing are ADTs / sum types (and pattern matching, though that is more an implementation detail).
Alien Contact Unlikely for Another 1,500 Years: Study
> 50% of jobs are eliminated through automation.

Automation mostly doesn't "eliminate jobs" (numerically; it certainly might eliminate job categories), it reduces the market clearing price of labor by providing a competing alternative.

Among the features of a mature UBI is replacing the combination of minimum wage and means-tested benefit programs as a means of ensuring that the "fully employed" and the less-fully-employed, respectively, are adequately supported. By displacing minimum wage, it actually reduces the degree to which reducing the market value of labor results in lost jobs.

Now, it doesn't eliminate income or wealth inequality, which is essential to maintain some incentive to engage productively with the economy for those who can, but its not a matter of nobody working, its a matter of mitigating the cost of a narrower class of people having high-value labor while the labor of the masses is increasingly low-value given the alternatives available.
No-hair is about stable black holes in a steady state. When (e.g.) two black holes merge to form a third, its transient state may be more complicated; I guess the "hair" decays exponentially.

(Disclaimer: Not an actual physicist.)
As primarily a C# and JavaScript developer, I'd say TypeScript. Best of both worlds and I feel pretty productive in it (once past the pain of setup).
[Having "a mix of pod structs and function pointers" is analogous to having an interpreter for some scripting language.]

Yes, it might be similar at the core, but i would guess the usual audio pod-struct/function mix is many times less complex than a full jit language interpreter.

What does chasing pointer mean to slowness then? My understanding is that its similar to data pointers, that a certain region of memory needs to be looked up and be fed into the instruction cache. If the process is layed out so that instruction cache misses are minimised, whats so bad about it?
Linux has never had crap bundled? I guess the author forgot Canonical's "shopping lens" debacle, which was fully as sleazy as any ask toolbar bundling nonsense.
For starters, by spending trillions of dollars on wars in the Middle East to keep fuel prices low. We also set the gas tax far too low to account for all the negative externalities of driving.
Mossack Fonseca worker arrested in Switzerland
Something to keep in mind is that gravitational waves are linearized solutions to Einstein equations. That is, they can only be meaningfully defined far away from those sources. What happens close to the black holes cannot be described in terms of waves. You should not think of the gravitational waves as being emitted directly by the black holes. Instead what happens is that the black holes distort spacetime in complex non-linear ways, which turn into gravitational waves at large distances (hundreds of Schwarzschild radii). As such, the time dilation imprinted in the waves depends on the motion of the "center of mass of the binary" and the cosmological redshift.
Elixir makes me warm and fuzzy.
> IMO RNNs do need some kind of structured loss (more than per step likelihood) to be competitive with HMM approaches using Viterbi decoding

This is exactly what they do with the dependency parser I've cited, so your opinion is definitely valid. Although their approach is not general, given the fact that they approximate hamming loss with log-loss and again make it work only on sequences.

http://arxiv.org/abs/1502.02206

paper above also has a very good analysis on how to remove the search component of the inference and allow linear time complexity with competitive results.

consistent (as it is used in the machine learning theory of reductions) reduction from structured learning to multiclass classification seems to be possible. I just haven't seen anyone couple the learning procedure with neural networks. (Daume did mention they trained RNNs with the reductionist approach but seems that the code didn't make it to vowpal wabbit).

the approach above works with any loss you want (from F-score to any weird thing you might think of), the loss doesn't have to decompose over the structure (one can just announce the loss after the labelling is done and learn from that loss), it can work on any kind of structure, from images to sequences to documents for translation. it can also use a O(log n) consistent reduction of multiclass classification if speed is of the issue and if number of classes is large. It can easily work as an online method too, not requiring the full structured input.

for example, simple sequence tagging works (depending on the number of possible labels) around 500k tokens per second :D word count is only 2-4 times faster than that :D

there still aren't any papers using the above consistent reduction in the framework of NNs but I guess they'll soon be coming.
> An OS that has to release a version that'll be stable for the coming five years simply cannot provide bleeding edge packages.

Wanting software more than every five years is hardly "bleeding edge".
> there's http://dp2retina.rozsnyo.com/ which is more expensive but probably better

I am aware of this one as well, but what qualities make it "better" than the Abusemark model I linked to?

It's 3 times more expensive ($35 versus $99), uses 12V input (and thus cannot be USB powered), and has an 8-bit micro (ATxmega32A4U) instead of the 32-bit micro found on the Abusemark board (STM32F103CB). They both feature dual backlight drivers, although rozsnyo isn't listing what driver chips they're using, I suspect it's the same as Abusemark.

The Abusemark firmware even provides a USB serial device in addition to firmware updates, which the rozsnyo lacks.
SHOW HN: Your Tech Job Hunt Solution.
Man, is that annoying, or login forms that are in a dynamic dialog and/or ajax-login out of band instead of a post, so that it doesn't offer a save option... I mean, I tend to use LastPass over the built-in manager, just the same, it gets annoying when sites work extra hard to subvert those things that make actually using the web easier.

Along the same lines is one of the reasons I actually like OAuth/OpenID/OpenAuth logins, etc... simply that I can avoid yet another login that I only use on one site, with yet another password, that I generate and won't remember anyway.
> Visual Studio interprets the volatile keyword differently depending on the target architecture. ... For architectures other than ARM, if no /volatile compiler option is specified, the compiler performs as if /volatile:ms were specified; therefore, for architectures other than ARM we strongly recommend that you specify /volatile:iso, and use explicit synchronization primitives and compiler intrinsics when you are dealing with memory that is shared across threads.

> /volatile:ms

> Selects Microsoft extended volatile semantics, which add memory ordering guarantees beyond the ISO-standard C++ language. Acquire/release semantics are guaranteed on volatile accesses. However, this option also forces the compiler to generate hardware memory barriers, which might add significant overhead on ARM and other weak memory-ordering architectures. If the compiler targets any platform except ARM, this is default interpretation of volatile.

From https://msdn.microsoft.com/en-us/library/12a04hfd.aspx

Really, just don't use volatile.
I am curious how anyone thinks "stock market for small business" is a viable idea? Did anyone who approched you do even the most basic due diligence first?
JS ES2015. The syntax looks awful at first glance, but after heavily using it, there's much more power to this language now.
> What's needed is a CPU instruction to fence a critical section and lock up two cache lines while you manipulate them from one CPU, with other CPUs locked out. Transactions should have a hardware instruction cycle limit, so you can't lock up the other CPUs for very long. Then you could do swaps, sets, appends to lists, and such with straightforward code.

This is a perfect description... of non-atomic code. There's nothing atomic about mutual exclusion of cacheline access over multiple CPU instructions. As a bonus, we know how to lock a mutex without limits on instruction cycles etc. - this prevents any weird code geneneration limitations on JITs and compilers, meaning you can write normal straightforward code. You are, of course, recommended to lock for as short a time as possible where it makes sense as you say - so you don't lock up the other CPUs for very long.

With this in mind... what exactly is your requested change to the status quo? Is it for cheaper mutex (un)locking instructions in non-contested scenarios? Or is it for other cores hitting the same cacheline as your "atomic" operation to do something different than what they currently do? Currently, common approaches include:

- wait for the other operation to complete (aka spinlock)
- switch to another, more productive task (aka block / context switch)
- speculatively execute code and then throw away the result if there was a conflict (e.g. STM - you can do such things with existing atomic operations, although hardware support for conflict detection might be nice)

Or maybe it's to lock by cacheline instead of explicitly named mutexes? This is easy enough to do with current tech - have an array of, say, 256 mutexes - and then lock the mutex at index size_t(address)/64%256. Maybe choose a prime number of buckets to reduce collisions - not an option if such a mechanism was baked into the silicone.

EDIT: Or maybe you just want some instructions to discourage the OS from preempting your thread while holding inner locks?
From the link the parent commenter posted:

> The staging was an issue, critics argued, because it over-simplified the peppered moth story and made it seem that the camouflage of the moths was a self-evident advantage. However, it wasn't clear that moths rested on tree trunks during the day, as the pictures implied. Some evidence suggested they preferred to remain higher in the tree canopy and beneath branches where their coloration would have been less of an advantage. Also, it wasn't clear that birds were the main predator of moths. Bats also ate moths, and since bats use echolocation to navigate, the coloration of the moths would not have made a difference. Critics also questioned the methodology of Kettlewell's experiments.
Picat. A new language that blends different paradigms including logic programming, constraint solving, pattern matching into a cohesive whole. Allows for very compact, elegant solutions to many problems.
>he couldn't understand why anyone would want one, because technically a laptop can do basically anything an iPad can do, right? And it's more powerful to boot!

I've definitely been that guy at points.

>Both are communal/anti-profit movements, but on the surface that doesn't seem directly related to "not caring about UX".

I think in both cases the issue is about freedom. For instance, in IRC, if the server you are on sucks, you can move to a new one. You can even set up your own. In the same sense Myspace sucked. People could do absolutely hideous things to their profiles. It was a terrible platform, but you could change it to be your hideous platform.

UI/UX often takes the form of "This is the best way to do something." I think that is a fine strategy when it works (see:iPad), but when the person who created the UI can change it at any time to suit for their own ends it really rubs the wrong way. Facebook used their ability to change the user experience to manipulate emotions. That's not unique to Facebook of course, but it explains why people would rather use Myspace.

I'm not a Marxist, not by a long stretch, but I'm definitely becoming less accepting of non-free software as time goes on. I bought a Surface Pro when they first came out because I thought they were the coolest form factor I had ever seen. That Surface has been the source of about half of my computer related frustrations over the past 3.5 years. I still love the form factor, but my experience is often soured by Microsoft's horrible OS design. I wouldn't mind the horrible design if it stayed the same, but they often make changes to their design that make the user experience worse.

I understand that Microsoft has to design an operating system that works on hardware they do not control, unlike Apple. Before I had a surface I used this fact to excuse a lot of bugs and poor design. Unfortunately, Windows has more bugs on my Surface than it does on any other computer I use. My experience with the Surface, a computer I love, has eliminated the remaining shreds of respect I had for closed source software. The fact that Microsoft will not or cannot fix persistent and widespread bugs and errors affecting a computer they wholly designed is embarrassing. FOSS software has its bugs, but when it breaks I can (and have) fixed it myself. Even if the overall experience is worse, at least I own that experience, and can change it.

This is what it really boils to: I'd rather live in a hell of my own making, than in a heck created by someone else.

I think that argument probably rings true for staunch capitalists and Marxists alike. I've often heard variations of my sentiment above used to excuse the lack of social welfare in the US, and I think the Marxists probably feel that if they are going to be disenfranchised they'd rather have a more equal society than a less equal one.
I know, right? It's not like the maintainers can backport the bug fix in the first place, or upgrade 1 version forward.
> How does it prevent password reuse?

It does not prevent password reuse, it mitigates the risks of password reuse in that it adds the requirement of having physical access to a device, which is a show-stopper for most attackers.

If you're using a password manager with sufficiently complex passphrases, the biggest remaining risk factor are targeted malware attacks (something like a keylogger), which is something that typical SMS- or TOTP-App-based 2FA implementions won't help you with, fair enough. Implementations where certain security-sensitive activities require separate confirmation and where the details are transmitted through a separate channel would mitigate this attack to a certain degree as well. As an example, some banks in Europe provide their customers with card readers with a PIN pad that shows transaction details on a separate display. Banks routinely include transaction details in SMS-based TAN mechanisms, which works as well, but is obviously not quite as good.

> You could even argue it increases the attack surface.

How?
Haskell, seeing I still have so much to learn. Elm, because there seems to be a sane web frontend language. Swift, because I can do daily work in a modern language with so many parts done right.
There's a tradeoff of general human capital ("best athlete") versus specific human capital ("best specialist"). I used to be more in the latter camp. Over time I've moved to the former.

The system works because the severance is very generous, and it's not considered a career risk to leave Netflix.
The irony is when I have to hand-enter my email address, especially on my phone, I'm far more likely to mistype it and make a mistake... And on the receiving side, I'm sick of seeing emails for someone else.
Also like newLISP. Powerful, small, practical and thought provoking.
I know of one from a previous project. We had a prompt that said "enter your home address" with JavaScript autocomplete using google location APIs. Unfortunately chrome would try to auto fill this box with a city name (not even the full address) and this auto fill prompt sat on top of the JS drop down.
Rust: it provides extremely strong guarantees about your code at compile time so that usually it feels like a script language with C/C++-levels of performance. And the best part: no data races, and no runtime garbage collector overhead.
Wow, not even anybody asking you to explain your reasoning. So it's okay when Google ignores standards, but not Microsoft?
For clarity, can you give an example of how to `npm install` an old version of lodash such that we get the old version of the lodash.d.ts?
Firstly, the research is paid for and is public domain - that's the whole point - so that people can use it without paying.

Secondly, the author betrays himself by dismissing Apple's open source efforts. Their contribution to WebKit is the only reason there is competition in the browser space, and saying Swift and LLVM are 'proprietary' and dismissing their impact is either ignorant or dishonest. As far as I can see LLVM is the backbone of a huge amount of academic programming language research.

Thirdly, Apple's photos 'AI' seems like a pretty modest application. Hardly groundbreaking stuff that they are keeping 'secret'. If they owe taxes for this, then all corporations owe taxes for ideas they've incorporated.
Cmder looks nice, I'll have a look at it.
Ultrasound Opens the Brain to Promising Drugs
> But, a price factor of 2.25 over raw parts (COGS, cost of goods sold) is pretty reasonable overhead.

If this were a normal commercial product, I would agree with you.

But the fact is, when you buy this Adafruit kit, you're getting the raw parts which you have to assemble, the monitor has fewer features than a normal desktop LCD monitor (only one resolution supported, only DisplayPort input) and given that it's the bare LCD, is much more fragile than a commercial monitor.

So, yes, normally it is absolutely reasonable and expected for a manufacturer to charge 2-2.5x the price of raw goods. But in this case you're literally paying Adafruit 200% to do simple supply chain logistics for you, and you're getting a pile of parts which you can buy (with free shipping!) from FleaBay/AliExpress with a few clicks of your mouse.
The only problem that I could see there is that you actually kind of need weight on a tractor. You take a 500lb tractor and take out the 150lb engine you're getting a lot closer to the weight of the driver and you're upping the possibility of tipping over significantly.
There's no supporting details?

"C++ programmers find it difficult." Says who? I doubt someone who slogged through enough pain to learn C++ would be fazed by the weird parts of Rust.

The Rust language is not at all a significant barrier to its adoption. I think that the fact that Mozilla refuses to standardize its development and has a history of political-correctness inclusivity is a bigger barrier to its adoption. Especially given that C++ has been around for so long already, is always (very slowly) improving, and is already standardized. It's not a great language in the sense that it's FUN to program in, but neither is Rust, and even if it was, it's not a good enough reason to throw away c++.
The rule is pretty simple if you are bootstrapping. A cofounder makes your life easier now at the expense of making it harder in the future - the ultimate technical debt.
Apple brings HL7 CCD health records to HealthKit in iOS 10
thanks & thanks
Show HN: Pennyearned is pinboard for expense tracking