skysight-inc/HackerNews huggingface dataset:
Everything was handed to me in life. Not much but enough to get to middle class if I had just followed the rules and stuck with it. But I didn't. I failed out my physics/engineering program. I now work in a factory, and owe around 50K which I barely make 19K a year.

My life sucks. But I'm also young. I watch movies, sci Fi movies/shows which motivates me. I want that life. But then I try to program and I'm like "Holy crap. I'm so far away..."

I hate going to work I perform the same tasks over 6,000 in a day. Everyday is the same. I am wasting my life.

Motivation by fear isn't a good thing. Like the cliche, follow what you love.

Me I'm about trying to get out of my situation. Make money. I HAVE AN IDEA!!!

The problem is discipline. Sleep is a basic thing. Screw up your sleep pattern. You end up wasting time being awake and trying to fall asleep/not able to work.

Yeah discipline is the big thing. And true motivation from a desire/longing to do whatever it is with an internal driving force.
Does anyone work in a remote team with an always-on video conference?

I really, really prefer being able to shout out a quick question but the friction costs (and fear of interrupting deep thought) about calling someone, sometimes even a Slack message, prevents communication at times.

The times where I've been pairing or on a long call "in the background" have been great I thought. Any downsides for those who do this regularly?
Does denouncing someone as a bigot make you yourself a bigot or is it okay because _obviously_ their views are bad and it's okay to take a moral high ground?
Why your tests are broken and how to fix them
Why do all sorts of blogs have "Click to Read More" buttons these days? Seems totally unnecessary.
A road surface would be useful.
Why put in your notice? Why not just cut back your hours? Especially if everybody else is - walking out seems a little drastic in this case.
I am trying to quit watching shows/browsing websites. As soon as I start. My productivity is just sucked away. IQ points drop and I'm left as a drooling idiot.
Nailed it - I really do not understand what it is about the Javascript ecosystem (and particularly the React part IMO) but comparing it with the Elixir ecosystem where the underlying language is probably evolving faster even than JS is, Jose and Chris seem to make 90% the right decisions up front and not have to make massive fundamental rearchitectures every 10 minutes.
> Some tasks, especially around generic programming, can be very easily expressed in a dynamic language, but require more machinery in a static language.

I think this is not generally true and not a point against static typing, but rather against statically typed languages with poor support for generics. Java stands out as the poorest implementation of generics I have ever seen.

> For instance, a generic serialization library can be written in a dynamic language, without anything fancy, but providing the same thing in a static language requires more machinery, and is sometimes more complicated to use.

As a counterexample, have a look at NimYAML (my work):

http://flyx.github.io/NimYAML/

The examples there show how easy it is to provide the user with a generic interface for serialization in a statically typed language. The implementation does not differ much from what you'd do in a dynamic language: Provide a pair of serialization/deserialization handlers for each of [simple types (string, int, float, enums), array/sequence types, tuple/object/struct types, dict/map types, pointer/reference types].
Developers tinker with code, but most of the time you don't tinker with the output of that code, like hot patch your binaries or whatever. Same with systems, you build a container from a Dockerfile and maybe Makefile, you don't then go and change a few things you change the source code. We are just pushing the immutability boundaries further and getting more reproducible environments as we do it.
The Link Tax Is Officially on Its Way
Fewer media wide-releases sounds good to me. Perhaps we'll get better fare then. :P
Signal fixes bug that lets attackers corrupt encrypted attachments
> That's his point.

That's her point. :)
Isn't Love thought to be a suicide risk too? At least that's what they were arguing. Would the coalition have effected the McKinnon decision? It was May who stopped it after all and introduced the forum bar to make it easier to stop extradition in certain cases.
UNT Researchers Make Breast Cancer Breakthrough
I'm actually interested in this topic, and seeking other perspectives on how to look at this. I've been down voted here to the point that many people seem to think I'm adding nothing to the conversation, or trolling. I'm not. If you disagree with what I'm saying here or think I'm on the wrong track, I'd be interested in hearing where you think my comments went awry.
>Hollywood says we'll see a loss of culture

Seems like some scapegoating is going on here:
(2011)
http://www.slashfilm.com/infographic-hollywoods-waning-creat...
You are right - in a tautalogical way - that type systems only catch type errors. However, in modern languages (including Haskell, Scala, as well as newer, more experimental languages like Idris), those type errors can be extremely powerful.

Many people assume that 'types' are simply primitives like Int and String, and that a type checker just makes sure you don't pass an Int to a function expecting String. However, it is possible to express far more powerful statements about your data using a good type system.

For example, you can express the idea of non-emptiness of a container, as mentioned in the article. Then you know that, say, taking the max element of a non-empty container is guaranteed to give you an element, whereas with a possibly-empty container you might not have any element at all, causing a null, or exception, or at least requiring an Optional type.

You can express safety properties such as a sanitized string vs. unsanitized. You can have a Sanitized type that can only be created by calling a sanitize function - which carefully escapes/handles any invalid characters - and then functions that might, say, pass a value into an SQL instruction can be typed to only take Sanitized strings. Now the representation in memory of Strings and Sanitized strings is identical, but by using different types and a certain set of allowed functions on those types, you can encode the invariant that a string cannot be inserted into an SQL query until it has been sanitized. Now your type checker can catch SQL insertion vulnerabilities for you. How's that for a type error?
When card UI design doesn’t work
> It feels like a lot of overhead,

Right, because it IS a lot of overhead.
You did...

> For example, most of these advantages apply to Julia as well...

and then you listed it as an advantage.
One of the things I do not understand is, the explanation given is that Obamacare fixes the donut hole where people who are not enrolled in company sponsored/medicare could get insurance.

This has just let the drug companies to raise the price without any backslash because the end user is "not" paying the price. However, the rising premiums and plans with high deductibles meant that the drugs are still not affordable even if you are covered by some insurance.

What is the solution to this? Single-payer health care?
Same experience here. Usually a name brand is mentioned as well, which I always chuckle at.
I've dealt with dynamic typing vs static typing A LOT recently. In my experience static typing has a major complication that most programmers don't think about: datastructures. When you are dealing with a list in Python for example, you just throw whatever you are working with into that list. Whereas Java Generics and C++ Templates are very ugly because you can't just say "this is a list of stuff" you have to say "this is a list of a set of lists of ints". Not only is it ugly to write and read, it gets worse whenever you have any errors involving it. Ever seen a C++ compiler error message with templates involved? Other static languages like C don't even really try to deal with datastructures and just leave it up to the programmer to manually access the memory.
Yes, I could host the demo on my server and move the code to the root directory. However, I am not sure about the benefit.

In my understanding the main reason why people put code in the root is so that you can use "go get" to do a checkout. "Go get" then creates a src dir and puts the code there. This functionality is already covered by my server. Since my code path uses devt.de "go get" will always use my server and not github.

The only way someone could use the github code would be with "git clone" and here I think the src dir in the repo might be useful. Otherwise, you have to make sure to create this yourself.

Am I missing something?
> Personally, type errors haven't been the kind of errors that haunt my dreams.

The point of strongly-typed systems is that you can represent your constraints as types. This takes extra thinking and work, but gives you almost almost unlimited expressive power (ref: agda).

Simple example: meters and feet as different numerical types. When you multiply them, you get a silly unit (foot-meters) that doesn't fit with whatever you wanted (meters^2), and thusly fails compilation.
He probably has the legal recourse.
"But healthcare (including all the labor and money that goes into it) is my right!!1!"
It makes the adverts stand out more, and that pays the bills.

Edit: it seems the old location for adverts, the sidebar, is dead because people zoom in on mobile and many users are on mobile.

Pop-ups also are somewhat dead because people have learned to close the not-too obnoxious ones without paying attention.
If you're sick of the churn, I've been maintaining Andrey Popp's original React-Router-Component [1] for the last few years.

It's a simple router that hasn't changed much. I've tried to keep it extensible and simple.

1. https://github.com/STRML/react-router-component
WoSign Incidents Final Report [pdf]
> If all this makes you worried about China's long-term cosmic ambitions, then you are not the only one.

I too saw that as a weasel phrase. Propaganda isn't limited to countries we claim don't have free speech. Little things like this are probably not due to government's direct control over media, but they're a result of the natural fears people tend to have been given due to their government's political stance and foreign policy.

The western world depends on China to be their manufacturer. Many of our startups and industry that deal with durable goods are dependent on their vast manufacturing power. Yet we use their government as a means to also hold them at an arms length.

Why not let our space agencies work together?
In Haskell you can generate a parser to a typed structure using library combinators and code generation:

data DataMessage = DataMessage { company :: Text
}
deriving (Show)
$(deriveJSON defaultOptions ''DataMessage)

data DataList = DataList { _data :: [DataMessage]
}
deriving (Show)
$(deriveJSON defaultOptions { fieldLabelModifier = drop 1 } ''DataList)

Which will fail properly when the data is malformed and in the real-world is even shorter, because you can set your data-type to protocol naming conventions and share them throughout.

Then there isn't much bloat. You wrote your types and generated your way to parse them.

You could test with:

main = do
print (encode (DataMessage "some-company"))
print (decode "{\"company\":\"some-company\"}" :: Maybe DataMessage)

print (encode (DataList [DataMessage "c1", DataMessage "c2", DataMessage "c3"]))
print (decode "{\"data\":[{\"company\":\"c1\"},{\"company\":\"c2\"}]}" :: Maybe DataList)

https://gist.github.com/b30f6f09a737dcc980e052b0f3d2a39e
This is still pending appeal, no point in bringing in politics with a veto until (if) appeal fails?
Every technology is relatively wrong. Time points out where and we fix it (process is repeated again forever).
Yeah, my old doctor would always prescribe generics, and if he knew you were hard up and might not even be able to afford the generics he would try to get samples from the reps anytime he could and just give them to you.
"This is sort of a subtle point: when programming in a static language, you always have a choice about what information you encode in the types, and how you encode things. ... In a static language, you do always have the option of building a less typeful API, where less is enforced by the types, but it is often tempting to spend more time encoding things statically (and then proving things to the typechecker) than would be saved by avoidance of potential future bugs. With experience, you develop a good sense for what is worth tracking statically and what to keep dynamic, but newcomers to static languages can make bad tradeoffs here, which in turn contributes to needless complexity in the language’s library ecosystem. "

This is a very important point that I've rarely seen talked about explicitly though I think all programmers develop a tacit sense of it.
> A language created 33 years ago now with no intention of being used as it is today.

You know that they update the language regularly, and have a games sig? https://groups.google.com/a/isocpp.org/forum/#!forum/sg14
...but we also all know how untrue and unhealthy that attitude is. 'murica.
My guess would be he/she did not lock the versions in package.json, but used "wildcards" (I consider `1.x` a wildcard.) Happened to me once, took about a day to figure out. I really dig `Gemfile.lock` in Ruby land for this purpose.
> But you’re about to accuse Bill — Bill! — of writing spaghetti code. Bill, who started with your company when they had carrier pigeons instead of emails, and who singlehandedly built the original version of the software with nothing more than COBOL, baling wire and duct tape. Just who do you think you are, anyway?

Ugh, I had this problem once. The guy who wrote our company's web store did it in pure javascript (no libraries) and C (not even c++) on the back end purely for credit card processing. He didn't believe in googling something that he could figure out how to do himself, and consequently he never encountered a single best practice.

In the end, he was so resistant to change that our boss had to fire him. He went from being the alpha-dog with a decade of seniority who was treated with utmost respect, to fired, within about two weeks of me volunteering to rewrite the e-store and the CEO accepting my offer.

On the one hand, I wish I'd known how to handle that more diplomatically. On the other hand, thank god I don't have to work with such an irritable primadonna. He was the only employee allowed to work from home, because he was deathly allergic to computers (no joke), and had a special setup at his house where the computer was isolated in one room, monitor pressed up against a window, and only a keyboard and mouse in the room with him.
Just a reminder that the senator in this case is a Democrat.
And that's just one of the many problems with the SF startup scene.

Many other corps in many other parts of the US are perfectly compatible with what was described.
flow chart https://media.licdn.com/mpr/mpr/AAEAAQAAAAAAAAjDAAAAJDEyMDMy...
Every day I'm surprised there hasn't been some malware that strikes at the default Steam install locations. The malware would not need admin access, could easily just wipe out the whole directory and be a noxious pest. More concerning, with a bit more work malware could trojan every EXE and/or DLL in the directory and likely won't get caught [1]. Once trojaned, all that any of the EXEs need to do is pop up a decent mockup of Steam's "Installing VC Redistributable" dialog [2] and get an easy UAC prompt opportunity (that Steam has already taught most gamers to expect semi-regularly) and from there full admin rights...

Not that I want to give malware devs any ideas, but I would be surprised if the above never crosses their minds. I suspect the main reason that it hasn't happened to date is that most malware devs are likely gamers and don't want to defecate where they eat.

As for the "great benefits", as much as I like modding, I like my system security a little bit better. There are definitely ways to do modding both securely and easily (and reproducibly) using things kind of like Docker containers and patch overlays, and I'd love it if, say, Valve invested some time into that as a secure platform service. For some of the games it supports Steam Workshop gets sort of, partly there, some of the time...

(But ultimately, I think game developers mostly don't care about security and Steam especially isn't very well incentivized to move out of the dark ages anytime soon. Bringing things back around, I'm hopeful that with the UWP platform exploring things like modding as a service we'll at least see that sort of innovation from Microsoft and the UWP converge towards the best of all worlds, eventually, hopefully...)

[1] Steam has a baroque assortment of DRM and anti-cheat mechanisms, obviously, but only while it is running and even then most of them are passive when a game isn't running. Steam absolutely has no idea what would be legitimate modding to game EXEs (as many mods do that) and what would be trojan-ing. Most people leave Steam running just about all the time, which locks down some of Steam itself, but not everyone does and all it takes is finding one good crash vector for Steam...

[2] Steam also seems to be several anti-practices here because as far as I can tell Steam doesn't ever bother to check if VC Redistributables or DirectX are already up to date on the system, it just spams the installers regardless...
How to ask questions the smart way
NAT doesn't isolate your router, but it does isolate devices behind your router from unsolicited WAN-side connections (modulo hacking the router itself and hijacking sessions, of course). How is this not a security benefit?
OK, it really doesn't matter what tech you're using. You should be asking for affirmative consent if you're storing data that can affect privacy. Of course, _everything_ affects privacy these days, so even the exemptions for shopping cart data are kind of silly.

Cookies is a pretty household term - but distinct from local storage, so I wonder if sites are using that as a loophole.
I would say 'a statically typed language aided by a type inference engine'. My biggest bugbears with statically typed languages go away when decent type inference comes into play.
This is why we need alternatives. Vote with your money:

https://www.indiegogo.com/projects/allergystop-affordable-ep...
Why you feel busy all the time (when you’re actually not)
I think the concept of refactoring in dynamically typed vs statically typed languages is a double-edged sword comparison.

On one hand, refactoring code written in a statically typed languages is less error-prone - But on the other hand, such refactorings tend to affect more code than those of dynamically-typed code.

If your business requirements change often and refactorings are common, it can be a pain to keep having to rethink your code structure.

Dynamically-typed code is often easier to extend and modify. I find that with statically typed code, if you start messing with a small part of your code, sometimes you have to rethink your entire class hierarchy. With dynamic languages, your code can handle quite a few changes before it gets to a point were you need to rethink the overall structure.
I think the concept of refactoring in dynamically typed vs statically typed languages is a double-edged sword comparison.

On one hand, refactoring code written a statically typed languages is less error-prone - But on the other hand, such refactorings tend to affect more code than those of dynamically-typed code.

Dynamically-typed code is often easier to extend and modify. I find that with statically typed code, if you start messing with your code, sometimes you have to rethink your entire class hierarchy. With dynamic languages, your code can handle quite a few changes before it gets to a point were you need to rethink the overall structure.
> The purpose of a type system is to prove something about the code

The workaday purpose of these type systems is to write more of your intentions into the actual program code and get the compiler to enforce them on your behalf.

That may seem like a mere restatement, but the shift in viewpoint can give tangible benefits to someone who is new to ML-style languages and isn't convinced that making the compiler happy is doing them more good than the pain it's causing them.
My personal favorite blog post on this topic: http://blogs.perl.org/users/ovid/2010/08/what-to-know-before...
Exactly the answer I was hoping to hear. Thanks.
> The irony is that it was actually buying something online from Apple instead of pirating it that got him caught.

I dunno ... this gets repeated a lot because it is the official version of events but I am by default skeptical of such claims in operations like these as the authorities are fully incentivized to hide sources and methods.

Edit: I just read down a bit further in the discussion and nxzero holds a similar and well expressed view.
> some stuff

Cant't help thinking that that's probably something like 90% of code out there...
> I'd argue the modern equivalent is the overuse of design pattern abstraction where every function has one or two lines in it.

If you're writing functional code, very short functions are in fact considered best practice. This is because (obviously!) the basic unit of composition in functional languages is the function, and not the class. So you want to be able to compose those functions as much as possible.

In fact, I've also read and been told by old school programmers (I'm 40, so I'm talking 50-60 year-old C hackers) that even non-functional languages like C and Go should limit the length of functions as much as possible.

Experience backs this up, since some of the worst code I've ever worked had functions 2-3 screen lengths long, often with unrelated logic there within. Invariably, this was either C or VisualBasic. Say what you want about Java, and it is verbose, but at least it limits programmers to 1 public class per file, and Java programmers do tend to break their class logic into smaller methods.

So for imperative languages, the advice is frequently: don't limit functions to a line or two (although that's entirely appropriate and even recommended for Haskell and functional JavaScript), but preferably not more than a dozen or two lines.

And if you name your functions well, you usually shouldn't be needing to jump all over the screen to lookup a function. The name should tell you exactly what it does. If you're using statically typed languages with a decent IDE, the type signature should provide any additional needed info.

Google's C++ style guide: "Prefer small and focused functions."

Haskell.org's style guide: "Most haskell functions should be at most a few lines, only case expression over large data types (that should be avoided, too) may need corresponding space."

felixge's nodejs style guide (one of the more popular ones for NodeJS): "Keep your functions short. A good function fits on a slide that the people in the last row of a big room can comfortably read. So don't count on them having perfect vision and limit yourself to ~15 lines of code per function." (my experience with functional JS is that the best code bases strive to keep functions around 5-6 lines in most cases; check out React, which for any criticisms is very well-written).
GNU readline 7.0