skysight-inc/HackerNews huggingface dataset:
You can slightly change the context of the problem, and it entirely changes the character of responses:

Imagine you're an accountant working for the government. You choose how medical research funds are spent. One day, you notice that there are two equally expensive programs: Program A, which will save one life next year, and Program B, which could save five lives next year.

Program A is being funded, but Program B isn't. Program B could be funded if you took all of the funding from program A and diverted it.

Do you divert the funds?
If the default behaviour of nil on a send for a method that doesn't exist was to return nil, then nils will flow through your program further than anticipated and debugging will become more difficult.

Nils will get into data structures and figuring out when and where they got there will become more work. You'd end up writing a lot more logic testing for nil and throwing an exception when it's found, to avoid the nil propagating further.
The author is missing the point.

Is he? The point is that in Java you are still able to treat x unsafely, while languages with stronger typing do not. E.g. in Haskell, if a function returns a Maybe a, it will always be a Just a or Nothing value. Moreover, such languages allow you to make non-exhaustive matching against all constructors a compiler error.

tl;dr: Haskell, Rust, et al. put the burden on the compiler. Java puts the burden to ensure safety on the programmer. (As can be witnessed in your snippet.)
Reimage Pc Repair License Key and Crack Free Download
If I change the login setting, this usually works (yeah, I have extra layer of shell but I don't care):

$ /bin/bash -l

Environment variables in Unix isn't for changing global settings. Their effects are localized by design.
English script doesn't, and we use it for English language, so why not?
That's the HN convoluted 'no' he was referring to.
Get/Giveaway Coda for Free EASY HACK
This is a bug that I recently discovered trying to install and activate CODA! Listen this only works if you have purchased the software at least once from the App store. I’m not sure but I believe coda 2.5 is where they dropped App store distribution. This allows a nice exploit of the system.

1. Firstly you have to install the app store version of the software in this case 2.0 as it is the highest version the App store can deliver.

2. Secondly you have to follow the upgrade prompt from coda and make sure you select upgrade to 2.5 at which point it will ask you if you want to register. Once this happens you will be sent a different serial number from your original to unlock the software.

3.Lastly this is the most important step when you register you must change the email address associated with that serial to a non-Apple ID address after this you own the software free and clear. Keygen supplied by the good folks at Panic.

It will give some dumb ass prompt at the end of the process that said apple id not found bull-shit just ignore it and safely stash your key away. If you have a busy that already own coda and wants to share the love try this out. I might post 1 key but I don’t have the time or patience to sit and push out keys all day as I am busy writing code for my website.
There are 2.7 people in the average US household. If homes are equivalent to households (I don’t know how they are defined – I think they might be identical) then this power plant can power two thirds of your city (presumably minus all the infrastructure needed to run all the rest of the city, everything from offices to shopping malls to street lights – I don’t even know what the relation of residential use to all other use is nor would I be super keen on guessing), not just a quarter.

Still, I do agree that it’s easier to visualize with the number of households attached, inaccuracies be damned (at least if you do both).

PS: Interesting tidbit I just found out while doing some quick googling on this: Apparently the average US household consumes more electricity per month (more than 900 kWh) than I do in a whole year (roughly 800 kWh).
I wildly disagree, because I get waking nightmares from the amount of implicit "wtf why doesn't it even enter my method" behavior that would imply, but I upvoted you because I think it's a very interesting idea and I wonder what others think.
In German you could argue uppercase letters are word-starting versions of lowercase letters.
I disagree with some of your points.

The fact that you can get a null instance of Optional is not Java specific - Scala has the same issue, for example. Saying that Optional does not sort any problem because there is no way to enforce it cannot be null is just wrong - it sorts plenty of problems, just not all of them (you didn't mention the case of an optional that contains null, which is unpleasant as well).

You can indeed call .get - so can you in Scala (.get) or Haskell (fromJust) with exactly the same semantics. What do you propose for the case where you know that there is a value in there but can't make the type system aware of that fact (you've called isPresent beforehand)? pattern matching and fail in the empty case? How is that different from calling get? Is it because of the fact that the exception is unchecked? In that case, why not throw a more specific, checked exception through orElseGet? And if you know that there is data to be had, isn't that exactly why we have unchecked exceptions in the first place?

You absolutely are required to handle the not-present case - you can't treat an Optional<T> an a T, and someone will need to decide what to do at some point. Either the caller (ie you return an Optional yourself after mapping into it) or you. There's a wide range of ways you can do that, one of which being "I want to fail if there is no data" - that's either .get if you don't need a checked exception or .orElseGet if you need something more constrained. You can also decide to use a default value, or o different code path entirely...

Optional has issues - it can contain reference to a mutable variable, for exemple, or you might find yourself with a null optional or an optional that contains null. It's not perfect. It's also a lot better than the alternative, null, as it lets you communicate some of your constraints to the compiler and allow it to catch certain kinds of errors at compile-time rather than at runtime. Rather like the rest of the Java type system, in fact - it's far from perfect, it doesn't catch all type errors at compile time, but it's (arguably) better than a fully dynamic one.
What string? Is it a webpage modification or just a whois modification? What exactly is it looking for?
Theoretically, Arabic no but Persian yes. I can say with confidence that Persian have phonemes such as /v/, /p/, and the clear distinction between /j/ and /g/ because you might find this funny that Standard Arabic doesn't have a /g/ phoneme but in other derivative variations like Egyptian, Yemeni, Omani, it's featured prominently, and when they like to denote that, they esp. Levantine people usually resort to write it as غ like in «Google غوغل» which is the equivalent of the Parisian /r/, which is in my opinion it's still wrong, very wrong actually.

It's safer for you to go with Persian other than Arab if the existence of these equivalent phonemes is a priority for you.
More easily explained as: "alcohol shuts down emotions, so the logic is all that remains"
Close, but not quite there. You should leap over tall buildings to make sure that you never have to set y to null.

In my code, I'm only dealing with null if a API gives me one. At that point, I take some sort of action to make absolutely sure I'm not passing it along to anyone else. This means using exceptions, the null object pattern, or Optional without a need to dereference. The goal is to prevent a proliferation of references that could be null and therefore have to be checked.
A GoogleNet or VGGNet has tons of parameters. How many convolutional layers are stacked together, the size and stride of each one, where to put the dropout layers, where to put the full connection layers, how they are connected together, global learning rate and momentum and decay, local learning rate and momentum and decay, each of these myriad parameters have an unpredictable effect on the final result. The initialization of the network also has a major bearing on the final outcome. It is almost a chaotic system where nothing small can be safely ignored. One time my result of training a CNN was swung by the `batch_size` parameter and to this day I don't know how.

Those parameters are exactly the type of handcrafted optimizations I am talking about. You cannot just fill in arbitrary numbers and expect the network to fare well. In fact, you cannot even expect it to converge.

You can take those papers and build a world class classifier only because someone else has taken all the time to optimize for the specific case. Once you switch the task, the result will be OK, but nowhere close to what a human or a true AI would give you. Not until you take the time to optimize the parameters.
> Where did the null come from?

A bit offtopic but SAP JVM puts that info in NPE error message[1], I don't know why others implementations don't, maybe it is incurring too large overhead?

[1] it is something like "Attempted to call getLocation() on Franchise object returned from getFranchise() but it was null"
Well, if you choose those specific percentages, people might think it's a small accomplishment, 15%, 7% and 2% seem kind of small.

I don't think there is one good way of representing numbers, it's a complex matter because it's not about the number itself, it's about our perception.
Partial functions such as fromJust are generally frowned upon in the Haskell community. There was a relatively recent proposal to deprecate and then remove fromJust:

https://mail.haskell.org/pipermail/libraries/2015-February/0...
I don't think alcohol shuts down emotions. Anecdotally speaking, alcohol seems to enhance feelings of anger and happiness in certain individuals.
Also, long hair in front of your shoulders (no ponytail).
Fairphone 2 brings modular Android to the masses this December
Ai Weiwei swamped by Lego donation offers after ban on 'political' artwork
I agree that the invokation idea is relatively wild, that's why I made it into a separate point. There are somewhat successful languages out there where sending a message to a null object doesn't do anything. If this is a class of bug that happens to you frequently, it's probably not for you. But once you get into the mindset that each method call is prepended by a virtual conditional, my hunch is you would know pretty quickly why your method isn't being called.
I'm going to go ahead and paste the top comment from YouTube here:

“They say simplicity is genius. School teachers should watch and learn from this man. Imagine the kid's imaginations being stoked by this approach.”

Indeed.
> read what you have written OUT LOUD

I sometimes use this when not writing anything that is destined to directly go to other people in order to help my understanding. When working on a confusing problem I try to write it down as if I was explaining it to another person, and verbalise in my head what I have written (I'm liking the TTS solution someone mentioned elsewhere in the thread, I might have to bring some headphones into work and try that). It is surprising how often making myself write down the problem as if explaining it to another person makes the blindingly obvious solution that I'm until that point missing (or just over complicating) jump out.

Thinking of the problem as if you have to explain it to someone (even if that someone is an imaginary friend version of myself) forces me to organise my thoughts in a more structured manner (this leads to that which causes the other because of the thing that does the things to the other things so I considered that update but that would conflict with function X... - for more complicated things I'll even draw myself a diagram) which highlights the parts I'm skipping over but shouldn't be.
> ... I have extra layer of shell ...

Fix that by running:

$ exec /bin/bash -l

instead.
'read what you have written OUT LOUD'

This right here. Anything I've written is read out load, and it's astonishing how many unclear sentences, head smashing obtuseness and general rubbish this picks up.
Bolivia deciding they don't need our money anymore is exactly how it's supposed to work.

That's a bit of a simplification, ignoring things like the US having Evo Morales' plane grounded because they suspected Snowden was on board, and the expulsion of the DEA. Also Bolivia has struck gas and wants to keep the money in the country. The accusations that USAID is trying to overthrow the Bolivian government? Well, it's hardly paranoia if it happened to your neighbour. That doesn't make it true but it makes it worth taking very seriously.

The US is absolutely not a pay-day lender; it's more of a super-PAC. The money is given for specific political purposes.
> Before I publish a new essay, I read it out loud and fix everything that doesn't sound like conversation. I even fix bits that are phonetically awkward; I don't know if that's necessary, but it doesn't cost much.

This is the key bit. It's not so much "write like you talk" and more "write like you could present it."

So much writing isn't accessible because the author misses this cardinal rule. Even the most dense, formal scientific writing can be made clearer if the author or editor reads it aloud and fixes the awkward parts.

I helped content editing for an academic journal back in the day. A big part of our jobs was helping the authors bring their voice out into the papers. A lot of writers, novice and expert alike, have an idea of what an "expert" in their field should sound like. The result is stiff and manufactured prose that too often ends up being inaccessible for anyone else.

But, as soon as you clue an author in on how their personal voice can come through an article, you see a shift in the quality and clarity of the work.

The articles, text books and other writing I learn the best from, and come back to, ultimately sound in my head as if the author and I are speaking aloud. It's the real differentiator in sounding like an amateur or an expert.
In Defense of the Company Town
I feel get is acceptable style if you actually want to fail when there is no data to be had.

If you don't have a default value to provide, nor an alternate code path other than "sod this, I'm bailing", get is ok. Not quite as good as using a more specific exception through orElseGet, but not bad, exactly.

Also, if you have just called isPresent (and assume your data to be immutable), then get is ok - the alternative being to manually throw something like new IllegalStateException("the impossible has happened!"), which is not that much more useful, and is a pain to have to write all the time when you know it will not get called.
FYI .try takes a block. Passing a symbol is just shorthand, similar to how map(&:method) is shorthand for .map {|x| x.method }

So technically you can pass arguments to a try method by doing object.try {|o| o.method(args) }

Not trying to be pedantic, hopefully being helpful.
Step 1: gems, npm, pip, etc.
Step 2: "containers".
Step 3: this.
> German still has an sz-ligature (...) that has actually ceased to be considered a ligature and become an actual character

Can you explain why this happened? As a non-german speaker it always struck me as a stupid confusion between orthography and typography, but I assume there must be some historical reason for it?
Maybe ultrasonic vibration could be used? I don't know if it can handle large particles/amount of dust or how it would affect wildlife.
Did this article overlook the recent findings that Alcohol is similar in effects to low doses of Oxytocin and thus influences a 'trust decision'?
Good, I guess it's a way to legitimise .try()
I like it.
Consider using core OS tools (wget/fetch, tar, etc.) versus the dependency tree required to run git on your system. Do you need curl? Do you need perl? Do you need a XML parser and a regex runtime engine?
> By the way, the hour the programmer stays in the office overtime to optimize that code, using computers and lights and other machines, probably damages the environment more than your example before...

What if we're talking about the file-copy API in some widely distributed operating system? That's going to be multiplied by millions and millions of people, and therefore, being an obtuse devil's advocate, i argue that indeed it would have an appreciable impact on the environment.

If, however, you're talking about some relatively infrequently used GUI element in an application which has merely a million users, then okay, indeed, go home and don't waste another hour of lights and computers at your office :).
That's largely because you still have the package manager to resort to in order to take care of most dependencies. Prior to that, you'd still have to install (a lot of) dependencies by hand. Not all of them used autotools, not all of them used standard install locations by default... it was pretty atrocious.

In fact, I remember that one thing which kept me on Debian for a long time was that it had so many available packages. Back then Debian was even slower than today and many of those packages were a little old, but it didn't really matter to someone who was just discovering things.

It's easy to forget about them, but package maintainers are incredibly important in today's Linux (and *nix-inspired in general) world. There's a lot of hard work behind the fact that you can just apt-get whatever new program you found out about.
It is not THAT clear. Hence that multiple other papers, as the article says, made mistakes.
The original plan called for a LA to San Fran trip time of less than 2 hours or 40 minutes, which would have required peak speeds of over 350 km/h (faster than any other train in the world), and average speeds of 320 km/h. This would be difficult to achieve anywhere, but it's especially hard (read: utterly impossible) to achieve on that route, since for regulatory reasons the train will be limited to 160 km/h for significant portions of the route.

Since then, the plan has changed repeatedly, and not for the better. It currently looks like average trip times will be in the 4-6 hour range. That is hopefully achievable (although they haven't built it yet), but one thing it isn't is high speed. (They're hoping to work in some "express" trains which will do better, but it's an open question whether they're manage it, and even if they do, they won't be remotely as fast as Europe, China, or Japan.)

You're talking about trains going 300 km/h, but California is looking to build a train that will be doing literally half that. By many common definitions, it's not even "high speed rail".

> I have a question to all the naysayers

I love high speed rail, and I hope maybe one day California will try and build a high speed rail network. :) Naysaying what they're actually building doesn't mean I don't like rail.
> so what about CVS, svn, Mercurial and fossil

Why, these are pretty basic too. Especially if what you want is just to get the code. Having a bit of experience with any VCS will let you skim the relevant manpage and use another VCS in minutes tops.

> including it in an initrd seems excessive.

True...

> Furthermore git downloads the entire repo

Not necessarily? I think you can download just the source files, without any git metadata, turning git into SVN essentially. I'm not 100% sure though, but I'd be really surprised was it not the case.

---

I started my VCS adventure with RCS, then (quickly) moved to CVS, then (even more quickly) to SVN. As soon as DVCS started to appear I switched to bazaar (bzr), then git. These are the VCS I used for my own projects; I probably used a couple more VCSes in a situation where I needed latest code for some project which used something like Mercurial, or Darcs, etc.

In general, I think it's fair to say that Version Control, as a whole, is a basic tool.
Lua binary modules are supported by referencing the path to the module's static library and any dependent libraries. Used packages are not automatically pulled in. LuaRocks integration would be interesting: https://github.com/keplerproject/luarocks/pull/264
Brian Goetz's response: "They didn't solve the problem I thought they should have solved, so their solution is worthless." Thank you, internetz.[0]

In any case, that's not what Java's optional is there for[1]. Solving the safety problem is the job of Java 8's pluggable type systems[2] that are both more powerful than the static-analysis tools listed in the article and had Oracle's official support (in the form of JSR-308).

[0]: https://twitter.com/BrianGoetz/status/656860771196887040

[1]: http://stackoverflow.com/a/26328555/750563

[2]: http://types.cs.washington.edu/checker-framework/current/che...
This seems inconsistent behaviour to me. Some running processes reload the environment and others don't. Maybe in Windows they can get away with it, but that doesn't mean it's a good idea.
The child objects may not exist. "u" is nil (a null pointer, more or less), calling "u.profiles" sends the :profiles message to nil. NilClass probably doesn't have a :profiles method, so this will probably raise a NoMethodError exception.

As for why this is a common problem, "u.profiles.thumbnails.large" is is probably a chain of Rails/ActiveRecord model associations[1], which generally map to table rows . If there the "profiles" table doesn't have any rows "WHERE profiles.user_id = users.id", then ActiveRecord will leave a nil[2] (or empty array) in user.profiles. This is true for all foreign key relationships, so you often end up having to do something to protect against null values (no rows) every time you move between models.

Sometimes it is possible to work around this by always creating the associated model when the parent object is created, that only works in a few cases. Note: I recommend against doing tricks to auto-build the associated model on first access: that kind of "clever" solution can lead to confusing bugs later on. (I learned that one the hard way)

[1] http://guides.rubyonrails.org/association_basics.html

[2] ibid, 4.1.1.1 "The association method returns the associated object, if any. If no associated object is found, it returns nil."
An assumed admixture
This is another off-base point, in my opinion. Sure, it's possible for it to be null, and that isn't great - but the vast majority of null problems come from the user assuming the interface won't give you a null. Something returning an Optional should never return null, so the ambiguity is resolved. Sure, it still could as a bug, but that's actually a pretty rare case. I don't see it being a real problem.
> you didn't mention the case of an optional that contains null

That's not possible in Java. `Optional.ofNullable(null)` returns `Optional.empty()`, and `Optional.of(null)` throws a NullPointerException.
I agree with this. I don't see why new syntax (which looks kinda confusing, IMO) should be added to solve a problem which can be solved with a method. A naive-2-minute implementation:

module Chainable
def chain(*kl)
k = kl.shift

if self.respond_to?(k)
v = self.public_send(k)
else
v = nil
end

return v if kl.empty?

unless v.respond_to? :chain
raise ArgumentError, "can't chain on `#{k.inspect} => #{v.inspect}:#{v.class}`"
end

return v.chain(*kl)
end
end

and then this:

class Object
include Chainable
end
Well the panels are tracking the sun, so it would make sense to build in a wiper that utilises same mechanical motion. Possibly even use condensation - in the precise time of night at dew point, rotate the panel to a morning position.
Yeah, have some people gently brush them after dust events.
As of Java 8, Java has pluggable type systems[1], some of them are more advanced than what Haskell provides (like true intersection unit types), some effect types (locks etc.) and more. So Java puts the burden on some very advanced -- but optional -- type systems.

[1]: http://types.cs.washington.edu/checker-framework/current/che...