skysight-inc/HackerNews huggingface dataset:
I can highly recommend this. For us Brits this is a national institution and appearing on it is considered a badge of honour similar to a minor peerage. We listen to it live on a Sunday morning.

If you enjoy the format there is a large archive of these with many of the most influential people of the 20th century. However the modern (Kirsty Young) ones are by far the most insightful due to her masterful, understated interviewing.

I offer these as a taster to non-Brits who would like to hear more:

Dustin Hoffman:

http://www.bbc.co.uk/programmes/b01p314n

Tom Hanks:

http://www.bbc.co.uk/programmes/b079m78n

Bruce Springsteen:

http://www.bbc.co.uk/programmes/b0855znp

Bill Gates:

http://www.bbc.co.uk/programmes/b06z1zdt
Thank you Undertaker
When will the first public beta of iOS 11 be ready?
I like that it compiles to a single instruction, but lots of languages already have this; it's pretty common.

Even boring old Java has had Integer.bitCount for many years.
List of Top Truck Bed Tent Camper
You have no BATNA, nobody is going to give you "what youre worth" (they literally do exactly that)
Lots of talk about performance, but no numbers cited. I did my own benchmarks before using sequential ("COMB") GUIDs as 'PRIMARY KEY' (yes, they're surrogate keys) and found no material performance difference. I didn't keep the results, but someone else has made their numbers public here: https://blogs.msdn.microsoft.com/sqlserverfaq/2010/05/27/gui...
>My anecdotal observations don't align with that statement

I can't find it right now but I did see a paper recently that showed a correlation between wealth and hours worked, rich people really do work the longest hours.
A counterpoint is that more declarative code can often remove the need for tedious step by step debugging because the behavior of the code is more transparent. I do most of my work in Haskell and find I don't typically need to debug it like I would for a less declarative language because the meaning of the code is much more clear.
Can someone provide a tl;dr ?
Trademark infringement is all about context. Pirate Joe's for a place that sells pirate costumes isn't trademark infringement. Pirate Joe's in the same font that Trader Joe's uses, for a store that sells Trader Joe's products is probably crossing the line.

Note that the company was started as Transilvania Trading, and didn't get sued until after it changed its name to Pirate Joe's. Moreover, he added the disclaimer "Unauthorized, Unaffiliated and Unafraid" after the lawsuit was filed. Trader Joe's had a very legitimate trademark infringement case, especially during the period where the store was called "Pirate Joe's" with no disclaimer.
All of the examples are far better than the code I normally deal with.

That being said, the most tiresome code is this kind of step-by-step error checking.

if (! is_numeric($id)) {
exit('The ID is not a number.');
}

$db = open_database();
if (! $db) {
exit('There was an error connecting to the database.');
}

$query = db_query($db, 'select * from widgets where id = $1', $id);
if (! $query) {
$db_error = get_db_error_msg($db);
exit('There was something wrong with the query: ' . $db_error);
}

Zzzzzzz. It triples the code size. One third is the normal code path. Two thirds is all the error checking. I'm sorry, I just don't write it:

$db = open_database();
$query = db_query($db, 'select * from widgets where id = $1', $id);

I let errors bubble up to some general error handler, which stops the script in its tracks and gives the user a vague and unhelpful error message. It doesn't matter. Even if I gave them a very specific error message, all that they would do is log a ticket, and I would still go into the server log to uncover the line number the error was on, debug, and fix it.

Don't get me wrong. I write JavaScript to constrain user input, with friendly directions and error messages. And I set tight types in the database and add database constraints where I can. But I don't write all this step-by-step checking in the middle layer (PHP, Python, Go, what have you). So if the user somehow bypasses the JavaScript and tries to insert text into an integer column, the database will simply refuse, and the resulting web page will be a very ugly error message, which is what they deserve.

If the database is down, it's going to be ugly, regardless.

I admit that this strategy works okay for non-life-threatening, SQL-backed web apps and such. You may need to do something tighter in your work. But I wonder if there would still be something more elegant than the every-other-line error checking shown in the article.
Breath tests are notoriously unreliable/inaccurate, to such a degree that in some jurisdictions the law is now phrased entirely in terms of a machine reading since it's been established there's no reliable relationship between the machine reading and blood alcohol level.

Seriously, read up on the history of breath-test machines sometime. Everything from difficult chemistry to literal "oops we misplaced a decimal point in the software".
People forget that Bloomberg had computer networks before the Internet.

I remember when we didn't even have comdb2.
I am still amazed that we survived the Cold War intact. There were so many close calls. My father was a Foreign Service officer, and among his many posts, he was stationed in Moscow in the late 50's. Some of the stories he tells still send a shiver down my spine.

But, survive them we did. As he reminded me, there were many people on all sides working as hard as they could behind the scenes to de-escalate tensions, smooth over diplomatic ruffles, calm the angry leaders. MAD was (and is) such a terrifying thought, and enough people understood the implications, that no button was ever pressed. And that is something to draw hope from.
A tunnel experiment in WebGL
Link to demo: https://tympanus.net/Development/InfiniteTubes/
> '(1 2), even though your macro will see (quote 1 2).

'(1 2) is (quote (1 2)), not (quote 1 2)

> that common patterns (e.g. variable bindings, function definitions, conditionals etc) are easy to parse visually.

Actually those Lisp patterns are not difficult to parse for humans. It's just that it looks a bit unfamiliar for non-Lisp users. The human visual system is capable to deal with that quite easily, it just might take learning. Humans can for example read book pages very fast even though there are very little visual clues in long sequences of text. It's just that humans have read a lot of those books...

The visual pattern for variable binding in Lisp is:

LET var value
var value
var value

expression
expression
expression

That pattern is easy to spot visually. In actual Lisp code it is:

(let ((var value)
(var value)
(var value))
expression
expression
expression)

The top-left item defines the structure of the rest. That item is easy to find. Here it is LET.

All you need to know is what item has what pattern. There are a few basic patterns and combination of those. Once you learn about 10 - 20 of those patterns and understand that something like `WITH-FOO` will give you a clue what pattern to expect, then it is fairly easy to read Lisp.

Typical patterns:

function call
sequence
binding list
with scope
tree if function calls
property list
association list
conditional expression

and some more...
I think most of the complaints about the python version go away when you do something like this....

is_even = lambda n: n % 2 == 0
score_result = lambda j, k: j
is_interesting_result = lambda j, k: is_even(j) and k

a = some_variable + 42
b = sum(map(score_result, filter(is_interesting_result, results)))

or

b = sum(j for (j, k) in results if is_even(j) and k)

List comprehensions only become difficult when you start doing conditional execution within the result side. Use if for filtering or turn your complex operation into a meaningfully named function/lambda expression.
Somehow very swiftly ended up with an atomic bomb......
It's defined few sections in, but yes, your larger point stands.
Paying a price for 8 days of air travel in America
Flatrate rides from ORD to the loop are supposed to be $25. However, you may have to share it with someone... But you'll probably never be able to get that fare. (Look at the chart in the cab)
I have failed multiple times to reliably use a Linux desktop with 1Gb of ram. Even the most stripped down Ubuntu version seems untested for this setup; for instance, the background process that repacks the DEB database easily peaks over 1Gb, and you get the computer swapping at a random point. On top of that, also browsers have a really hard time working with that constraint.
I would love to read an article on setting up such rules. Any links to posts?
I feel that this sort of 'cleverness' in packing a large amount of logic onto a small amount of code is treated quite differently between Python and C-type languages.

In C++, would you write the same structure using a single line for-loop and ternary operators?
You can code golf in any language and it will probably result in less comprehensible code. If there's one thing I think I agree with the original author on, it's that terseness is not an end unto itself. But I think the overall point that terseness can sometimes be bad so therefore we shouldn't work at a higher level of abstraction is really at odds with everything we've learned about programming in the last century.
I think it's related to the iron law of abstractions. It's easier to change code that has no abstraction than the wrong abstraction. The right abstraction is better than both those, of course, but is often difficult to identify upfront.
Nope it does not. Standing for yourself in those situation is about hurting opponent so that he does not try again. That is what men actually do - they are surely as hell less likely to stand up to the boss - such behavior is quite rare. If you succeed, you successfully stood for yourself regardless of whether there were risks or not. It is also a lot about acting aggressive before there was the actual need, to prevent the situation from even happening.

If women have to learn to stand up for themselves as you imply they should, they need to find a way to hurt people who treat them the way they don't like.
Next week: "phoar look at the tits on her"

'He was merely remarking on the young lady's physical pulcritude, there is nothing remotely laddish about that.'
I thought about using RESET of course. The Vcc thing is indeed bizarre and I wouldn't be confident that running logic circuits on a fast dV/dt power supply is a good idea.
App Store now requires developers to use official API
Really interesting to hear this story and to leave the personal context to the end makes it even more impactful. The perseverance and creativity that this person obviously had to show to get this to work for so long are really inspiring, even if lots of other people have done similar things before. I really hope things get better for your country soon.
Ask HN: Which issue tracker / code hosting for an Open Source project?
There are tons of options available. Integrated ones (GitHub, GitLab, Launchpad,...) and specific ones (Gerrit, Monorail, RedMine,...).

We would like to make it as easy as possible for potential new contributors to jump in. Which option would you recommend?
To take your analogy to its conclusion, we don't want to communicate only using small words, true, but we don't want to communicate only using big words, either.

Ain't nobody (= most people) got time for Hegel :)

I suspect that's why some of the very "expressive", i.e. dense languages, aren't widely adopted.
Yes, but this was about long term reliability so programming is of lesser concern.
Being employed isn't voluntary because there are finite resources available to humanity and no one wants to waste those resources supporting a lazy person who doesn't contribute anything.

Being employed at a particular organization is, in fact, voluntary. You are not obligated to stay at one employer forever.
Neural nets that update over time need a way to know what to keep and what to forget from last time. So let's learn what to keep and forget... by using more neural nets.

Disclaimer: I just learned what an LSTM was. But it's a good article.
Start by using done service discovery. That way service names stay the same but service implementations and locations can move.

Then ship the static list of names (should be short) and per-service credentials (highly highly recommended).

Another pattern is co-locating a proxy with your app. See e.g. linkerd on how to do that. This will also unify the handling of circuit breakers and connection pools across services - even without any shared code!
I have an idea in healthcare sector in India. For that i personally made a field study and went to 30 potential. I had made a decent presentation of the basic 3 features and went as a direct walk ins . Half of them were not only willing to use my "product" (which wasnt built yet) but also write a cheque for it. They were bargaining on price at that instant

This was 3 months back. I already run a growing fmcg business . It has drained me of time and resources. I cant find time to give it for this project. I am decent in marketing and especially cold calls and walk ins so i am confident to get things done. But existing commitments and ventures are making it hard for starting the project.
The catch-all top level error handler isn't typically a hallmark of good design but I think it's pretty relatable as a quick fix when you need to get something working on a deadline.
We purchased reserved instances. When I quote the 12.5% number it's amortizing the ri cost.

Reserved instances have saved us a ton of money, even with my screw up last October.
EDIT: nvm
It's like investing energy to switch from "My app runs on Kubernetes" to "My app runs on Windows XP" and being proud about it for unexplainable reasons.
Then please adjust your expectation.

It's not in line with the officially stated purpose of this site, nor with the regulars' expectations.
Would these problems persist if we switched to optical signaling instead of rf? Can we expect an optical PCIe equivalent one day?
Less stupid technical questions, because there are much less cheaters and you can trust the given educational background.

I worked as architect, mech. engineer and various other engineering sectors. There are some technical questions of course but nothing like whiteboarding binary search or tree traversal.
By "inner state", the parent didn't mean literally the RAM or disk storage used internally by the application, just the logical state that belongs to it. A Plan 9 filesystem is just an interprocess communication API that happens to be structured in terms of virtual 'files' and file operations, kind of like what REST does with HTTP. The application handles all requests itself so it can always limit access or enforce invariants, which was absent in the Microsoft examples you linked.
It maybe worth investigating sparklyr[1][2] from RStudio.

[1] https://github.com/rstudio/sparklyr

[2] https://databricks.com/blog/2017/05/25/using-sparklyr-databr...
This is a surprisingly accurate tl;dr for someone who just learnt what LSTMs are.
All of them! The focus should be on career flexibility, not pigeonholing oneself into a single career that can lose viability in an instant.

There is a saying: Don't put all of your eggs in one basket. It is especially pertinent when it comes to jobs. Things can change very quickly, as many people have learned over the years. When there is a concerted effort to push people towards a certain career, as we are seeing with software engineers right now, one should be especially leery about the future.

But at the same time one may as well capitalize on these careers while they are viable. Flexibility allows that and readys one to move into the next big thing when the shift comes.
Is this a standard blog design or is the author of this post also a very creative designer? I am really impressed both by the content and the design of this post.
Solved Data structures and algorithms problems in C/C++
I come from a C# background and have little experience with Haskell, so YMMV. C# got many new features over the years like LINQ or Lambda Expressions. My experience is that you get most of them if used in a moderate way. Like splitting complex LINQ into smaller parts and introduce intermediate results instead of one big query. They are also easier to test this way. Another important aspect of this topic is if you are maintaining your own code or code others have written. I used to maintain code written by another team, which only did feature development and barely any code maintenance. While doing only code maintenance on code written by others for a longer period I gained a new perspective on what's good code in the long term.
The proportionality argument is bunk, straw-man level bunk. Consider what goes on every time go accesses an object, casts to an interface or writes to a channel. Huge, complex code under the covers, way more than the Python examples he's given. What this article really says is "There are abstractions I'm not as comfortable processing as others, therefore those abstractions are bad."

If having code be proportional to complexity was a good idea, we'd all be writing in assembly and subroutines would be frowned on.
Because the world really only needs two selfie-taking apps, and that's me pontificating generously.
> So do whistle blowers.

This is not a whistleblowing case, it is a case of wanton destruction by a former employee.

> That line of reasoning doesn't set the bar for what's right and wrong.

Dragging in all kinds of stuff that has no bearing on the case doesn't set the bar either.

> Are you sure no matter what the company did?

Yep.

> What if the CEO threatened the ex-admins family?
> Or if the ex-admin found child porn on the CEOs computer?

In that case you go to the police and file a report with them. Hurting the company, the employees and customers when your target is the CEO is ineffective and illegal besides.

> There's a fine line between right and wrong in most situations.

No, it's crystal clear that this was wrong in any way you would like to look at it.

> The most egregious acts of disobedience can be seen as defiance or foolish. It's not for you to decide- especially when there isn't any context to this whole situation.

This is a criminal act, pure and simple. If the CEO did anything illegal this guy/girl is an idiot for doing something illegal himself.
> Eventually its gets unwieldy when you have lots of classes.

Yep, if application started to grow, it'll require significant refactoring at some stage. But many application won't grow and using framework for something like 5 services looks like overkill for me.
Also, I'm a little bit surprised by the title/description, and then the examples. As opposite, I was looking at something like https://github.com/JonathanHuot/needrun/ which is EXACTLY a "plain shell script".
History doesn't repeat itself, but it surely rhymes.
I actually try to teach the companies I work with. I call it 'never ending ticket queue syndrome'. What I try to tell them - and which usually clicks - is that the ticket queue is not supposed to be a tredmill, but a series of roads going to an intermediary spot where you can get off the road for a bit. The shorter the ticket queue (or at least the visible portion of it) the better. Sticking your 12 year product roadmap and a couple of hundred unsolved issues the majority of which will likely be forever pushed back because of higher priority items in a company wide visible queue is an excellent recipe for burn-out.
Mobile Learning Activities for Education
I asked repeatedly about these mines of treatment for my uncle. No doctor listened. I'm voided now.
I have a Lua module I wrote that allow me to do stuff like:

process.limits.soft.cpu = "4m" -- limit to 4 minutes of CPU time
process.limits.soft.core = 0 -- and no core file

Yes, ultimately, it ends up in setrlimit(), but the amount of code that goes into backing this up is a bit daunting. But it more than makes up for in showing the intent (and it's not like this is done in the hot path of a program).
I can share my code on Github, it will be interesting to find some commons. Probably, this approach deserves more attention.
Apple's Cook tells MIT graduates: temper technology with humanity
Thanks, that's the best answer.
Can't watch the video now, but are you saying they are vacuums or pressurized? If they are vacuums, the highest vacuum you can have is -1 atmosphere, I.e. No air.

5-6 atmospheres would be PRESSURIZED, not vacuum.

Also, a vacuum would pull in water from the water table, you'd need pressure to keep it out.

Vacuum would be good for fire prevention, things can't burn if there's no oxygen. Pressure, on the other hand, will greatly amplify fire, if you just pressurize air. If you want to avoid that, you have to pressurize with a neutral gas like nitrogen, which would be expensive if there is any regular amount of gas leakage.

In either case, you'd have to build compartments that were pressure/vacuum proof (think a submarine or spacecraft) -- and in either case, leaving the pressure vessel would pose dire risks to occupants.

I'll try to watch the video when I'm back on WiFi.
But the same agreement can also be applied to the opposite. Since Amazon deliveries often take one to two days (assuming you have prime) you might reconsider if you really need that item.
So, disclaimer: I work on Titus.

We have a lot of odd integration points with Netlfix OSS and AWS.

It's funny, but providing simple things like a metadata service is valuable. Our internal Service Discovery relies on it (which is OSS). Also, VPC-integration isn't in Nomad, and again, the Netflix ecosystem expects it. These little integrations make your container appear more EC2 VM/Netflixy, and help leverage the ecosystem.
Focus on self-driving vehicles distracts carmakers from brake technology
I would recommend people to use a persistent collection library like Vavr instead (many other options too).

It provides the same functionality but without string field references (a disaster for refactoring). Additionally it won't require learning a new DSL for basic comparisons because the logic is contained in normal Java code with lambdas and method references.

this:

Gather query = Gather.where("age").greaterThan(50).and("status").is("active");
List<Employee> filtered = query.find(employees);

becomes this:

List<Employee> filtered = employess.filter(e -> e.age > 50 && e.status.equals("active"));
Welcome to the fascinating world of HDR photography
Logging is absolutely not irrelevant to the function of your code. It's a cornerstone of system observability along with instrumentation (metrics) and tracing. It deserves to be unit-tested, same as anything else. Loggers absolutely deserve to be injected and treated the same as any other first-order dependency.
Yes the bulk of our business is time series. This includes everything from hardware break downs to fraud detection.
I think Jeremy has some good points but in general, but I wouldn't assume that everything is binary. (By this, I mean
look at these kinds of terse statements with a bit of nuance)

Usually as long as you have a high amount of regularization and use truncated backprop through time in training you can learn some fairly useful classification and forecasting problems.

Beyond that standard neural net tuning applies. Eg: normalize your data, pay attention to your weight initialization, understand what loss function you're using,..
Race-conditions? As in, if you're running the same Ansible script concurrently on the same machine? Yeah, definitively don't do that. But why would you?

I agree that modules like lineinfile are tricky and should be avoided (better to copy a full file), but it's hardly just as easy to shoot yourself than the equivalent sed command, in my opinion, if nothing else because they're more restricted.
Do you have any evidence for that?

I've met several programming curmudgeons in my time, none of them were JS devs. Oddly they were people like yourself that like to throw around lazy generalizations.