skysight-inc/HackerNews huggingface dataset:
1) Getting emails like this is, sadly, very common

2) Can you fake it? It depends. Some people have it easier than others when it comes to coding ... call it an innate capability. If you have "it" and can learn fast, you might be able to fake an entry level position without effort. Anything more, not so much I'm afraid. So .. have you ever coded before?

3) Seriously think it through if you're going to fake it. Apart from stuff like reputational harm, if you are an alpha-personality, you might find it very hard to fail badly at something. For instance, people stay in PhD programs for years because they are smart and have no idea how to fail out. If I were you, I'd be honest with them ... tell them the extent of your prior knowledge and experience. If they can deal with that and you can learn fast ... that's awesome. If not, no big deal, right? :)
Why? I had (and often have) exactly the opposite sentiment: it is surprising that a language that is as high-level as Haskell can compete with low-level imperative languages.

Regardless what one thinks of Haskell, it's a testament to the work of the GHC developers.
Maybe I'm too cynical, but the NSA will just redefine in their minds what all the terminology means so they can keep doing what they want. If we forbid "collecting records" they'll consider "collecting" to be taking ownership of records and allow themselves to query via PRISM on site at Facebook et al. If that's considered a 'search' violating the 4th amendment, they'll make an AI robot to do the searching. They'll be constantly one step ahead in making new technology to avoid being restricted by terminology. People need to go to prison for what they've already done. Passing a new law to explicitly forbid their past and current behavior only legitimizes what they've done and will lead to further acceptance of their actions.
Perhaps his debt was in bitcoins, so it also increased (as priced in USD)
The Way of All Flesh
TANRI TEYİDİ : GHSSWA DÜNYA KUTSAL İNANCI İLE KENDİNİZİ ESENLİĞE KAZANDIRINIZ
yeah, with ambulances staged right outside when people keel over from heat stroke [1]

So many ambulances responded to medical assistance calls at the warehouse
during a heat wave in May, the paper said, that the retailer paid Cetronia
Ambulance Corps to have paramedics and ambulances stationed outside the
warehouse during several days of excess heat over the summer. About 15
people were taken to hospitals, while 20 or 30 more were treated right
there, the ambulance chief told The Call.

so just like disney, really

[1] http://bits.blogs.nytimes.com/2011/09/19/inside-amazons-very...
Thank you, I know who the Amish are, it just gave methe impression that he has subventionated posts by the Amish and not normal feed. I'll check the link anyway!
Go pretty much compiles and runs within the time the JVM needs to even start.
While it's unlikely that Appointment Reminder is one of Twilio's largest accounts, we do have a number of customers in the Eastern Standard time zone, and due to customer usage patterns we have a predictable spike in outgoing calls and SMS messages which happened to coincide with the early-morning PST Twilio problem.

Under normal circumstances, I have Twilio set up to bill us $500 if the balance ever dips below $500. That $500 is our rebilling increment. Each SMS message and phone call we made caused us to get charged our rebilling increment. We hit $3,500 before our credit card company started rejecting charges. I think that if they hadn't, we would likely have saturated our credit line.

I'm thrilled with Twilio's response to this issue, and most other transient issues I've had being a Twilio customer. The system is mostly rock-solid reliable. I actually went to bed during the middle of this event (midnight, Japan time) because a) my systems were reporting that our messages were successfully going out (so no customer-visible downtime) and b) I had total confidence in Twilio to take care of things. And they did.
Huh. First time I've seen it called a d-mark, usually a demarc
Getting into mainframes is damn near impossible without fluking into an apprenticeship, is the problem.

Taking the IBM courses to fully qualify as a dinosaur herder costs as much as a computer science degree.

The other problem: kids aren't dreaming of maintaining 360 assembler, COBOL or PL/I applications.
Thanks for the upvote. I did not know my karma would get busted for my comment.
some old tracking codes I embedded 4 years ago from some defunct analytics system I can't remember.
Why Google Reader died
> Hopefully in future Rust will adopt something like Go’s automatic initialisation of all values to zero, or at least have this as an option (or document it better, if it already is an option).

First, thanks for the feedback!

Unfortunately, I don't think this feature will be added to Rust, though. IMO it causes bugs, as accidentally failing to initialize a variable yields a garbage value at runtime. There's no reason that 0 is any more likely to be a valid integer value than 1, or 42, or 0xdeadbeef, and the compiler shouldn't try to guess. And the feature wouldn't work in Rust anyhow due to the lack of null pointers.

However, having an explicit zero value is convenient, and this is what the Zero trait is for. With Rust traits you can overload on the return value, like Haskell, so you can write:

let (emptyr: Room, emptyt: Tile, emptyl: Lev) = Zero::zero();
let mut ls = [ emptyl, ..100 ];

assuming that your types derive Zero (which you can do with #[deriving(Zero)]). In the future it should be:

let (emptyr, emptyt, emptyl) = zero();
let mut ls = [ emptyl, ..100 ];

This could be done by either writing a zero() wrapper in the prelude or allowing static methods to be imported, both of which are probably good ideas.
As it happens I just made a Dockerfile for pump.io, in case anybody wants to install it in a docker.io container.

https://github.com/Joeboy/dockerfiles/tree/master/pump.io

Edit: Also I'm https://microca.st/Joeboy if anybody wants to follow me (not that there's anything to follow so far).
This is a point about SR, not GR.

In SR, if A and B are two events and B is outside of the light cone of A, then reference frames can be found where A happens before B, A and B happen at the same time, and A happens after B. Therefore FTL travel in one reference frame is traveling backwards in time in another.

The ability to travel FTL in a single preferred reference frame is not sufficient to cause causality violations. That is because all trips move me forward in time according to the preferred reference frame, so I can't wind up at the same time and place that I (in my personal history) was at before. But if I can travel FTL in my choice of reference frame, in my choice of direction, then I can plan a trip from A to B which is FTL in one reference frame, then switch and travel from B to A FTL in a different reference frame. From the original reference frame I first traveled FTL, then backwards in time. In the second reference frame I first traveled backwards in time, then FTL. But both agree that two copies of me wound up at the same place at the same time, and I can try to violate causality.

Suppose that you go from SR to GR but are dealing with a large region that is approximately described by SR though locally it may look different. In my "warp drive" there is no local FTL. But the observations about SR, reference frames, and simultaneity still hold between two distant locations. The ability to warp as fast as I like but only relative to one "approximate SR reference frame" does not let me violate causality. But the ability to do it in any direction relative to any reference frame that I like, gives me the ability to construct "closed time-like loops". Which is what is required to try to violate causality.

Note that I say "try". It is possible that a unified theory of GR and QM could allow for closed timelike loops, but (thanks to quantum decoherence) would not allow you any meaningful interaction with the previous copy of you.
That's possible! Can you hire them an image coach or acting classes or some sort of interpersonal communication coaching, though? I turned down a job offer from them because of how inauthentic several of the airbnb's office personalities (not only the founders: some of the staff, too) seemed to be.
Nope.
Package signing in the exposed ways means that if you trust the dev once, you will trust him for every subsequent package, no matter where you get it from.

The conclusion is especially bad.

"we'll get a solution where the end user has the relationship with the source of trust and not the package author."

That's extremely dumb, on many levels. I'll go with the possible most disturbing.

If you don't care about the author and only the source, the author just has to put a backdoor in the code. DONE.

That's why you have to trust the author and NOT the source. The author is the first creator of the code and thus the person with the most ability to sign the code.

Package signing ensure the package has not been modified (because you see, replacing SHA hashes is trivial. sha1sum file > thehashfile.txt).

Yes, you'll have to trust someone, at some point. Then you'll build more trust as time goes. That's how it is. When you get your debian package, you trust the debian devs, a bunch of them.
When you trust a arch package, you trust that the devs you trusts make good trust decisions, and you trust them as well (arch uses the "web of trust").

When you trust an SSL server, you trust that your browser made the right trust decisions, and that the CA made the proper checks, and that the server owner is trustable.

When you turn on your computer you trust that intel didn't backdoor their microcode.

And so on. Trust is an infinite "issue" and securing the transport will never ensure the source is correct. Never.
>Neither is true, and this hokey 'user rights' notion is just a thinly veiled justification for a paternalistic communist view of open source collaboration, in which you want to control not only your own code, but the code that other people write, too.

No, this makes no sense. The only people who want to "control code" are proprietary companies. Copyleft and the GPL is a rejection of this, the main goal of it is to ensure that all users have equal control over the software. I don't know know how you draw the conclusion that the GPL only benefits the author, as the author loses most if not all of the (unjust) powers granted by copyright by publishing under the GPL.
I actually had to design one of these dialogs for LinkedIn for the new who viewed my profile when we flipped it to a tit-for-tat system (you show me your name and I'll show you mine).

We spent weeks changing the language to be as clear as possible without being overly verbose. I admit that the first (unreleased) rev probably was a bit shady, but in the end we ended up with something that's primary goal was to inform.

I'm super glad we went that way too. Being upfront and clear turned out to be the way to go. Sure we didn't get instant benefit like you'd get with an opt-out, but the conversion rates were very good even when we spelled out what we were doing.
I've seen at least 3 other such services promising encryption for Facebook chats, but none of them talked about how they're doing it. So how does it work? What is it using? OTR?
This slideshow carries weight because it was written by the chief designer of the Ruby programming language.
That is correct.

Trendon's whole scheme would have worked if the price of bitcoin had started falling, instead of rising so much.
Because it's a poetic, hacker'ish celebration of something that all --err, some of us love so dearly.
Also, Ken Jennings writes his weekly trivia challenge in Emacs:

http://www.ken-jennings.com/messageboards/viewtopic.php?p=12...

That's maybe not the ideal endorsement, though. Ken is a great guy, but having the trivia champion of the world saying he is an enthusiastic Emacs user... well, it doesn't improve Emacs' reputation as an editor for lovers of the esoteric.
No my entire argument depends on the FACT that GPL preserves end user rights which end users are not entitled to with permissive code and are not given with proprietary code. All your attempts to evade this point shows that you have no interest in any honest conversation.

This is not about end user choice, this is about end user rights. With GPL licenced code end users have the _right_ to the source code which created the _actual_ binary they recieve. They don't have to demand the source code, but it is their right, they don't have to examine, modify, run a resulting binary of their own, but it is their right.

These rights are NOT preserved with permissive licencing, and they are NOT granted by proprietary code.

You try to muddy the waters by saying that 'users' don't have to use proprietary code unless they want to, but again developers doesn't have to use GPL licenced code so that doesn't have anything to do with this at all.

Whenever you want to use someone else's code you are subject to their conditions, you sure see nothing wrong with setting conditions for using proprietary code (users can always say no), so by what logic do you think developers should not be allowed to set GPL conditions for their code?

Your communist rant makes you sound like some crazy right-wing extremist, you want to have the right to use other people's code in your proprietary projects, but the notion of other developers instead wanting access to code used in conjunction with theirs in return somehow strikes you as some oppressive communist scheme??? Seriously???

You seem to think open source developers somehow owe you code to use in a proprietary fashion, and if they don't provide it under such conditions they are 'communists who wants to control other people's code'. I can't quite understand people like you.
Quite common in Germany, too.
Yup. Came here to say the same thing as soon as I saw that. Never restart a service that is under high load. Block the network if you must to try to reduce the load, but don't restart.

Part of the problem of being under high load is that sometimes data does not get written out to disk like it should (because of the load on the OS), so restarting can easily corrupt things - especially if you restart the computer rather than the service.

The other takeaway is reboot all your servers monthly! (Or after any changes.) That way you can be sure they'll come back up properly. Reboot when you have time to work on it, so that you don't have an emergency at the worst possible time.
Now this is a very decent hack. I always hope to see more of them. Kudos !
No,Samsung has not passed Apple in Profitability
I saw a lot of leading publications(Business Insider especially) wrongly stating that Samsung passed Apple in Profitability- Answer is NO
Apple reported $6.9bn of net profits and $9.2bn of Operating profits.
Samsung meanwhile reported $8.33bn of Operating Profits.
Press is comparing Apple's net Income with Samsung's Operating profit - This is misleading as it does not include several other expenses like taxation and Interest/extraordinary expenses.
Additionally must remember, Samsung Electronics does much more than mobiles.
You misunderstood what he meant by, I started Ruby development.

That's the creator of the Ruby language. That's when he started developing it.
1. When you sign a file.. oh snap. It generates a checksums and signs the checksum. That's how signing works.
Thats exactly the same as what you propose.
In fact.. the way you propose and without a custom implementation of the signing algorithm, its generally going to generate a hash of the list of hashes and then sign that. Slower, more memory.

The only advantage is if you need to remotely sign a file locally. You can gain time by not having to transfer the file if you sign only the list of hashes (and of course, you've to trust that they've been transported properly, so your trust is less perfect, because further away from the original)

2. The heuristic is the number of signatures you trust. Having thumbs up/down just makes bots happy.
As for malicious merge, yes "eyeballs" are the "only decently reliable solution", but not only this is mission impossible, they'll probably still miss some smart backdoors in the code. All you need is an off by one.. (or what not..)
You can however sign commits, and blame whoever introduced the issue whenever its discovered/public (and decide if it was a legit error or not)

Note: its still a good idea to have automatic checks so that all the "easy stuff" is filtered out, of course.
ZeroMQ is supposed to be a superior alternative to a broker with reduced hops and avoids a single point of failure.

More details here: http://www.zeromq.org/whitepapers:brokerless
StoryApp: Tell your stories to the world
Writing a single sentence fragment per slide for 75 slides does not make poetry.
I saw a lot of leading publications(Business Insider especially) wrongly stating that Samsung passed Apple in Profitability- Answer is NO
Apple reported $6.9bn of net profits and $9.2bn of Operating profits.
Samsung meanwhile reported $8.33bn of Operating Profits.
Press is comparing Apple's net Income with Samsung's Operating profit - This is misleading as it does not include several other expenses like taxation and Interest/extraordinary expenses.
Additionally must remember, Samsung Electronics does much more than mobiles.
Try Mypaint or Krita as alternatives to Gimp and please do not bad-mouth FOSS painting tools if you do not know them.
What if someone makes a typo entering their SSN in the form that leads to this page, are they also a hacker? By your definition, they would be.

If your data is on the internet and not secured, it is being scraped by robots constantly for a start, some of which might iterate counters, so some responsibility lies with those who maintain the website. There isn't a clear line like the threshold of a dwelling we can point to, because it's not always clear which urls are authorised for a user and which are not. Ultimately you're not going to stop the curious, and bots, from scraping the web, so if there are no access controls on your payroll you can expect data to leak, even if you come down hard on every single person you find accessing it without authorisation.

I think the emphasis here should be on intent, as shown by the data taken, and what was done with it, not on trying public urls. If someone shows intent to steal information by changing urls, then downloads the info, then uses it for identity theft or sells it on, that's clearly a crime, and unless they have mitigating circumstances, perhaps it deserves a fine or a very short jail sentence for serious cases. I do think the sentences today are excessive for this sort of activity.

If they simply access a URL as you propose above, I don't think you can show intent. Even if they access several urls, was their intent to explore, or to steal information, or did they just follow a bad set of links or make a mistake with their web crawler?
Actually there is nothing about interpreted languages which makes concurrency particularly difficult other than their history.

As an extreme example, you can run Erlang as an interpreted language and concurrency will not be a problem.
Cisco buys Sourcefire for $2.7 billion
Ask HN: What's the fnid in the URL?
What's it used for and how is it calculated?
Ex: https://news.ycombinator.com/x?fnid=ErFrwPqYY6tmu1v2had2pg
I don't understand the purpose of the website related to the domain name. Could someone tell me the link between the two, I am genuinely missing it?
I've had a long history with Scala, but have only written about 500 lines of code using it. My feelings towards it had this trajectory: great hope, realistic hope, caution, suspicion, confusion, disappointment, pity.

Around 2006 I was working at a pretty large Java shop, and had hoped to convince the whole organization to gradually switch to Scala. There was one thing that really bothered me at the time, which was the inclusion of XML in the language. I wasn't too fond of XML, didn't think it would last, and thought it a sign of thoughtless trend-following on the part of the language designers, but I liked pretty much everything else. I really liked traits, I liked pattern matching; I really liked lambdas. I thought the language would never win any points for elegance and grace, but at least it was powerful. In any case, the language was young, and I knew I would have to let it mature before there was a real chance of it being adopted in such a large organization, so I kept close tabs.

Shortly after, implicits were introduced (if I have my chronology straight), and I then noticed that scaladoc only made an API even harder to understand, but I thought this could be resolved. Then structural types were introduced, and a big red warning light went off in my head. By 2009-2010 it was clear that a large organization like the one I was working at, would never adopt Scala; it was too unwieldy. Then collections were revamped, and Scala became the only language in existence whose automatically-generated documentation ensured that an API could never be understood. The designers' taste, or lack thereof (taste means choice; preference) was clear. I was then introduced to Clojure and learned that an extremely powerful language can be extremely elegant at the same time, and that a language can really help you program (rather than confuse you with "constructs") by adopting a coherent philosophy. I pretty much abandoned any hope for ever liking Scala again (or recommending it for a large organization), but I swear to you that I still thought, "the Scala guys haven't adopted macros yet in spite of their lispy awesomeness; perhaps there's some hope to them yet; maybe they finally realized that mixing ice-cream, steak, and pizza in a bowl does not make a good salad". We all know how that turned out.

I think I'm a pragmatist, but leaving aside the total incoherence of Scala, it has become so inelegant, so ungraceful, that I wouldn't use it for that reason alone, especially considering that most modern (and non-modern) languages value elegance. It's as if C++ hasn't taught us anything; as if programmers need to make a binary choice between power and beauty.

In the meantime, Scaladoc has actually improved, but that's just too little too late.
Technically speaking, old design for comments are loaded and then, using JavaScript, it's replaced with the new design.
I fully agree.

Dynamic languages don't scale on the typical enterprise Fortune 500 with three development sites and 50+ developers, as an example of the typical project sizes I work on.

The main reasons tend to be:

- Lack of unit testing, yes even in 2013 most enterprise managers would rather that time is spent on "real" coding

- Massive code size, hard to navigate with just grep/find

- Skill set varies too much across teams, specially if seen as cogs
If the package repository acted as a certificate authority, and generated distributors' certificates by verifying the distributor's appropriate virtual identity (GitHub, BitBucket, DNS), then I think you can at least be pretty sure that the person making the release is someone who would have had access to commit to the project's source code anyway.

Is that at least "good enough"? If the root certificate for the package repo's CA were itself signed by a real-world CA, then I think what you end up trusting is the security of the repo, of GitHub, and of the project's developer(s). Projects with multiple committers could have several of them receive certificates, and require a quorum of signatures before a release is published, to mitigate the risk of any one core dev being compromised.

To keep package names trustable, I think the only sane scheme would be using the project's URL on the service which was used to prove its identity; Rails would be "https://github.com/rails/rails", though surely you could use aliases (github:rails/rails) to reduce typing.
Why is that so hard to believe? Some people do feel ill when reading about vile and disgusting circumstances and situations.

Yeah, fun times at start ups, unless you are a woman. Why are we celebrating this bullshit again?
You mean Modula-2 co-routines. :)