skysight-inc/HackerNews huggingface dataset:
Openhunt – forgotten already?
Not long time ago I was moved by the post revealing flaws in ProductHunt mechanisms. In a way, I felt cheated and really enjoyed the idea of a fair, truly open, upvoting-based service that would tell about the new and exciting products. Someone suggested that openhunt.co can become such platform. As an experiment, I stopped using PH and visited OpenHunt.co on a daily basis. I am sure I was not alone. At first, there were lots of posts with some really good products upvoted. However it quickly died out. Here is the full list of products posted a couple of days ago.

MONDAY January 18

▲ 4 - Webfolio - Showcase and share code snippets!

▲ 2 - Double air hockey table - Invention

▲ 2 - TwitSpot - Spam filter for Twitter direct messages

▲ 1 - Simple Image Optimizer - Compress and optimize your image files to speed up your website loading times.

▲ 1 - TODOED - Turn any text into a delegated todo.

The question is – where is everybody? Got back to ProductHunt I suppose? Shouldn't we regroup and try harder in supporting free and open, HN-like systems such as OpenHunt?

P.S.: I have no relations with OpenHunt.
معلومات عن صيد القاروص و افضل وقت للصيد – تراخيص
What you're saying is - don't exercise unless it seems quite likely that you'll make good money soon on those options. Or don't quit after 1 year + 1 day while exercising your year's worth of options "just in case".
Don't exercise until you can sell is great advice, but the giant wrinkle (particularly now that startups take far longer to go public) is if you don't wish to work for a company for 10+ years, you have a short exercise window after leaving a company. Some (very few) are converting ISOs to NSOs if you leave, allowing former employees to wait until the security is liquid before buying it.

My suggestion to all engineers is to use the leverage you have and insist that vested ISOs convert to NSOs if you leave a company. If they don't want to do this, well, there's a reason, and it's not good for you. At minimum, they intend to crank those golden handcuffs tight, and if you have life changing events in the 5-10 years it takes a company to go public (want a house, partner wants to live somewhere else, kids, etc)... tough luck. If you continue even without a conversion clause, apply a massive discount (on top of the massive discount you should already be applying) to the "value" of those options.

As for your anti-tax rant... if you want nice things (roads, schools, universities, clean air, judges, police, hospitals, child protective services, efficient postal mail, etc), someone has to pay for them. Charity is no substitute for our collective choice to pay for things.
So the old class of exploiters who depended on an agrarian economic structure got replaced by a new class of exploiters who depended on an industrial economic structure. I cry no tears for them. And now the industrialist overlords are getting creamed by the information overlords. Notice a common thread here?
Good point. From my perspective, the major problem with free trade is that it lets the billionaires move production offshore and avoid all taxes while hiding their obscene profits. (And they then import the products while laying-off US employees.)(And the guy who owned the factory, let's call him "Steve", made many billions offshore for which there is no US accounting at all.)

And it was a very cool factory - I had done automation projects, and some buddies of mine at the company were working on that project. As someone who had done robotic automation, it was truly amazing to watch and was probably the most state of the art at the time. We literally turned out the lights just to stand on the catwalk and watch the robots in the glow of the hundreds of LEDs on the electronics.
I meant the domain of the problem, so I was saying dynamic typing is advantageous for exploratory programming and modeling. Whereas static typing is easier to use if you have pre-planned all your programs.
I must admit, the idea of an un-specialised tuple with 15 elements is pretty damn scary. If I saw that in a codebase it'd be a real WTF moment. After three or four fields you should really be naming them, and if your language makes defining small classes painful, it's better to fix that with a Scala-type case class syntax (or data classes in Kotlin).
If speed of algorithm / function is a concern on particular functions, write a test that measures this. Refactor as much as you like until you hit the limit of readability vs adequate speed.
Are you kidding me? The article stopped making sense right at the beginning:

> But, perhaps surprisingly, electronic discovery software has not thrown paralegals and lawyers into unemployment lines. In fact, employment for paralegals and lawyers has grown robustly.

WHAT?! The statistics they chose from the US Department of Labor were cherry picked and out-of-context. Lawyers are seriously hurting right now:

> The national unemployment rate for law graduates has grown for the sixth year in a row to a whopping 15.5 percent, according to a report by the National Association for Law Placement. This unemployment exists despite soaring law school tuition.

Taken from:

http://www.huffingtonpost.com/natalie-gregg/mamas-dont-let-y...

More:

http://qz.com/206705/the-us-lawyer-bubble-has-conclusively-p...

Another good read (don't have to watch the video to get the gist):

http://abovethelaw.com/2013/10/this-pretty-much-sums-up-the-...
Datacenters are another example. Once they're built and turned on, my understanding is that they take maybe 35 permanent people to operate at the datacenter itself.
The file /proc/kallsyms contains the addresses of various kernel functions: it's useful when you've already exploited a vulnerability in the kernel, and you want to do something useful with it, e.g. escalate your userspace process to root. In theory, since you're running code in kernelspace, you can do whatever; in practice it's much easier to start with known functions that can manipulate the data structures for you.

Think of it like the manual of a nuclear missile launcher. Obviously they don't want to give that out to everyone. But if you can break into the room with the launcher's control panel, you've still caused a major security breach even if you have no idea what to do next. Having the manual just makes your job easier, but the attack was that you broke in in the first place; they can't count on you being unable to figure out how to work the panel.

Also, if you're running a binary kernel (for instance, a kernel built by your Linux distro), the addresses in kallsyms are going to be constant for everyone running that distro. Hiding kallsyms for non-root users is primarily useful for people who build custom kernels.

Production-level malware often also has code that doesn't depend on having access to kallsyms and is more advanced (e.g., starting from the system call interrupt vector and disassembling it and seeing what addresses are jumped to). Using kallsyms is good for keeping a simple proof-of-concept exploit readable.
It absolutely could. This past weekend I was really worried about getting broken up with. My gf had been withdrawn and was communicating less and acting awkward in various noticeable ways that I interpreted from experience as an impending breakup, especially since she was just about to leave for a week to go to Brazil for a week with 3 single girlfriends who want to party.

I was pretty sure that I was toast when she asked if I wanted to get dinner on Sunday and talk for a little while.

If you had looked at my readings that day, I would have looked like a breaker-upper, I'm sure.

Turns out that she was stressed about work and travel and after we talked about it a little, everything was fine. But damn. I really thought that was over for the better part of three days.
Indeed, and personally I find that having the types around also makes it much safer to do the inevitable rounds of refactoring once you figure out what you're really building. (Especially in a language like Haskell where most of the type information is actually inferred from context. It requires absolutely minimal type annotation.)

EDIT: Maybe it's just my bias, but it seems to me that most of the "dynamic" crowd just haven't tried a truly "agile"[1] statically typed language like Haskell or O'Caml.

[1] Hey, if they want to abuse the connotations of out-of-context words to describe the paradigm, so can I. :)
Doesn't every community need guidelines/rules on the internet? Without them you get wild-west-style communities. I think HN works BECAUSE it's heavily moderated. In the beginning we could rely on a small user-base to self-sustain discussions, but we've reached such a wide audience now I don't think that's possible without mod assistance.

Would be interesting to implement a veteran-only view to only show user's posts and comments that reach a certain karma or age threshold. Neither of which would correlate with conversation quality, however you'd likely see on-the-whole more 'classic HN'-style discussion as you've filtered out the vast majority of new/'casual' users.
Most people are grossly simplifying this discussion. The worst for me still is those who yell "Luddite Fallacy" whenever this discussion comes up.

What most people are missing is that it's not so much automation but rather digitalization which allows for a completely differen kind of automation thats not just mechanical but instead has some kind of intelligence embedded in.

The point is that technology is simulating higher and higher levels of abstraction and thus are replacing not just human physical abilities but also our intellectual ones.

And if you want to understand what that means. Then ask yourself what profession did the horses enter once cars made them obsolete in transportation.

It's also interesting to notice that the last 100 years only new kind of job have emerged and that's computer scientists. Most other jobs today are really just modernized versions of older ones.

The luddite fallacy is in itself a fallacy and everyone who subscribe to that view really should explain exactly what new kind of areas humans will be going into. Surely they should already exist today.

And if you want to claim that new jobs are being replaced when technology takes some away then you really need to explain this graph.

https://plot.ly/~BethS/8/job-growth-by-decade-in-the-united-...
Many stores have flat screens that show (only) the artist and album currently being played.
Additionally to this. In your refactoring process, stick a commit on each step of the refactoring. It will help you go back to a point where you were happy. Squash the commits when you're done if needs be for cleaner history, or leave them if there aren't a bunch of people on the project.
So, basically nothing in real world domain. The protections are basic at best. The most common errors are runtime exceptions, zero protection offered. YMMV.
It's hard to tell exactly what GP is referring to. It could be the parameterized Tuple type, which has built-in implementations for up to 8 fields. But those will all just be named Item1, Item2, etc.

https://msdn.microsoft.com/en-us/library/dd383325%28v=vs.110...

The conversation makes me lean more towards C# anonymous types, which are just syntactic sugar for creating classes with public, read-only properties. But they feel like creating named, statically-typed tuples.

https://msdn.microsoft.com/en-us/library/bb397696.aspx
“The EU Is on the Verge of Collapse:” an Interview by George Soros
U.S. lawsuit against founder of Facebook's Oculus can proceed
The /proc/kallsyms values are identical across identical kernel compilations.

Suppose you have a vulnerable CentOS 7 system that you want to exploit - you could get the proper addresses from your own CentOS 7 VM running the same kernel, apply those to a modified exploit compilation, and run that compilation on your target host.
NIS+ used "relative" timestamps, which were basically the delta between the server and the originator. So the originator would say "here is a packet and I think it is time 1415151515.5" and the server would get that packet and say Ok, since I think it is 1415151520 your delta is -5 and I'll subtract 5 from all of your times to put them into my time context. Then when you compared time stamps you did so in the servers frame of reference. But as the article points out it still suffered from jitter given the various subsystems between the packet and the service endpoint.

As for out of order and lost packets the TCP layer prevent out of order, but retransmissions on lost packets resulted in big jitter spikes. Those were rare enough to pull out as a special case. And there was layered on top an optimistic transaction protocol where you could ask for the current transaction id, increment it by one and send your transaction with the assumption that if someone landed before you it would fail and you would have to restart. That worked well for read mostly applications (like a name service).

The NoSQL database that Blekko designed uses a more complex promise system to preserve transaction ordering and it uses idempotent combinators which help manage time syncronization issues. But again, if we could wave a magic wand and get perfect synchronization it would be pretty interesting.
You could optimize the single bit away by assuming that there would be a bit.
Never expected to be trading Hindi aphorisms on Hacker News of all places. Here's one of my favorites from a book full of them I leafed through one time:

दो-एक गाँव में भोज हुआ और कुत्ते की जान हड़बड़ी में ही चली गई।

My attempt at a translation:

'There were feasts in two villages, and in their running back and forth, the dogs died.'

(A bird in hand is worth two in the bush.)
Depends on how hypothetical you consider the proposed hard fork is. On paper the majority of miners and most major bitcoin companies are ready to switch: https://forum.bitcoin.com/bitcoin-discussion/72-of-miners-ha...

And that 'one person' is arguably the most influential core developer, given that four other core developers work for his company.
Your irony meter is more sensitive than a large number of commenters who's responses are variants of "no, because... anecdote!"

I agree, it is interesting to see data, though I struggle to design a study in my head for how to really show this either way. But... anecdote... it does amuse me how various languages claim to improve development time/safety/bug rates/cost, (OOP, Types, Functional, etc). But these big claims are not quite born out by companies investing in those languages wiping the floor with their competitors. If there really was a significant difference, I'd expect evolution to take its course.
Middle-aged white death trends update: It’s all about women in the south
The USA for example?
Shame that you write off an entire language from this trivial experience.
If you look at it like that I'd say there was basically no way to complete the challenge. Even finding $50 walking down the street wouldn't count because of the time you took to walk.
Lattix Announces Lattix Architect 10
I enjoyed starting to learn about Nim, but the worst case of NIH is the forum.

There is good forum software out there. This thing that Araq wrote in his spare time is not good forum software. It is outright painful to participate in a discussion there.
Slight correction, `exit` in IRB is actually not the same as `Kernel.exit` (as IRB actually allow IRB sessions to be nested, using `Kernel.exit` would quit the whole program rather than just the current session). It is actually an alias of `IRB::ExtendCommandBundle#irb_exit` that throws `IRB_EXIT` to stop the eval loop of the current session and allow some pre-exit hooks to be assigned to it.
Building an Impossible Clock
While that's true about the usage I'm not sure it applies in that comparison. All primitive collections, string manipulation, simple ops, etc. are already written in non-interpreted language and compiled AOT in Python. I expect they're also native in V8 and Ruby, although I don't know that codebase.

I'm not sure about "core code". I mean, the context is "unit tests", not "functional tests". If you have hot core code in your unit tests, then something smells... Hot helpers, and cross-cutting utilities, sure, and I mentioned them.
As a long time JS developer I was blown away by the V8 performance, and it still amaze me. And it works very well on Windows.

What would be cool though, is if we could use vbScript in Node. Because vbScript is even easier to learn then JavaScript!
Putting the hyperbole in not only makes people click on it but it makes people be more swayed not only by reason but also by feeling . Sharing the article probably makes a significant people
Donate to the organization. Disclaimer : I am an EFF member.
Is this the first Instagram masterpiece?
(working full-time on JavaScript code for last 4 years)

TL;DR good dynamic codebase is possible, but not when you throw too many devs at it (particularly junior devs) and only when you set the very high quality bars. Otherwise, in finite time the codebase will converge to a big pile of mess.

IMO the big dynamic-language codebase with multiple people working on it can only survive with extensive test suite, lots of mock data available, automated quality tooling (jshint etc) and proper code review in place. All of those are well-known best practices, but they require good developers and certain discipline.

In particular, when the app retrieves lots of data from a server, it's easy to get lost when the frontend app doesn't even know what data it operates on, it just knows it gets "some JSON". In old-school java world you'd have this mapped into a bean and you'd at least know what you work on.

Previous project I worked on was an inherited poor JS codebase with lots of unrefactorable magic happening inside, multiple event buses and what not. Since JS is a very dynamic and very permissive language, someone can abuse some language constructs to make it very hard to reason about the code.

In a pathological extreme you may get "everything is an object" codebase but no idea what keys each object has.
Bonus points if the code is passing some JSON around and adding some keys to that object in an ad-hoc manner, scattered along many functions.
No tests and no mocks meant that to learn that, you'd have to run the app and put breakpoints. But, the same variable might have had totally different type of data inside depending on how some if-elses executed.
Most of our bugs were due to some objects not having some keys (sometimes) for some reason etc.
From a slightly different angle, Lior Pachter focuses on how science is often a pyramid scheme of sorts:

https://liorpachter.wordpress.com/2016/01/18/the-heroes-of-c...

>There is a more cynical view of the PI model, namely that by running large labs PIs are able to benefit from a scientific roulette of their own making. PIs can claim credit for successes while blaming underlings for failures. Even one success can fund numerous failures, and so the wheel spins faster and faster…the PI always wins.

>Lander concludes his perspective by writing that “the [CRISPR] narrative…is a wonderful lesson for a young person contemplating a life in science”. That may be true of the CRISPR narrative, but the lesson of his narrative is that young persons should not count on leaders in their field to recognize their work.
Patching Java at Runtime
3000 Swift URLs
What do you use for Python debugging? I'm working on a large Python project coming from rails work and my biggest frustration is no equivalent to pry. I find Python debugging incredibly painful by comparison.
There's an old probably apocryphal story about Henry Ford III taking the head of the UAW on a tour of his new automated factory and asking "Think you'll be able to get these robots to pay union dues?" to which the UAW head replied "Think you'll be able to get them to buy cars?"
I downloaded and checked the zip file. Last digit is a 6. Downloaded it multiple times to test. Can anyone else replicate this?
Thanks for adding support for GitLab!
Wise Care 365 Pro Crack Plus Serial Key Full Version Free Download
I think the point in the "variable"/"VARIABLE" difference is that, although they visually look very different, their meaning does not. In a more practical case, if I read some code which has two variables within the same score with names "last_value" and "LAST_VALUE", I would not be able to tell what should they contain: one has the last value in a sequence (which one?), and the other... what?
> People already know...

No, they don't.
That's not how it works :). If the productivity doubles, the product will still cost $10, but the company will happily pocket that $5 improvement - and no, they won't raise the salaries of their workers, because why would they? There's zero reason to. Also note that "efficiency improvement from the manufacturing plant" usually means a) automating a part of the production process, and b) firing the workers who are no longer needed.

So now you have a product that's still $10, but some of the people in the community don't have a job anymore, so they can't buy it.

Of course, then a competitor shows up, driving the product price down to $4.50. The original company has to adjust, so it fires some more people and cuts down the paychecks for the rest.

The end result is: the product is cheaper, but the community is poorer, and some of its members don't have a job anymore.

But hey, isn't this the whole point of optimizing business through competition? Isn't the goal to make more with less resources and less people?
The funny (or unfortunate, if you're FB) component is that if the FB form response in favor of Free Basics had been written more elegantly, TRAI might have considered it to be responsive. The TRAI invitation to comment was winsomely written. It included the following as the final question:

Are there alternative methods/technologies/business models, other than differentiated tariff plans, available to achieve the objective of providing free internet access to the consumers? If yes, please suggest/describe these methods/technologies/business models. Also, describe the potential benefits and disadvantages associated with such methods/technologies/business models?

A rather nice invitation for people who actually did want to write in in support of Free Basics.
Strongly typed languages beat dynamic languages hands down for refactoring. The ability to know immediately what broke without having to run all your code paths dominates any time savings gained by typing faster.

I'm a fan of strongly typed languages with good type inference (and therefore less typing), but even in verbose languages like Java this is true about refactoring.
He's probably got a short sell going on.
While I appreciate the sentiment of settling debates with data, you have to actually measure the right things. That statistic that says that only 2% of bugs would be prevented by static types? That's based on the assumption that everything that would be a type error in a statically typed language manifests as an exception in Python. But that's obviously not even close to being true. The really annoying bugs that type systems prevent are far more insidious than that. For example Python will happily let you use the greater-than operator on an int and a function. So if you accidentally write `f < 10` instead of `f() < 10`, you will not get a type error, but your program will have a bug that manifests in your program logic going wrong and leading to wrong results somewhere down the line.

I've analysed all bug tickets for a Python system at a previous job for several months, tracking how many of our bugs would have been prevented by a Haskell-style type system. This isn't very scientific either, but for my sample it was somewhere between 70%-90% depending on your interpretation. I'm not saying this generalises to all projects, but I can definitely say that the 2%-number is hilariously wrong.
Hang on, why would you drop your prices when your margin just increased? Why let "the community" keep their extra $5 and not pocket it yourself instead?

Financially speaking: what's the incentive?