skysight-inc/HackerNews huggingface dataset:
I can give you a simple example.

I met a Trump voter from India who had spent more than 10 years and a lot of money to get his green card.

He complained about the Dreamers and how that basically was cheating what he had to do the official way.

These are the kind of subjects people care about when voting for someone like Trump.

With regards to Trump and why I am not as negative towards him. Because I don't know (besides his toe-cringing communication style) what it is I should be negative about that isn't mostly republican politics.

By and large, his politics haven't really done much in any fundamental way. I am aware that there are specifics that can be put forward as "bad" but to me politics is a much larger game than just isolated events.

Fact is that we don't know what the consequence will be. The results of any presidents politics are often seen long after they left office.

So I am basically unsentimental with regards to Trump. Personally, I am what you would call a fiscally conservative but value based liberal.

I benefit from globalization because of what I do, but I am aware of the problems it creates for many in the working class (which I grew up in too) and I think Trump's appeal to them was at least an attempt at changing things in some fundamental ways.

What I hold even higher though is the US democratic process which I consider extremely impressive in it's ability to contain someone like Trump.

In other words like most other presidents before him, Trump is being guided by the checks and balances of the US democratic system.

I don't see any cause for real concern so far.
Feedbro RSS Feed reader has built-in Rule engine that lets you define rules for filtering/highlighting/autotagging articles.

https://nodetics.com/feedbro/
> Unless the new version is API compatible with the old one, you're likely going to have to do some major work in incorporating the new version.

A new major revision of a library means that there are some non-backward compatible changes, and in many cases this means a limited number of fixes have to be done. Also in general it is expected that one will want to upgrade, so probably those changes are documented. Also hopefully the two libraries will share the same main concepts so using the new version will not be terribly different from the old.

Of course it is not always the case, see Angular, were two unrelated frameworks share the same name (I really think they should have changed the name).
No, I'm talking about the sticky bit for directories: see

https://en.wikipedia.org/wiki/Sticky_bit#Usage

and

https://en.wikipedia.org/wiki/Setuid#sticky_bit
I dunno, dude, most of the "masters" I know would come down off that hill and go "yeah, this is pretty obvious stuff he's saying." There are things in there I'd quibble with, but overall? Yeah, he's not wrong.

The way you're gunning for somebody who's trying to make things better, who's trying to improve the craft, is strange in its own right.
It’s relatively actionable as well. When someone says they want to migrate from Rails 4 to 5, the default response is “we should really consider doing that at some point and evaluate how much work it will take.” When they say we want to migrate from Rails 4 to Django X, the default response is “you’re going to have to justify a total rewrite”. That’s even true for some brutal version changes: going from Python 2 to Python 3 is still typically less work than going to Go or Java or some other language.

Angular might be the one exception I know of to this pattern.
We should give up on reproducible builds because version numbers do not give enough information? What?

Version numbers are what you expose to the real world, something which semantic versioning tries to standardize. I shouldn't have to care if you use git, hg or copy-paste-versioning internally.
Ford Assembly Line Workers Try Out Exoskeleton Tech to Boost Performance
That's pretty good! Get between 11-29 fps at 753620 particles on Galaxy s7, mostly sits at 16 or 17fps though.

I wonder what an iPhone would get, I'm led to believe their GPUs are pretty strong (to say the least).
In type-checked languages, object literals are fairly obtuse because an object literal is an anonymous class with only one instantiation point. For example, suppose you have syntax to create an anonymous class like this:

{ x: 123, y: 456, z: 789 }

What type would it have and what would you do with it? The only use for it would be to upcast it to Object. You're better of using Map classes instead. One can then wonder why Java doesn't have Map literals. The reason for that is inertia. When Java was designed in the early 90's maps and sets weren't thought of to be as useful as arrays in everyday programming.
Your employer may share your salary, and Equifax might sell that data
Yes I'm starting to think that good ideas can grow out of anything and can be facilitated by any technology. Blanket statements which warn against specific approaches or technologies are often incorrect.
>So while you're right that we used to rely on gossip and hearsay, simply amplifying the number of sources in no way implies that we're getting a less biased message.

That's sort of what I was getting at. At heart, these new technologies aren't necessarily more reliable than what we had before. But on the other hand, I think that at the very least they're not any less reliable either. Simply by having more people reaching a consensus on something, you're probably going to have some great diversity of opinion.

In his book The Wisdom of Crowds, James Surowiecki posits that there are four factors that determine whether or not a crowd will be able to make intelligent decisions: diversity of opinion, independence, decentralization, and mechanisms for aggregation of collective judgement. Not to be self-congratulatory, but I think that's part of the reason communities like HN produce more intelligent and well-reasoned content than, say, an NRA fan club on Facebook.
Also, if you have one power outage, it's more likely you'll have another soon, so you don't want to burn up your generator (likely a long lead time to replace) during the first outage, just to have nothing during the next outage.
What is the value you expect to get from hotdesking?
only 56fps for 900k particles, expected steady 60fps
Assuming you have documentation, then any deviation in actual behaviour from what your documentation says is a bug.

If you're relying on undocumented behaviour in your programs, then you inevitably will find no/less value in semver.

And if your program isn't documented, then your code implicitly fills the role of documentation, which does mean that fixing any bugs can maybe be considered a breaking change. Or something like that.
are you sure that little popup is not implemented in some emacs package? i get those little popups when working in edts-mode with erlang..
Feedbro has built-in Readability style engine that can transform partial feeds to full feeds (you have to set it in Properties for each feed): https://nodetics.com/feedbro/
Thanks for the link. The C201 is listed as work-in-progress.
I don't think you have any idea what you're talking about.

An estimated 700 million people watched the 2006 finals of the FIFA World Cup. In 2014 the entire tournament was watched by an estimated four billion people and that's just one event.

Unless the Chinese population explodes to 5 billion people overnight and they ALL start watching basketball, the two sports aren't even in the same league.
New network of EV charging stations to reach from Norway to Italy
Groq promises 400 TOP deep learning chip at 8 TOPS/W in 2018
You could also just use one of those cheap USB power/voltage monitors as the author does. Obviously a cable alone should not be drawing power.

Maybe an innovative company could add warnings for USB ports that draw power but have no recognized device. For the advanced ports with charging support and so on they should have power monitoring already.
Looks like the site got killed.
I once had a Java job which required me to use an IDE. What I noticed is that I became dependent on the auto-lookup features and didn't really learn the codebase until at least a year in.

I use vim, and whenever I need definitions from other parts of the code base I put them all up in multiple panes or tabs. Its not as immediate as the pop ups, but it forces me to go look at that part of the code base. I find I learn the relevant parts of the code very quickly and even remember the most common definitions.
Or even better, take out the SIM and find to whom the number is registered to. In many countries numbers require registration, ie. you can't get one without showing personal papers. Of course intel agencies aren't required to do that, so that if you can't get a real name for that SIM then you're 100% sure you're being watched by people a bit more powerful and dangerous than your suspicious wife (unless your wife works for them :^).
Using cellphones or anything related to them, especially if you don't plan to recover the device, is not good for spying because you're leaving behind tracks almost as important as DNA.
Nice article though. If some of you want to experiment with these devices, you can get a SIM800 or A6 GSM modules then pair it with a small uC for a lot less than €10.

https://github.com/carrascoacd/ArduinoSIM800L

http://simcom.ee/documents/SIM800/SIM800_Hardware%20Design_V...

http://www.electrodragon.com/w/GSM_GPRS_A6_Module

https://www.makerfabs.com/desfile/files/A6_A7_A6C_datasheet-...
The first point could be likened to the Apple vs. Google design model.

Google: "Test 36 shades of blue and choose the one that performs best"

Apple: "Create beautiful product based on user experience and then convince you that you like it."

I don't think making all product decisions based on data is necessarily good, nor is designing in a vacuum.
The article does describe more than just the calligraphy, although that certainly is the main focus. Example of preparation unrelated to calligraphy:

> Mortimer Adler suggests making a detailed outline of the speech and then using those as notes. I wasn’t familiar with how to do this so I gave the speech like I would usually do and recorded it on my phone. It was excruciating to listen to myself but I did it. Took around 45 minutes. I transcribed everything I said onto paper and that gave me my first draft.
There are two solutions to this:

1. Take the type definition from the point of use, not the declaration. For example, if the object literal is being assigned to a variable, its type is the type of the variable. If it's being passed to a function, its type is (a subtype of) the type of the function parameter. If it's being returned, it's the return type of the current function. C/C++ and Kotlin do this, as does Scala (I think; I don't know the language well).

2. Use structural subtyping. In the type system, allow the possibility of expressing "HasField x && HasField y && HasField z". Then the type of the object literal is simply an anonymous type that includes those predicates. Ocaml and (I think) Go do this.
Thanks for your comment. I have been using opendns family filter,but I didn't know about clean browsing.org. The safe search enforcement via DNS looks handy. I will consider switching. Looks like they block Reddit too.
FCC Cyber Security Planning Guide [pdf]
With the HN feed I get this error:

Unable to load feed https://news.ycombinator.com/rss:
503: Unable to read feed: https://news.ycombinator.com/rss

That is a pitty, looks like an interesting project?
Does it have an open issue tracker?
Great question. I, (and other people from the Clojure community) think that the Clojure language has a lot to offer to the Deep Learning/ Machine Learning space.

Step 1 - Build bridges to other Deep Learning communities using Jupyter notebooks, etc.

Step 2 - Bring innovation. In this area I see Clojure particularly useful in joining the symbolic logic and the deep learning model realms.

Step 3 - TBD (Depending on how the various time lines shake out to the singularity ;) )
except snapchat has been effectively locking out and leading on android users. they're making a whole new app just to get some android users back because instagram is absolutely murdering them
Would the downvoter care to state any reasons for disagreeing? The IME only has drivers for a specific ethernet port. They also don't use the secondary ports if equipped, though I imagine that's just a configuration setting.
> there are plenty of brands that are almost as cheap as Lepin and produce original (non-stolen) designs

Lepin does as well, just under the XingBao name.

But the joke's on the both of them—I just buy them for the pieces, not for the set designs.

Honestly if Lego just sold big boxes of bulk technic pieces (like they do for their normal blocks), I'd probably just buy those instead.
Agreed, but we've noticed some weird issues at work lately.

When someone is on an older version of npm or on a different system, (linux / mac os) things get fucky with the lock file. The lock file is changed and they just blindly commit it. So kinks still need to be ironed out with npm, IMO.
The article does a good job of highlighting some problems of versioning but I don't think the solution it proposes is any better.

The format of Product A Version B.c seems to be most actionable as long as it's consistent.

A could be a major shift in the product. So something like Windows 98, Windows 2000, iPhone 3 and 4, Android Gingerbread and ICS.

Version B would update whenever it's unstable and possibly breaking. So a version 2.0 or 3.0 would introduce lots of new things, but new things tend to be unstable, even after extensive testing.

Version .c is more stable as the number increases. So a version 4.88 is more stable than version 4.81

I don't see how more dots (e.g. version 4.81.2 of 4.81c) are actionable.

As the article brings up, the problem is when the defaults highlight to a new shiny unstable version instead of a stable older one. So the defaults should point to the highest c number, just a version below B. If the latest build is Version 7.2, the stable build might be 6.214.
If you sample from a 1000D Gaussian, most of the points will be "close" to the hypersphere of radius sqrt(1000). The distance to the center for 99.5% of the points is between 31.6-2 and 31.6+2. 99.997% will be between 31.6-3 and 31.6+3, 99.999997% will be between 31.6-4 and 31.6+4, etc.

This is what he means when he says "practically indistinguishable from uniform distributions on the [unit] sphere." As tgb remarked in another comment, the "unit" bit is incorrect.
One, I think the article doesn't underline why a paper based system would be better than a paperless method other than giving examples of hacked paperless system and weird claims like paper methods are bullet proof provided they are marked clearly and properly(what? That is one of the reasons for starting off paperless methods in the first place) A method that relies a lot on human based management and logistics is bound to fail in more ways than methods that use less of the same. Paper based methods involves a lot of human pieces than a paperless method (electronic methods and the likes). I may be wrong, but our shift towards automation clearly highlights the former. Any thoughts anybody?
You mean the Chinese government will stop protecting their currency and hurt their export?

That isn't likely to happen soon even though other governments want them to float freely rather than in a price band.

China doesn't hold enough USD to hurt the US economy without hurting themselves even more seeing as the bonds are non-callable by the buyer.
Absolutely, this new generation of kids don't want to pay for anything on the App Store. Maybe the generation of ~5 or so years ago that had a stockpile of iTunes Gift Cards from Christmas did so, but the attitude towards paid applications seems very different now, at least from what I've seen with my younger cousins.
Versioning is a mess of a problem area where the majority of the difficult problems that exist today are dealing with previous solutions.

This is not to say there have been bad ideas. Nor that there have been nothing but bad solutions. Indeed, I'd wager most solutions were perfectly fine, in isolation. They typically don't play well with other solutions, though. :(
> what with the higher voltage and all

I'd think the higher voltage would have fewer problems since there's less current and voltage drop... covering up for less-than-spec wire gauges.
I first heard about this over a year ago from the YouTuber Cr1TiKaL. This has been going on for a while now. I'm amazed that YouTube didn't address this sooner.

https://youtu.be/3iq1TK3I2vc (explicit language)
Hacker News Hiring Trends
I think we see surprisingly little of anything search related. In terms of full-scale solutions, there is basically just Elasticsearch and solr. When you look at lower level libraries available, there is very little outside the Lucene world.
I'm getting a steady 40 FPS on Firefox 56 and 58 on Windows 10. About 5 FPS slower on Chrome 62 on the same machine. And Vivaldi is almost identical to Chrome, which is expected considering they share the same internals. Impressive.
EDIT: ~640,000 particles on all browsers.
As someone who was involved with redteaming: ~nobody does. It's very rare to get caught after bugging someone's equipment. Bugs like these blend in seamlessly with the massive amounts of cables behind most desks.
I wish I could find the link now, but there was a very interesting (and, based on my admittedly rudimentary knowledge of history, high quality) thread on reddit's /r/askHistorians that dispelled this 'myth'.
E-bikes and other kinds of electrified vehicles. They have reached a "tipping point" because batteries and engines are so good that even out of shape people can use them to commute to work. What is left is regulation. When the EU and the US makes 1000 W engines and speeds >25 km/h street legal, then there will be few reasons to drive cars left.
There's basically another part of the version-tuple that we compress into the same position as the "major" version: the number of complete codebase rewrites that the code has experienced. Often V1 and V2 of an application, especially, will have effectively nothing in common.

Often they'll be developed by separate people who happened to inherit the name of the original, or "take up the reins" after the original became abandonware—but, either way, decided to just write a new one themselves rather than continuing on with the old. At that point, there is really no difference between calling it "libfoo (n + 1).0" and calling it "libbaz 1.0".

If you want to convey ancestry, you could add another preceding number, and that's often what people do—in the package name. For example, sqlite3 vs. sqlite4. If you wanted to make this "part of" the version tuple, you could: just have a super-major number before the major number.
Yes, clothing is problematic. Quality isn't great, and you need to order at least 2-3 sizes up. Even then, the sleeves might still be short: XXXL just means you're getting the overweight size, not the long-limbed size.
Julia is growing a really good GPU support ecosystem.

Thus, the advantage is to have all your codebase in a single language vs a 2-language solution (e.g. Python && C++).
The kinds of things I look for in evaluating senior candidates are things like:

- Payments flow kept going down because of lack of reliability in our CI, so I rebuilt the job queueing system to get to 99% reliability

- Most of our business is outside of the US, so we invested in better CDN routing, got a 50% improvement in our web TTIs

- We weren’t able to deploy code often because of our monolith, so we moved to a service-oriented architecture in order to speed up development

If candidates can’t justify why a project happened and why it helped either the company or their team, then that candidate isn’t a senior engineer, they’re just someone taking marching orders.
AliExpress is huge in Russia and CIS countries and that contributes a lot to the sales volume.
Bugs exist. That isn’t a design problem. Neither is carelessness. I don’t think either are the thrust of the article.
> AWS really likes to own the entire stack.

I wish you and I could own the full stack on our hardware, too. Imagine free drivers, firmware and microcode, full schematics and specification of all the parts. That would approach my atheist's heaven.
You used emacs for 10 years and never used cscope?
Well look at it this way: If we all switched to speaking German, would that rid the world of bad ideas?

[Granted there's some evidence that language does affect thought patterns both for good and for ill, but overall I'm going to say my answer is...] No. Someone expressing a bad idea in German is still an idiot, except he's more of a Dummkopf.

So I think the problem with this piece is that the title and part of the argument seem to assert that versioning doesn't guarantee anything about package quality or "breaking-ness" (which is true). But then it goes on to assert that this other versioning system would help change that. I doubt it. Naming and versioning are just descriptors of a thing, and may not accurately describe the thing. In other words, a turd by any other name still smells like a turd.

The package itself is the thing. The only way to know anything about it is to test it with your own stuff before you migrate to it. Therefore always pin the last version that works, and when you become aware of a newer version, test with it, read the changelog, make a decision. Treat it like your own software, in other words. Because you're making it part of your own software - the software you'll be held responsible for.
Lemnul dulce PLANTA MEDICINALA
That little popup is basically just cscope. It isn't unique to VS/VSCode or even any specific IDE/editor.
I wasn't aware of greenkeeper, thanks. Can you give some examples of "Semver-based package managers"?

I'm curious what you think of the two posts I was basing mine on:

"Spec-ulation" by Rich Hickey: https://www.youtube.com/watch?v=oyLBGkS5ICk

"Volatile Software" by Steve Losh: http://stevelosh.com/blog/2012/04/volatile-software

I think there may partly be a "universes colliding" effect here, and partly just the future being non-uniformly distributed.
i understand the patterns and design intentions of the language, despite not having written very much of it. (i just checked my work stats and i'm surprised to find that i've written/changed nearly 40k lines of go - of course that counts for less given how verbose the language is). one of my complaints is that a language designed to be simple has made (to me) incomprehensible design choices in the name of efficiency.

for instance, in a for loop ranging over a slice:

for _, i := range some_slice {
go func() {
something(i)
}()
}

i is re-used for every iteration of the loop, so the asynchronous function does not close over i as a particular value, but rather i as whatever value the loop has iterated to by the time it is referenced. i see experienced go programmers make this mistake sometimes, even when they've run into it before. my take is that the golang designers chose to implement this behaviour to either simplify their work or in the name of efficiency. if it's the former, it's indefensible. if it's the latter, why not offer user-friendly semantics (let closing over i as in the example capture the iterated value) and simplify the generated code at compile time when possible?

for your example, you can look to the newly added sync/map which uses interface{} everywhere as an example of how the lack of generics have left users with no _sensible_ tools to remedy these kinds of language problems. how wonderful would an efficient thread-safe and type-safe concurrent map be? it's possible in many other modern and not so modern programming languages, but it is intentionally not possible in go.
But how do you discern ahead of time which is quality and which is crap?