skysight-inc/HackerNews huggingface dataset:
I agree that getting just the right amount of simplicity is actually a hard challenge. JSON over HTTP feels like it has won as it was so trivial to implement in any language, however experience has taught me that the lack of a schema causes problems over time.

At StackHut (www.stackhut.com) we're using JSON with a lightweight schema. So far this is working very well, providing simple yet 'typed' remote interfaces into containers. However I often wonder about switching to XML/XML-schema/XML-RPC, protocol buffers/gRPC or some custom system in the future or to just keep it simple and not over-complicate things.
Rusty is the name of the TCP/IP stack that was developed to increase the throughput of the traffic simulator. The software is written using the C++ programming language.

Awes, I was hoping (due to the name) that it would be written in Rust.
The people in charge of trying to root out fraud don't have the power to raise taxes. They aren't congresscritters.

That doesn't imply that they aren't demoralized, ineffective, or hamstrung, but still.
NIL is fine ... as long as you have some container for the opposite.

There should be a way to express Maybe<Maybe<T>>, aka an optional optional value.

The Store article in the article is an example of when this would be needed: a cache optionally has an optional phone number for a person.

If Lisp has the equivalent of Maybe<Maybe<T>> (perhaps a singleton list of a singleton list?), then the optionality is composable. Otherwise, the optionality is not really composable, and you will have problems.
I agree, Swift's optionals are really great. But I also like Objective-C's nil: you can send messages to it and it won't do anything. That too solves a ton of problems with NULL.
https://www.mandrill.com

http://www.mailgun.com
What are your peak memory, cpu, and bandwidth requirements? GAE is expensive for what you get. Have you considered dedicated hardware to offset hosting costs?
It only seems like a mistake in an age where there's practically unlimited memory available.
'you are a nice asshole wanker' is also marked as cheerful and agreeable. I guess it has no clue about sarcasm.
boost::optional and call it a day.

http://www.boost.org/doc/libs/1_59_0/libs/optional/doc/html/...
NIL is objectively, unquestionably safer than a raw machine pointer that is null. It's a first class object with a type; a symbol with a name, and instance of the NULL class and so on.

Of course, if you want to use NIL as a character string or floating-point value, there is an exception. That's your fault: you needed a way to indicate "I don't have a string here" or "I don't have a number", and you bungled the logic.
I agree with the article, yet, despite what the table at the end suggest I got significantly less problems with NullPointerExceptions since I switched from Java to C++ for my work.

C++ has an inbuilt alternative: references. References in conjunction with the Null Object Pattern have solved my problems until now.

References simply cannot be null -- and I generally do not use raw pointers in my code unless some library forces me to.
The star chart at the end of the article lists Haskell, OCaml, and Standard ML as languages that omit NULL. (Where no null means five stars, of course.)

I think Rust should also have 5 stars in this comparison as it forbids null pointers.
Yes, I'm quite aware of what Angular, Backbone, etc do. I'm also quite aware of what MVC is thankyouverymuch.

But I was specifically referring to data processing on the client and while those frameworks obviously can do that the page you linked describes where they farm it out to other cloud services.

This is obviously faster than doing it on the client.. and is exactly what I was talking about.

The future you linked to is the exact opposite of doing data processing on the client. So why you'd call client-side data processing the future with that link as evidence I don't know.

... unless you don't actually understand what "client side" means I guess. Client Initiated Processing !== Clint Side Processing.
I have never thought that setting up false billing infinities that are easily exploitable was ever a good idea.

People that think bandwidth is free are operating under a ludicrous interpretation of the facts.

Ever increasing bandwidth requires constant capital expenditure to upgrade the infrastructure. The bandwidth fairies do not show up at night to sprinkle pixie dust on your cable modem. If someone thinks it does not, I invite them to dust off their 56K modem and connect to the infrastructure of yesteryear.

Now, I am all for cheap internet and requiring unbundled access and creating an environment that encourages competition. But to advocate "unlimited" plans that then require all kinds of loopholes for dealing with people actually taking advantage of the impossible, well, that's just wasting everyone's time and money.
Aritzia Warehouse Sale 2015
MANTL.io: The Bedrock of Hassle Free Microservices Infrastructure
Yeah, I know. Due to inertia, I'm still using sys-fs/udev and will probably continue to do so until Sievers makes good on his implied threat.
Erm, you are simply misinformed. I use Bootstrap and I never use any presentational classes, these are just provided for convenience (although a huge amount of people abuse them).

Bootstrap provides LESS mixins like .make-row(), .make-*column() etc. to keep your CSS semantic.
https://hackage.haskell.org/package/base-4.8.1.0/docs/Foreig...
Replacement for jQuery DataTables w/ React.js
Handling a lot of connection should not be an issue for the network stack, at there is no shared state between TCP streams. The bottleneck would rather located at the application layer, if resources are shared between connections.

I do not think that you could get a 10 times improvement by using x86 hardware. It should rather be somewhere near a 2 or 3 times improvement.
I agree. I have two Airports - one in my house, and one in my detached garage/office. Being able to bridge the two together into a single seamless network was easy and reliable. Doing it with my previous wireless routers was a total pain.
I am a professional web developer (edit: actually i'm selling myself short with this title as I speak multiple programming languages, do UI and a host of other things) and haven't had a fulltime job in over 4 years. I try to get remote contracts that last from 1 to 6 months (3 months is the norm) and then I spend a month or two off self educating and making video games (trying to transition to indie game dev). I'm exponentially happier than when I had to wake up and head to a 9 to 5 even though I have less money and live much more sparsely.
Kapow, I don't agree with your assessment.
Lisp nil is really unit right? Nothing to do with null as otherwise used?

Can you describe when you want to directly have an object that isn't there? If you want a "decoy object" that faults if used... why isn't Maybe perfect for that?
No need to politicize it. I think both decentralization and the banishment of X for the benefit of Y have ruined the schools.

Mostly I'm upset about them making everything social. Not allowing humans to wander amongst ideas on their own uninterruptedly and make their own connections have created shallow and empty workers.

I wish what A.C. Grayling is doing would be taken more seriously before it is too late.
Another reason that, even despite sharing a lot of syntax with PHP, Hack is one of my favorite languages:

http://docs.hhvm.com/manual/en/hack.nullable.php
You don't need multiple return for this - that's exactly what Maybe is for. (You should have multiple return via tuples, but for other reasons.)
The ruby version is on feature freeze until libsass catches up.
There is a reason why in Lisp the type of NIL is NULL and not NIL. NIL does in fact name a type also. That is different from the NULL type/class.

NULL has one instance, the object NIL. NULL isn't derived from anything; its superclass is the master superclass T.

The NIL type has an empty domain: no object is of the NIL type. (Somewhat like in C and C++, no object is of the void type, for those who like pointless C and C++ analogies that don't lead anywhere.) Furthermore, the NIL type is a subtype of every other type, the same way that T is a supertype of every other type. That is to say, every type is implicitly a supertype of nil. This goes hand in hand with the fact that the set of instances of any type is a superset of the empty set. E.g. set of integers (a type) has an empty subset (every set does), and that empty subset can be identified as the NIL type, whose domain is the empty set.
I'm not sure if you're implying that the population growth rate of India is very high, but if you are that's not true anymore. It's actually very close to replacement levels with parts of India where it's actually below replacement levels [1]

[1] http://qz.com/317518/finally-indias-population-growth-is-slo...
Ya, all of the 4 star ones basically include it in their ffi compatibility layers. The five star ones do too.
I take a picture of important documents,receipts, and tax info and upload them to the cloud. It saves time when I have to pull up a documents or do taxes later on. It beats having to sift through mountains of paper.

So to answer your question, a phone with a good camera and a unlimited data plan
The OpenBSD covert channel analysis team is understaffed at the moment.
Pretty good, but I've never had a problem with an XMLHttpRequest being inconsistent. Everything else seems spot-on though.
This was also a problem among the colonial militia camped outside Boston in 1775. It was difficult to solve because people don't like being told where to shit by officers they elected a few weeks ago.
Tickets just became available, actually: http://www.eventbrite.com/e/watch-the-skies-chicago-2-ticket...
What solves problem with null is if you can send messages to it, and have it do exactly what you want depending on the nature of message.
How about a bigger international bank like HSBC, get an account in your home country with them? Then use a local branch?
I just got a note in my inbox that tickets just became available: http://www.eventbrite.com/e/watch-the-skies-chicago-2-ticket...
So, how do I manipulate these grains? I created a gitweb repo and I'd like to rename it, etc. But how?
Many modern languages (Kotlin, Rust, Swift) handle this problem well.

Though I'm not sure if that problem is really that huge. Bad code will break in many ways. And breaking on nulls usually isn't that dangerous, data isn't corrupted and stack is safe.

There's another mistake of computer science in my opinion is inefficient array bounds checking and implicit integer overflow behavior. And those mistakes are more dangerous, they lead to data corruption and exploits.
We don't need to get rid of null, we need more, type-specific and context-carrying nulls: types need a way to signal various error states via an enumeration of instance constants that carry the error state in a type-compatible manner without some syntactically crappy mechanism like Maybe.

class Connection {

//Error instances
BAD_ADDR("The given address was not correct...")
...

}

These constants should throw, just like a null value would, but with the specific error-state message, and should be testable for both the general and specific cases.

Try/catch has its place, but the persistence of null-as-error-state behavior among programmers shows that signalling-via-return-value is a practical and intuitive way to handle error states. We should make that better, rather than simply tipping our nose at null.
You're fat and in denial too, aren't you? Can't accept facts.
In dynamically typed languages, there are still problems with flat Null/Nil/None that are addressed by optional values (the biggest comes when you use multiple operations that can return null but the single null value loses the source of the null; using optional values these often are differentiated easily as being either an "outer" null -- e.g., None -- or an "inner" null -- Some(None).)

In fact, the example in the article of the Ruby K/V store illustrates this problem. If optional values were used instead of an ambiguous nil for both cases, there would be two distinct results:

* Some(nil) -- or something of similar shape -- where there is a value for the key, and it is nil,

* nil where there is no value.

Obviously, the typesafety issue doesn't exist for dynamic languages, but the composability/API quality issues do -- from the numbered issues in the article, I'd say at least #s 2, 3, 4, and 7 apply to dynamic languages in general.
It's worth noting that having a NULL, somewhere, is not so much a problem as forcing types to have a NULL. In this respect, e.g. Python and Rust both get it right: while Python has a None, and Rust has std::ptr::null(), an object that is a string cannot be any of those, because those are different types (NoneType and raw pointer, respectively). C's problem is that a string could be null, and there's no syntax for a non-null string.

Python's problem, meanwhile, is that any parameter could be any type. In C, you can pass NULL to a function expecting a non-null string. In Python, you can also pass 42, [], or the sqlalchemy module. None isn't special here. :)

Also, to quibble a bit: Rust's std::ptr::null() is just a raw pointer, and isn't actually usable in safe Rust. Actual safe pointer types are guaranteed non-null and you'd use Option<&T> to specify that they're nullable. Raw pointers cannot be dereferenced in safe Rust. It is true that std::ptr::null() is in Rust's standard library, but Foreign.Ptr.nullPtr is in Haskell's, and the purpose is the same (a special raw-pointer type only used for FFI purposes), so Rust isn't any worse than Haskell here.
71 TiB DIY NAS Based on ZFS on Linux
> Its survey last year found that almost 90 percent of workers were either “not engaged” with or “actively disengaged” from their jobs.

Is this true? That seems like an very high number.
Tech company breaks ground, a drop of blood can now provide 200+ test results
Tesla Model X Prototype Uses Side View Camera in Place of Rear View Mirrors
C++ introduced non-null references. But they didn't enforce them. There are still "I'm so l33t I can use null references" people. The new move semantics use null references for things moved from. C++ is trying to do Rust-like borrow checking without a borrow checker. Errors result in de-referencing null and crashing.

Rust doesn't have null, but it has Option<T>, which is often syntactic sugar for null.

It's not that null is bad in itself. It's that having variables which might be null need to be distinguished from ones which can't be null.
If you click on the name of the grain at the top of your screen when it's open, it'll let you rename it!

And Gitweb itself should present you with some basic instructions on setting up a webkey to push code to it.
Initially I thought this was based on wmctrl[0] which is a nice piece of software. It allows you to do some fancy window manager scripting in bash, even when running GNOME Shell.

[0]: http://linux.die.net/man/1/wmctrl
You can pretend all you want, and sure if you force yourself to always use Option then many problems will go away. It still is a huge hole in your type checking and will still cause mistakes to occur.
What's needed is a successor written as a Wayland compositor and tools that communicate via a d-bus interface to instruct the compositor where to place the windows.

Poe's Law really has me here.
I think they're joking about the capitalization of the name.
It's way overkill probably but JIRA has a JQL language that allows you easily apply filters to your Kanban board which I use every day to know what to bring up in my standup. I just have a "recently updated" filter that looks at all user stories/bugs/sub tasks and shows them to me. Again JIRA is a heavy tool if all you want is "todo list" but it's the best product management tool I've come across and for < 10 users it's only $10/yr if you host it yourself.

It also has a number of agile features via the official "JIRA Agile" plugin.
A null pointer can be dereferenced into a "null reference" which can be passed around, however. Theoretically UB, in practice, typically represented identically to the null pointer and behaves the same when used. Still helps in that the null bug root cause can hide in less places (modulo memory overwriting which adds root causes unimaginable in Java)
> We don't need to get rid of null, we need more, type-specific and context-carrying nulls: types need a way to signal various error states via an enumeration of instance constants that carry the error state in a type-compatible manner without some syntactically crappy mechanism like Maybe.

Sounds like you want to go a step beyond Maybe to Either.
"Of course, if you want to use NIL as a character string or floating-point value, there is an exception. That's your fault: you needed a way to indicate "I don't have a string here" or "I don't have a number", and you bungled the logic."

And there's the rub: Just like NULL. And, in fact, that's the major problem with NULL. NIL is better than NULL, but not by much.
Review Social News Android App
XML is uppercase but Http is not. That seems to be inconsistent, though in some coding standards that's a correct naming scheme: acronyms with length less that 4 are named in uppercase (XML, URL) and acronyms with length >= 4 are named as Http. Another example is HttpURLConnection class from the standard Java library.
Though it's probably not the largest sub-discipline, there are (and have been for some time: http://www.wiley.com/WileyCDA/WileyTitle/productCd-063122919...) a fair number of philosophers who are very interested in computing and (as you guessed) simulation as a way to approach their research questions.
The Dark Age of Virtual Reality-Based Torture Is Approaching Fast
(1) It's true that a sentinel value like NULL can cut cycles.
That's low-level code though, and not high-level code. I'd suggest that most code is (should be high level).

(2) It is true that you may have uninitialized values. There are several ways to address it. Java will not allow you to use uninitialized local variables. C/C++ leaves the values of some uninitialized variables undefined. There are several possible approaches. Treating null as a normal thing is not a good approach, though.
Any labor with love is a privilege. Any labor without love is sacrifice. It's safe to say people are more than capable of being content with sacrifice. Foxconn workers protesting the enforcement of US labor restrictions is a good example. They're there to make a sacrifice, not live their lives.

In the west, resistance towards sacrifice is appears to be mounting. But what is work but an activity that generates value for which you receive a kickback? And there are plenty of activities that are lovable and that generate value. Hence, the movement towards lifestyle jobs and placing passion first is only natural. Entrepreneurs could hold the key here, because they have proven they're capable of generating those jobs, beginning with themselves.

“Choose a job you love, and you will never have to work a day in your life.”

― Confucius
Government officials in Amherst, VA can now require employers to fire ex-cons
Disagree. I really dislike that sentence stylistically. By the time the author got to the point, there was no way it could live up to that many words (that I mostly scanned, since they don't really add anything to the main point of the article).

The article is great, don't get me wrong, and I wouldn't have mentioned anything if you hadn't brought up this point, but I thought I would just provide a counter-point.
Clearly you've only started using it in the past few years... It was horrific and totally inconsistent across browsers and between versions about 8 years ago and earlier.
Assuming x is not a boolean, I think

not x

would be sufficient in the case of Python.
A computation substrate has state and can change its state within (feedback) loops. An elementary particle suffices this definition: It has state because its properties persist at least for some time, and it has feedback loops (interactions with other particles) that change its state. The more elementary particles locally affect each other, the more complex the state and feedback loops can be. What kinds of computation you can perform on such a substrate depends on the rules that govern the particles, in particular, how many feedback loops they allow to simultaneously affect a local arrangement of particles. It looks like there is an upper bound to this: No substrate can compute more kinds of functions than a Turing machine, which is a hypothesis that is closely tied to the conservation of energy and unitary (that the sum of the probabilities of all possible outcomes of a system equals 1). However, since matter decays, it is doubtful that anything around us can actually be as infinitely precise as the theoretical idea of the Turing machine.
Severine: you're hellbanned.
> If x is known to be a String, the type check succeeds; if x is known to be a Socket, the type check fails.

So the author is trying to explain what the null pointer exception is, but uses the concept of sockets in his example. I wonder, how many people know what a socket is but don't know what null pointer exception is?
Also I assume the recharge is pretty much instantaneous? Just re-fill it with hydrogen and you get another 7 days... That'd be pretty sweet
i seem to recall that some interfaces had been moved from udev to libsystemd, or something, recently.
> if (str == null || str == "")

Why not have null (and emptystring) eval to false? And

if not str:
str = 'wordup'
I accept your apology about being aggressive, especially since I may have been a bit too empathic myself (about work). The "lie" is about you saying that when work is done, people move on. I think the truth is that people say work is done so that they can move on, but work can never be done.

We do seem to agree on that point though, so I should probably retract your comment "lies". You're fine with people leaving 'projects' incomplete if they hate it...and I'm fine with that too. But work is indeed left incomplete, and that's why I made my comment.

If it makes you feel better, replace "employers" with "the open source community", and redefine pay to mean code/maintenance instead of money. I think my point still holds.
Which UAP are you using?
"Rust doesn't have null, but it has Option<T>, which is often syntactic sugar for null."

In a sense, yes. But you have to do something positive before you can pretend that nothing is something. And the call to unwrap can be annotated with an argument as for why it can never fail, or why it's unimportant if it panics, or even be outlawed by a style guide.

"It's not that null is bad in itself. It's that having variables which might be null need to be distinguished from ones which can't be null."

Amen, brother.
Are you upset that your wife is a fat liar?
Not completely. non-nullable by default is nice, ignoring possible nulls is nice, but Haskell's Maybe still suffers from premature generality by conflating all forms of absence. A 'Maybe T' is fundamentally, context-sensitively, not equivalent to any other 'Maybe T' in the same way all 'T's are. This is bad.

edit: carsongross beat me to what I'm talking about with a better explanation: https://news.ycombinator.com/item?id=10149129
> I have 1GB of LTE data, after I use it on my device or through tethering I get throttled to EDGE and tethering is disabled until the end of my billing cycle.

I'm fine with this. I don't like calling it unlimited if it's limited to your cell phone.
> And Gitweb itself should present you with some basic instructions on setting up a webkey to push code to it.

Yes, but the name of the repo itself has _RENAME_ME as its suffix and AFAICT there's no way to change it. It seems as if gitlab behaves this way too.

EDIT: ok embarassing mistake on my part, it's all clear now.