skysight-inc/HackerNews huggingface dataset:
I don't write tests for all my code. But if I'm not writing an automated test (frequently when I'm writing a single-use script, which is something I do a lot, as I'm merely a hobbyist), I still "test" my code, function by function, at a REPL.

I've long since learned the hard way that if you don't test the functions as you write them, the bugs get buried in the system, and become very hard to find. When you test your code as you write it and modify it (formally on larger projects, informally on smaller ones) this doesn't happen.

That's the advantage of tests, so I can get Beck's point: If the function is so painfully simple that you already know if it's right, (say, an accessor) just by looking, then it's not worth writing a test for it.
Any yet it's extremely valuable when you want to test code that deals with externalities (aka, i don't need to actually insert a row into a db over the wire to make sure my biz logic works, and in some cases like error handling testing, it'd be way harder to actually code the situation rather than to simulate it), and tends to give you a baseline set of reassurance that can run very quickly. So IDK about just hauling off and labeling it as "moronic".
And we write tests to exercise our own assumptions about how the system will be used. It's way too often I write some tests for my code, I quickly arrive at use cases and failure cases that I hadn't anticipated while writing for the optimal use case.

Reality, on the other hand, is usually suboptimal.
Welp, I've temporarily reduced the duration to 1h, should free up some slots.

Here's a screenshot: http://i.imgur.com/UsRgXhD.png
Mormons consider baptism a gate - proxy baptism opens the gate, the post-mortal individual can choose to enter the path via the gate, or not.

This necessitates a lot of other background beliefs - immortal soul, individual will, and significant ordinances, to name a few.
over capacity and I get a captcha error when trying to select a different server. I have to reload the page -- never got to a terminal.
Don't blame the devs completely. Not many bosses give out raises or bonuses for good testing. Or even for not shipping bugs. Being a hero and fixing the bug you shipped gets much more visibility and accolades.
This is more of an Android permission management issue than a Signal app issue. If you use Android 6 (Marshmallow) or above, you should be able to grant only the permissions you're comfortable with granting to the app. For older versions of Android, there are apps that allow you to restrict the permissions granted to apps (I don't have first hand experience, but look for "app permission manager").
Seems to be no way to go back up the terminal, so if you run something like grep --help, you only get the bottom portion of the help section rather then the whole thing.
If you don't already know anyone who works in Dev/IT at any finance-related company in NYC, I would say your best bet is to go to networking events. There are always events all over the city every week. I get emails every week about them. You can also sign up to specific groups at sites like meetup.com and go to the events when they schedule to meet up in person. A quick search on that site yielded a bunch of relevant groups in NYC:
https://www.meetup.com/mysqlnyc/
https://www.meetup.com/NY-FinTech/
https://www.meetup.com/ny-tech/
https://www.meetup.com/nyandroiddevelopers/
https://www.meetup.com/UX-Data/
https://www.meetup.com/NYC-Data-Engineering/
and for the ladies:
https://www.meetup.com/WomenWhoCodeNYC/

Granted, these are learning-oriented rather than strictly networking, so the topics of conversation aren't going to be focused on job openings. But networking is obviously a part of it and you can reach out to the contacts you make at these events.

Basically, anything where you can talk to someone face to face so they can get a feel for you and you can make an impression on them. That's the goal. If they like your personality and they think you are competent, they are far more willing to open the door for you and overlook the degree requirement. But you definitely must be very, very competent if you don't have the degree.

Best of luck.
2016 revealed a world in chaos – and one that rationalism can no longer explain
It's not that it's wrong. Having confidence your code works is ultimately the goal. That said, if I just need to know code works, manual, rather than automated testing works just as well, and requires less effort.

Automated testing only shows its real value when you go back to change code that was working before. With the manual approach you'd have to retest everything to have any real confidence. With the automated approach you just run a command.

I'm a big fan of automated testing, but if I didn't expect to have to ever change code, I wouldn't bother with it.
It's one of the social norms on HackerNews that "low-value" comments like "Love it! Thanks!" and "Great Stuff" are discouraged. Although such comments are polite to the poster, they add nothing but noise for all the other readers of the thread.

Instead, it seems to be preferred that you simply upvote the post without replying.
I get paid for code that WORKS, so I write tests...
Paralyzed Fish 'Swims' Through Piscine Virtual Reality
We did something like this, and the goal was absolutely not "to incentivize people to create value for the company."

For a venture-backed startup, that can make sense, but for us it didn't. The company already had value when people joined and not only was "an exit" not guaranteed, it was quite unlikely. We built the company to run it indefinitely. I believe I used a phrase like "In the very unlikely event that the company changes hands.." to introduce this bonus.

Because of those differences, this isn't compensation or incentive and, as you noticed, it doesn't try to be. Think of this as electively sharing a neat event with those who have invested part of their career in the company.
Not necessarily. In many firms the turnover rate is significant enough that you have no idea who will be working on your code in six months or so. Unless you are on the sort of team that never changes, you can't really use your past experience as a guide for a future team's strengths/weaknesses.
You either have to pick a default, or you have to forbid developers from writing a + operation unless they first choose an overflow behavior. I can see arguments for the latter, but it's not a common choice.
Yes, it does require the phone number to activate the account. The same issue exists with Telegram too, which requires a phone number to create an account. Wire [1], which is a similar app, does not require a phone number and can work with an email address.

[1]: https://wire.com
Done!

https://rwmj.wordpress.com/2016/10/15/fedorarisc-v-is-finish...
There's an interesting article on how the movie Wargames[1] influenced the public consciousness surrounding hacking.

Another movie similar to Mr Robot is Algorithm which I'm surprised nobody has mentioned:

https://www.youtube.com/watch?v=6qpudAhYhpc

[1] http://www.nytimes.com/2016/02/21/movies/wargames-and-cybers...

What annoyed me about Mr Robot is the stereotype / trope of a hoodied punk teen wielding their talent with a computer which has been done to death already in other movies (I class Mr Robot as an extended movie with episodes).

Hackers can be anybody infact, and it doesn't help that the hoodied punk stereotype is perpetuated. Think Stallman, Zimmermann, & Eric Raymond, not Zero Cool or Neo.
I have thought about this... and an even worse problem, if this were to be successful, would be CO2 depletion. Plants need CO2 to "breathe"
My view would be that if you are struggling to get useful information out of tests to that extent, then your black boxes are too big!

I agree that there's nothing worse than a test that says "your stuff broke" and provides no additional information why. But there's a balance between that, and testing the internals of an implementation.
But still, you end up with tests for what the author feels his code should handle, not necessarily what the real world is actually like.

Don't get me wrong, that's still valuable - if only for the non-regression aspect - but I feel property-based testing is a superior approach.

Write your code ("this is a function that sorts lists of ints"), write a property ("when given a list of ints, after sorting it, elements should be sorted and the list should have the same size"), let the framework generate test cases for you. Whenever something breaks ("lists of one element come back empty"), extract the test case and put it in a unit test to make sure the same issue doesn't crop up again in the future.
I see bugs in my code very rarely nowadays, and they're always things I should have seen beforehand. In my experience if you're seeing edge cases at all they're a sign that your model is wrong - the business processes we're replacing with software are always simple, there's really no reason for code to ever be complex. The problems we get are those we introduce for ourselves by overcomplicating things in code.

I do think of myself as using TDD, but I use the tests to drive the model and often end up not needing the test - a bit like https://spin.atomicobject.com/2014/12/09/typed-language-tdd-... . With experience, more and more I'll skip past the writing a test and deleting it after, and go straight to encoding the properties that I actually need in my types.
This article doesn't really express the death of the autodidact, but rather than the rejection of the autodidact in Silicon Valley enterprises.

I've seen in this article no references to statistics showing that there are less autodidactic learning now than earlier.

I've not seen either references to statistics showing that there were fewer autodidacts amongst startup entrepreneurs.

I would rather think that with the development of the Internet, of MOOCs, youtube channels dedicated to teaching, and the mere availability of books from the Internet, there is nowadays more autodidactic learning than ever.

For make no mistake, learning anything from a MOOC is really autodidactic: the requirements to pass the MOOC exams are usually minimum, if you want to learn something, you will have to do your own study well beyond what is required to get the little certificate.
It is not my impression that Data Science mixes programming and maths. Unless in a limited field of finance where all data and analysis are maths heavy.
This will technically only work on pipelined architectures of which all major CPU architectures are one. You will be able to see a significant boost to performance given the following are all true:

* You have no inter dependancy of information across the lines
* All your data is in the cache
* You don't have instructions generated between the two lines that will require some sort of operand forwarding

Basically, if you already have the stuff in the cache, the calculation is invarent to the last calculation, and you have a processor capable of it you'll see a large speed improvement.

There is a great talk about this [0] (for the exact moment go to [1]). If you're interested further I'd very much recommend finding some sort of GOOD computer architecture class. Luckily now we have a fantastic resource to locate these such courses [2]. This seems like dark magic and many programmers refuse to come to terms with it's existence. Check out `dreta`'s comment to see an example.

Now I do agree with dreta, this is VERY much architecture dependant but most architectures would benifit from this sort of optimization. Pretty much all modern Intel and AMD CPU's caches are large enough, they support a big enough cache, and they also all have pipelines under the hood. Intel started this in the pentium series with a 5-stage-pipeline (which I find very funny due to the GHz wars that came from that time period desipte the pipeline being probably the pargest performance boon in most cases that you would want to brag about).

[0] - https://www.youtube.com/watch?v=e08kOj2kISU

[1] - https://youtu.be/e08kOj2kISU?t=26m50s

[2] - https://github.com/Developer-Y/cs-video-courses#computer-org...
Portland Adopts Surcharge on C.E.O. Pay in Move vs. Income Inequality
I can replicate this.
Someone, I think it was Copyblogger and others, convinced people that to create "evergreen content" you should take dates off articles and blog posts. The web has been worse off for this advice.
Nikolaj Schlej: Analyzing the Intel Galileo UEFI Source Code with PVS-Studio
I use pexpect as the basis of an automation framework I use a lot:

https://github.com/ianmiell/shutit/blob/master/README.md

Recently I used it to migrate an etcd cluster within OpenShift reproducibly:

https://medium.com/@zwischenzugs/migrating-an-openshift-etcd...
It's still would be more effective to use biomass to sequester the CO2 and then make biopolymers than it's to use an artificial process.

Also solar has it's own carbon footprint, and not as small as people think.

The raw materials for these panels are mined, transported, the factories in China that make those panels use likely coal as their primary energy source, then the panels are transported again and again and again, and finally installed and maintained by people who likely don't show up to work in an EV.

You need to be very careful abstracting the true carbon footprint of anything and sadly too many people seem to ignore this fact.

Just because the item you buy and it's use is environmentally friendly it doesn't mean that the supply chain is.
This is why I advocate for end to end testing of a whole system's expected behavior to augment a small set of unit tests (the unit tests are for edge cases).

Nobody needs division by zero tests if there are already guards in place so that can't happen, but it's quite helpful to have a "A goes in, B should come out" view from a client/user perspective. As long as behavior appears correct to the client and is not exploitable you're good to go.
Testing for me is never primarily about getting it right the first time. Although writing tests in parallel with coverage can definitely help to validate your assumptions, particularly with negative testing that you might not test manually.

The greater value of the tests is later on, when you need to make a change, and want to know whether you broke some existing functionality. Or, once you have a framework of tests around something, being able to quickly write a test that fails due to a discovered bug, and knowing that you fixed it by passing the test.
After I got past the "over capacity" error I got to a screen like the above, but without the terminal.

Javascript error:

index.js:2371 Uncaught TypeError: this.base.append is not a function
The kind of "stats" collected by new relic are only one of many inputs toa data warehouse like Slack is describing. You can't import your mysql databases into new relic, for example.
With all due respect for the project, and those who endorse it, the details they provide on that page is (and I'm use the words Snowden used before) Horse Shit!

I wish I had time to go into details and write a good post about it.
It uses tmux for session management, so you can press Ctrl+b and [ to scroll with the arrow keys and page up/down. But this is definitely something I will try to fix soon.
Monitoring Stdout with a Timeout
Just an fyi about some nuances of TDD that are overlooked based on the 60+ comments I see so far.

Most comments seem to equate:

"regression tests"=="TDD"

... but it's really...

"regression tests" is subset of "TDD"

I'm not a practitioner of TDD but I my understanding of its components are:

1) the ergonomics & design of the API you're building by way of writing the tests first. In this sense, the buzzword acronym could have been EDD (Ergonomics Driven Development). Writing the usage of the API first to see how the interface feels to subsequent programmers. Arguably, a lot of incoherent/inconsistent APIs out there could have benefitted from a little TDD (e.g. func1(src, dst) doesn't match func2(dst, src))

2) a sort of specification of behavior by usage examples ... again by writing the tests first. Consider the case of programmers trying to figure out how an unfamiliar function actually works. Let's say a newbie Javascript programmer wants to know how to use .IndexOf()[1] What do many programmers do? They skip all the intro paragraphs and just hit PageDown repeatedly until they get to the section subtitled as "EXAMPLES". With TDD, instead of examples being relegated to code comments "sqrt(64) // should print 8" , it formally encodes the "should print 8" into real syntax that's understood by the automated test tools. (Test unit frameworks typically use the keyword "Expect()" as the syntax.)

3) an IDE that's "TDD aware" because it creates a quick visual feedback loop (the code that's "red" turns to "green") during initial editing. The TDD "artifacts" can also act as a "dashboard" for subsequent automated builds alerting you that something broke.

So TDD is a "workflow" and from that, you address 3 areas: (1) design (2) documentation (3) quality assurance via regression tests. With that background, the original Stackoverflow question makes more sense: how many "test cases" do I write because it looks like I can get bogged down in the test case phase?!?

[1]https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...
My advice is that if you want to live and work in Denver move there. The reason I say that is that I imagine I'm an employer reading this post. The risk of hiring and relocating a person who wants to move from Florida to Denver is that once I've invested the time and money to bring the person onboard, they've achieved their important goal and will quickly start looking for another job or quit to ski or breakup with the significant other that lives in Denver or decide that the beach is better than the mountains or decide to move from Denver to Pittsburgh or whatever.

That's particularly the case in terms of the listed skillset and experience. This says nothing about how good you are at what you do. It is a statement about the market for people with similar profiles. The good thing is your skillset is portable but it also means that employers can be more selective if they need mid-level Java backend developers.

Finally, most recruiters are more likely a hurdle between you and a job in Denver than a facilitator because most recruiters operate by scanning "we're hiring" pages and job boards, throwing candidates at the open positions, and then negotiating payment if something sticks. If the recruiter cannot negotiate payment, then the candidate won't get the job no matter how good a fit they are.

Some recruiters, as in relatively few, work on an exclusive contract for the employer. By which I mean that one recruiter is the only recruiter for a specific position. Typically, the exclusive contract is contingency, but the terms are agreed upfront and the working relationship with the employer tends to be stable and long term. The best recruiters work on fixed fee and get paid whether or not the position gets filled. Exclusive contracts correlate with more specialized skills and experience. Retained contracts further correlate with very senior positions and tippy top talent.

One of the keys to working with a recruiter is to figure out if the recruiter is actually worth working with. The no-relationship recruiter may completely remove any chance of your working with the company due to the risk of litigation should you get hired through another channel. Or if the outside recruiter can't close the deal, their message to the company may cast you in a poor light, heck recruiters may entirely misrepesent you.

Some tells are if the recruiter asks for your resume in an editable format. That means they send it without your name and that means that they probably don't have a contract. Another tell is simply to ask the recruiter for the name of the company. If the recruiter balks it means you can get the job on your own. Finally, the best way is to simply ask the recruiter about the nature of their recruiting relationship with the company and their track record of placing candidates with the company. Recruiters with an exclusive agreement have no problem telling you and their answers will make sense.

Circling back to my original point. If the economic risk of of moving to Denver is too high for you to take personally, then moving you is an even bigger economic risk for a business.

Good luck.
When a junior dev tries to refactor said class and accidentally screws around with the behaviour of the setter function, having the tests blow up is handy.
If maintainability is part of "works" and tests are a necessity for maintainability (they are), then the quote becomes prettu weird. Substituting [code and tests] for [code that works] gives

> I get paid for [code and tests] not for tests.
I mean if you have a method whose definition is literally just "return 'abc'" and then you have a test assert that that method returns 'abc', knock it off.
PayPal does this too last time I checked (admittedly about a year ago).

It is frustrating as fuck.
Michael Jordan Owns Right to His Name in Chinese Characters, Too, Court Rules
Introducing Gomix, build the app or bot of your dreams in minutes
For me, the takeaway from that article is this:

> Different people will have different testing strategies based on this philosophy, but that seems reasonable to me given the immature state of understanding of how tests can best fit into the inner loop of coding. Ten or twenty years from now we’ll likely have a more universal theory of which tests to write, which tests not to write, and how to tell the difference. In the meantime, experimentation seems in order.

Indeed, we still "don't know" how to test—more generally, and given the abundance of methodologies and their tendency to go through a hype and dump cycle, I would say we still "don't know" how to write code in the first place.

We'll get there eventually, but for now I would take whichever approach, methodology, tools, and language that I use as having a "best before" date, and invest in it accordingly.
Using paid tools has no relation with having or not having your own datacenter.

If you have a small project (what is "small"?) you just deal with Google analytics or direct SQL requests to the single database you have. Don't need fancy tools.

The two free stuff I can think of are piwik and snowplowanalytics. They clearly suffer from "free open source" when compared to the paid tools out there.
Thank you for your explanation and writing this. Added in my todo list to play with. I understand this one is the official repo: https://github.com/ucsd-progsys/liquidhaskell ?
> Want to read/write pretty-arbitrary JSON? Good luck

Parsing JSON in Java was one of my worst programming experiences, so I have to agree with you here.

But in Rust, using the `rustc-serialize` library (and Serde, but I haven't tried that yet), parsing and writing JSON is really pretty painless. The really nice part is that you can declare the structure of your JSON data as a completely normal Rust struct (just with a derive annotation that makes it Encodable and/or Decodable), and with a single function call turn an instance of that struct into a JSON string. And in reverse, you can just parse() a string and it will return either an instance of your struct or an informative error if the JSON is malformed or doesn't match your structure. Makes JSON really easy to work with.
While it might (I don't know) be possible to make the manufacturing process smaller, you couldn't increase the address space without effectively rewriting the entire ISA. You could use bank switching or an MMU to increase the effective address space (allowing the machine to access more RAM than it can physically address), which was done even back in the day, on pretty much every machine.

>you'd be able to compete very well on price for the IoT or other markets.

Why do you think that the Z80 and the 6502 (and their derivatives) are still on the market? :-D