skysight-inc/HackerNews huggingface dataset:
I'm not sure what you mean "It gets coded as green". It doesn't consider an entire statement, it considers word choice.

Similarly, it says that green means that it's placed in the "writing tone" evaluation category, in that it tries to determine whether the writing comes across as analytical, confident or tentative. More like instructions or analysis and less like judgment or conversation.

It's better to look at the demo in a different way. I mean, if I put your post into the analyzer it tells me that it's impassioned, and of that it's not very cheerful. If I put mine in, it looks very matter of fact. It's more analytical and matter-of-fact.

The two posts imply that kind of difference in tone, and it's pretty cool to see.

It's got a way to go, but trying different examples is interesting.
I am not misinformed regarding Bootstrap; unfortunately I have extensive experience with it. :) Anyway, I should have remarked the fact that mixins do exist and semantic class names are totally possible with Bootstrap.

I was just pointing out the kind of mark-up which appears in the example I quoted and, typically, in Bootstrap-powered stuff. It's not a problem with the framework, of course, but - as you said - people abuse the pre-made classes. Regarding Bootstrap in particular, I think most people just import the compiled stylesheet (so, no mixins & other assorted goodies).
Why is there no demo website? No front-end framework should be without a component (listing each component) and a demo section. This is shoddily done compared to Google's material lite.
IO Monad Considered Harmful – In Code
> Sage uses a lot of memory (large matrices, plots, etc.), and the state must be maintained in memory during the course of the calculation.

1. I thought sage used a ton of RAM partly because of the huge amount of statically linked libraries. I see you said you're using fork to maximize shared memory. Have you tried KSM (Kernel Samepage Merging)?

2. Have you looked at zram? Certain matrices and such may be easily compressible.
I presume the the survey saw "very engaged" as always on at all times, which is rather misleading as I love my programming job but when encountering the many frustrating and complicated problems that come across my path I'll often reach for my phone and go on HN. But I wouldn't say I'm "not engaged." I suspect many here would feel the same.
I know from experience that I would rather run Cat5 than coax to the center of a room. :)
"In Python, you can also pass 42, [], or the sqlalchemy module. None isn't special here..."

...the interpreter's environment, my left elbow, the magic unicorn that lives under my steps,...
I'm still not entirely convinced that NULL is a problem. But how NULL (and pointer types in general) work in C leads to much, much greater problems.

Though, I think uninitialized variables or memory might be just as bad.
How a bug in VS2015 exposed my source code on GitHub and cost me $6,500
Since we're reasoning about a concrete case (abrinthebay's codebase): Wouldn't the amount of code-stripping benefit be directly proportional to how much unused code the codebase has?

It's possible in abrinthebay's scenario, they simply haven't crammed in so many Javascript libraries that the code-stripping can find 10-20% unused code.

(I'm also having a hard time avoiding calling "the code stripper yanks 10-20% of my code" an indicator that one's choice of libraries is wastefully large, but that's a separate thread of debate).
I agree that there is convenience to the execution controls VMs provide. But if you can't repeatably and easily stand up a replacement/duplicates of a system from configuration management and backups, then you don't actually have configuration management or backups.
Not just the Chinese, it's very popular in the US as well. Whole Foods et al carry it.
But have you used one? Spec and usability are not the same thing. I have one of the high end Asus routers and several Airport Extremes. I think you know where this is going.. I'm using the AirPort Extreme right now. Dead simple to set up bridges, everything works, no need to do any overclocking to get enough power to penetrate my 17th century stone walls. If the iPhone taught us anything it's that specs matter far less than user experience. Of course there are probably still guys hacking away on Windows XP that would disagree of course.
in Python (even for non-Booleans)

not x

is not equivalent to "X is not None", since empty lists, zero, etc., are not truthy in a Boolean context.
Reflows and repaints: CSS performance making your JavaScript slow? (2009)
My son recently had to make some allergy tests, they took him 3 vials of blood... Wish we had the tech already :S
One of the problem's Maybe still has is in the deeper question of "why are you expecting None to be here?". Don't get me wrong, there are valid cases for this, and Maybe is certainly preferable to null across the board, but I think the movement to Maybe in the greater programming space will in many cases practically result in trading one set of explicit errors (crashes) for (a more subtle?) set of errors (behavioral). In particular, this style of programming will become frequent (from Swift documentation):

if let roomCount = john.residence?.numberOfRooms {
println("John's residence has \(roomCount) room(s).")
} else {
println("Unable to retrieve the number of rooms.")
}

Or from this blog post's own example:

option.ifPresent(x -> System.out.println(x));

In other words, I think the core problem still hasn't been attacked and we may end up in the same situation we were in with exceptions originally: programmers will just throw up their hands and wrap everything in a Maybe/Optional and/or just maybe-protect until the compiler stops bugging them. At the end of the day, if you ? all your values then you end up with something equivalent to having everything be nullable and correctly null-checking them.

Obj-C had a form of this with nil calling of methods silently doing nothing (so you end up with methods that "conveniently" don't happen, and don't crash! when the receiver is nil). However, despite having lots of legitimate uses (don't bother checking your delegate exists), it can still very silently sneak in to other parts of the code.
>NULL is a terrible design flaw, one that continues to cause constant, immeasurable pain

Exaggeration much? Certainly not "the worst mistake of computer science". IPv4 is much worse, just for one example. NULL isn't even visible to end-users, many mistakes in CS are quite visible and really impact non-programmers' lives. NULL is just the color of the wallpaper in the engine room.
https://support.google.com/onhub/answer/6279845?hl=en

DNS Settings
While OnHub doesn’t track the websites you visit, your DNS provider can associate your web traffic with your public IP address. OnHub sets your default DNS provider to Google Public DNS. (This can be changed in the Advanced Networking settings of the Google On app.) Google does not associate Google Public DNS information with your Google Account. Learn more about Google Public DNS.

We are constantly working on new features and controls that help you get more out of your OnHub. It’s possible that, in order to implement these new features, we may need to change the way it collects, stores, and uses data.

Jump over to Google DNS https://developers.google.com/speed/public-dns/privacy

For what they keep permanently. (Network AS and requested DNS Site, with my home business account, that is enough to uniquely identify my houses traffic)
This is quite a bit more expensive than agencies I've worked with in the past, and those typically involve a translator + proofreader who are at least somewhat knowledgeable about the topic being translated, so the quality is pretty good.

I suppose some people will be happy to pay a premium for a quick turn around, but personally I care about the quality much more than the delivery time.
You're referring to the copy/pastable commands for setting up git, right? You can actually replace the _RENAME_ME thing (and the randomly-generated text before it) with whatever you want when you enter the command. The instructions could certainly use some work, though.
As a mathematician I still think making "-1 % 7 == 6 % 7" evaluate to false is worse.
If you have a language with enum types (Haskell, ML, etc., or any of the languages inspired by them like Rust, Scala, etc.), that's straightforward. In e.g. Rust, you'd have

enum Connection {
ValidConnection {fd: RawFd, address: SockAddr, ...},
BadAddr,
BadPort,
...
}

In fact Rust's representation of the maybe type is just a generic

enum Option<T> {
Some(T),
None,
}

so all you're doing is getting rid of the two layer Option<Connection> syntax and making it a single Connection, so you're not writing Option<this>, PossiblyBadAddress<that>, etc. everywhere.

Then all your call sites can do one of two things. Either they can check for specific errors, like

match conn {
Connection {fd, address, ..} => write(fd, ...),
BadAddr => /* handle error */,
BadPort => /* handle error */,
}

or you can write a simple function that throws an exception, if you really want an exception-handling style:

impl Connection {
fn get_fd(&self) -> RawFd {
match *self {
ValidConnection {fd, ..} => fd,
BadAddr => panic!("The given address was not correct"),
BadPort => panic!("The given port was not correct"),
}
}
}

and then call conn.get_fd(). For a simple command-line app, panicking and aborting is pretty much what you'd want to do anyway. For a test suite, panics are caught per test case (and you can even test that a function does panic with a given message), so it's very testable.
I would rather have my LAN stay up while my router is rebooting than save a slot on a power strip. Perhaps I am in a minority.
Turning breath into words: new device unveiled to give paralysis victims a voice
Nothing short of unticking the box you mean: http://imgur.com/If9Oazj

The amount of bad faith people ascribe to basic usability functions utterly astounds me.
> Not allowing humans to wander amongst ideas on their own uninterruptedly and make their own connections have created shallow and empty workers.

Huh, is that not exactly what Y is about?

As for turning everything social, welcome to the modern work environment. If you can do social you are out of a job, as the non-social jobs have been automated away.
This is similar to what Lewis Mumford has said in Technics and Civilization. Basically, more abundance means everything gets cheaper. Unfortunately the wealth created is locked up within a few classes and barely trickles down. Like the farmer who only produces cash crops and has no food to feed their family or the shoe maker whose children have no shoes. Mumford suggests that with such abundance we need "basic" communism which goes further than a guaranteed basic income. People will still have an incentive to work but they'll be spared the starvation and homelessness.

It's hard to get used to an abundance mindset but we're definitely at that point where we absolutely must. It's like pre-AWS and post-AWS: in the former we have to worry about provisioning more hardware and virtual machines and worrying about running out of space (I'm in that situation now where we have a private cloud and maybe 2 more VMs can be spun up and that's it). In the latter situation we would be able to provision as many VMs as needed. Sure your costs increase because you went overboard and provisioned one too many VMs but at least you got to worry about over-abundance rather than scarcity!
Yeah I didn't mean it as a dig when I mentioned the spreading of the Office brand. I will finally be able to build an app that doesn't linger in default Bootstrap styling forever :)
"Müller frequently travels late at night, although she tries to sleep at the apartments of relatives or friends. Often, she is accommodated by her boyfriend, her mother or grandmother."

So she isn't really living on the train.
Ugly. Not intuitive unless you are an expert. I wouldn't expect someone's grandmother to be success using it; constraining that with the airport setup that is super simple.
I know an M.D. who travelled to Germany to get a medical implant (for himself) that's not yet approved in the U.S., even though it meant paying $90K out of pocket.
NAKED GUY DANCES IN 7-11
Came here to say this. In fact, I think every language that they give 5 stars to has some form of "foreign pointer", "raw pointer", "unsafe pointer" or the like that is nullable, for FFI and other low level tasks.

I think that anything which has no null in normal, idiomatic code, outside of "unsafe", "ffi", or similar subsets, should get 5 stars. The distinction is really about whether you need to worry about any possible value, or any possible reference, being null, which you do in languages like C or Java where all references are nullable.

Giving Java and Rust the same 4 star rating because they both have some form of null and some form of Maybe/Option is a bit misleading. In Rust, Option is what you use in any normal code, and so you don't need to check for Null everywhere. In Java, it's the other way around; nullable references have existed since the beginning and are not segregated in any particular way, while Optional is a recent addition.

Likewise, I think that in Scala and Swift, null is only present for compatibility purposes, and idiomatic code does not use them. I'm not sure about F#. Clojure does use nil idiomatically, and also has '(), which may even count as "multiple NULLs" according to this rubric, though I guess that in Clojure '() is just treated as an empty list, rather than a null value like it is in other Lisps.
Similarly Norway is heading increasingly towards X (longer days, more testing, etc etc etc) and things have largely become a mess.
Ok, yeah, you're right -- I forgot those other cases. Thanks for the clarification.
It's not a huge hole and not such a big deal. Just don't design APIs to use null. I've done it, and I can tell, you, it works! (But to be fair, I haven't worked on database-backed software in half a decade.) When mistakes do occur they're the trivial kind where you get a stack trace and can work it out.

It's wrong to call null pointers a billion dollar mistake, too -- if we didn't have null (and in the absence of generics that permit Option, as things were long ago), programmers would end up using in-band sentinel values instead. That would be a much worse mistake.
Your customers need to be able to trust the quality of the translation because almost by definition they are not in a position to judge it themselves.
Have you not tried the AirPort Extreme? Why suffer through something you don't like when there is already a better option.
Author here. I didn't know that about Haskell.

Admittedly, the "rating" is pretty rough, maybe even a bad idea.

I've seen std::ptr::null more than I ever have Foreign.Ptr.nullPtr.

But really, both are usually used for compatibility with external libraries/programs/runtimes, not for idiomatic language programming.

Both great languages in my book :)
Yes...the title is mislabeled. It should be something more like "How a criminal got together with friends at BoE".
Haskell has `undefined` bombs, which are a similar problem.
> 4. NULL makes poor APIs

Then don't use it. The example given is a bad design. No phone number and not in cache should not return the same value. That bad design has nothing to do with nil, Return '' for no phonenumber.
When you need to distinguish missing values, that's why Haskell has Either. Maybe is for when you only care if there is a good result are not, Either covers the case when you need to distinguish different kinds of "not".
Yeah. That's what I was going for ;)
You have a ton of type safety in Python, which is one reason why Python programmers are cranking out large bodies of working code representing all kinds of applications that Just Work.

"No type safety at all" means you can misuse a value of one type using an operation that is appropriate for a different type, and some nonsensical behavior silently occurs (or perhaps some nonportable behavior that you sneakily intended). This characterizes assembly languages, certain machine-oriented languages like BCPL, and some immature dynamically typed languages which omit run-time-type checks (the type information is there, but not checked, so that string_length happily tries to operate on an integer, so that a type problem occurs in the interpreter's kernel itself.)
Introducing Common Parts Library for Prototyping
The Sorry State of Copy-On-Write File Systems
You shouldn't have to specify the error states in each method, this is why what I'm advocating is different than a simple enum:

- You don't need to define a constructor to take the error string

- You don't need to implement method dispatch (all methods of an error state instance automatically throw, like null does)

Enums are close, but not quite right.
As an outsider, here is my perspective on a number of things you could do:

Segment your users into plans. Do some user research on the archetypes and Jobs To Be Done that different people are using your product for. Segment features according to this and charge accordingly. For example all of the high availability, redundant web servers and snapshotting should go only on the paid plans. You can make the reasonable assumption that if people aren't paying for your service then they don't value their data very highly, so why should you? Some rough plans I can imagine would be: Undergraduate, Graduate, Professor. These people have different needs, desires, and fears; cater to them.

This might be a hard one, but dropping the free plan will make you cashflow positive immediately. For people who can't/won't pay, you can provide good instructions on how to set up the VM if people don't want to pay. Give people 30 days notice, and give them benefits for signing up, e.g. 20% discount for life of their account.

Look at partnering with teaching institutions that are using your software. Offer them a discount on a class purchase of accounts, or sell them support running the VM on their own infrastructure (perhaps integrating with Moodle or their auth system for an additional fee?).

Look at how people get value from SMC, your costs scale linearly with usage, so it may be good to scale your prices too. One option could be to replace the free tier with a pay-as-you-go tier where people pre-pay for x hours/month, and higher tiers get unlimited usage.

On the homepage, remove the section about grants received as it sounds like that is no longer the case.

Make the homepage a lot nicer and present the benefits of SMC much more clearly.

As others have said, it's not clear at all what plans are available or what differentiates them until you put in a payment card. This is not a compelling prospect.
I also think that Go did pretty well to fix NULL. It didn't get rid of it completely, but it (nil) is only valid for pointers and interfaces, so it's not possible to use it in place of a string, integer, etc. It's not as bulletproof as Rust or Haskell, but something as simple as disallowing nil strings can make a world of difference.
Yeah, I think that's a reasonable model where it will make sense since the client/backend can actually be more or less identical, since they'd both just be consuming REST.

But that's a pretty painful way to start a project as well. /shrug
Yes, it's a classic case of premature optimization.

* As you mentioned, you get most of the benefits from gzip compression.
* You pay a major debugging penalty for having your code minified, since it's much harder to figure out what happened with minified code.
* After the first request your code is going to be cached locally, anyway, so we're only talking about the initial request.
* Using a CDN for your libraries will buy you much more. It's not 100% relevant, but if you're worried about download speed, this is one thing that does make sense.
Django JET new fresh looking Django Admin interface with improved functionality
Sorry, no. You can only pass a stable, property typed Python representation of your left elbow, or the magic unicorn, not the elbow or unicorn itself.
I read VM in the title. Very disappointed.
You make a good point. I removed the mention of std::ptr::null, since it really isn't really a NULL like other languages. Like you said, it's for FFI.
"You are the WM" until you automate everything with scripts as the author seems to have done (because, why wouldn't you automate?). Then it's "You just wrote your own WM, in bash."

I'm tempted to try this because it's just so UNIXy, but I probably have "better" ("important" and less fun) things to spend time on.
I think the other side of that argument is why the capital gets locked up in the first place? I can't imagine someone like Steve Jobs or Warren Buffett actually wanting to keep people from resources or excess wealth if they had no use for it. Especially if it was just idling there doing nothing for anyone (themselves included). It just seems like that our situation is one born out of the interplay between institutions that have long since lost significance like a vestigial organ that only exists because the evolutionary cost to 'remove' it is greater than it is to keep it. But in this case, I think we can overcome these institutions it's just a matter of how.
Well the article doesn't talk about performance, but at least for the double-maybe in the store example, there is one level of extra indirection in the machine code: return pointer to maybe, then return pointer from string from it.

If you care about performance, you really need two predicate values to cover this case. You could have (void * )0 for no entry, and (void * )1 for entry exists, but is blank.
>noticeable health risks

There might also be a continuum and people living in freefall need to exercise 9 hours a day to live long term, but on Ceres its only 3 hours a day, so there's an interesting economic labor argument WRT 6 saved labor hours per day, or whatever the numbers work out to.
Check this out for frontend in python: https://github.com/zoofIO/flexx
I chuckled when he installed MySQL just to dump the files to CSV to put it in PostgreSQL.
Here's part of google homepage js thrown at it (In reality tossed a whole file, but pastebin wont fit it all for free). It's still entirely unreadable.

http://pastebin.com/VvEGZ8a3

If it can infer most of it from OSS? Sure. But big web apps do a lot more.
It also doesn't mean it's not malicious. Google doesn't have the best track record on privacy. Spend some time on their advertising platforms and you can see just how deep they go. Full text email scanning with the ability to advertise to people not just in the content of their emails, but based on the content of their recipient's emails. They've cooperated on frequent occasions with warrant-less surveillance requests. Google makes some nice products but they have long since jumped the Don't be Evil shark. They don't make all of these "free" web products for nothing. It's all around one singular purpose: to gather information that they can sell about you. No matter how people want to frame it, Google is an advertising company. Buying a router from an advertising company.. Have fun with that. What is the motivation for Google to suddenly care about routers? Is that really a pain point that's profitable to solve? Not really, unless you have a long term plan to leverage that into something that serves the core business which is advertising.
I use SendGrid.

https://sendgrid.com/
I did too and I've read this post before...
I remember having to do this with AS2 systems, short variable names were faster.
As opposed to made up non copyrighted names? What kind of silliness is that statement?
Agreed. However, Apple has a nasty habit of disabling features (such as power settings) and making the control software less and less friendly. I love my Airport Extreme it's software doesn't do everything that the OnHub software does. Some things I would really like is the ability to quickly see who/what is connected to my network, some history of connections, and even a way to tune QOS for specific devices (i.e. my Roku boxes should have more bandwidth than my phone).