skysight-inc/HackerNews huggingface dataset:
Ultimately it all comes to cybernetics. Understanding how systems work, understanding how to change systems, and how to design new systems.

Not about programming itself.

We were designing systems for millennia before computers existed. All the basic algorithms we use in programming today were invented before computers.

Computers just happen to make systems a lot more reliable, performant and scalable (if designed right), since computers have evolved to complement us (i.e. we're bad at what computers are good at and vice versa).

I don't think programming is the new literacy, I think understanding the common principles that tie system behavior together has always been the highest form of skill for any human to possess.

As for turning a system design into code, if you know how to design the system on a higher level, you can always delegate the "boring" act of coding itself.

I'm a programmer, but I understand that the act of programming by itself, even though I find it enjoyable, isn't that interesting on its own. It's only interesting in terms of how the program I'm writing connects to a system where the real world and real people are involved. All programs, with no exception, either interface directly with people, or interface with other programs that do interface with people.

Currently we conflate programming with the act of designing systems (algorithms, design patterns etc.), but I expect sooner or later system design and programming will split into separate "trades". Would it be a resurgence of cybernetics, or a brand new branch of science, I don't know.

But it'll happen. And it'll be good, because many programmers use computers as their golden hammer of system design, and it's hardly the only component of a good system.
Systemd's supporters might as well be devil-worshipping baby eaters, but that's not any argument for or against systemd as such, that's simply irrelevant.
I believe the reason for this strange color scheme is the lack of a revision control system. Back in the dark ages of programming, we didn’t use them. We edited files on disk, and that was that. In that environment, a deletion is dangerous. If you decide you want it again after you delete it, well, that’s tough.

I don't think this explanation makes any sense. What was this person from the dark ages diffing against? Presumably, something on disk (i.e. something whose contents are recoverable).
Legal pot in the US is crippling Mexican cartels
As essential as computational literacy has become, I feel a bit uneasy here.

Take mathematics for instance. What students learn in school is important, yes, but it causes a hatred toward math in general. In a typical high school, 90% of kids dread Algebra, Geometry, and PreCalc. These classes are miserable to them, and consequentially, they associate mathematics with their aversion from imposed education. Because of this, the wonderful world of numbers is reduced to mere repetition.

For those who appreciate the beauty in mathematics, this must be depressing.

I'm afraid that CS may have a similar downfall if we mandate programming curricula. Maybe a more subtle approach is necessary.
Oracle is used extremely widely in the US. For example, many US government agencies use it. Many companies use it.

I suspect its use has not grown as rapidly as other technologies.
I'm pretty sure I learned that convention. Why would it be intuitive? What's the association between red/remove and green/add?
Show HN: Wikipedia article page redesign (unsolicited)
Disagree. What we call coding today will have virtually nothing in common with what they call coding, if they do at all, at the end of the 21st century.

Just look at tools like Parse or Visual Studio Code Search. The future is going to be very, very different from the present.
What's so scary about smart girls?
North Georgia mom found guilty in Facebook photo case
rawdog/2.19 from the "Unknown" category is an RSS aggregator [1] that should hopefully get fixed with the mentioned python update...

[1] http://offog.org/code/rawdog/
I wonder if it would actually be legal for a phone company to implement a spam filtering service the way an email company can. Phones services are a much more regulated industry than email is.
One of the main rants in this is about superfluous comments. I completely agree that comments which are superfluous should be removed. However all his examples are JavaDoc. Yes, in the code they are useless because of the variable declarations, however they are of great use in an IDE.
I disagree about insertions and deletions. The primary purpose of colors should be to communicate more information without us having to think about. Having standard color schemes is really helpful. If every service uses different insertion/deletion colors, that's just more headache for us.

Additionally, to me, red deletion doesn't mean "this was a bad action". It means "this was bad code, so we're crossing it out". Semantically, that makes total sense to me. Red is bad old code, green is new good code. Seeing a lot of red in code means the same to me as seeing a lot of red on a marked up copy of an essay (as long as it wasn't a professor who marked it up) -- I've identified a lot of improvements to make.
I have found this also few minutes ago http://db-engines.com/en/ranking
Top Important Tips Know-Hows About YOGA
Go for Sysadmins [Gophercon]
True, supported by GCC, Clang and Visual Studio and probably other compilers ...
The main source of ideological disagreement between pro-systemd and anti-systemd users is just how much an init should handle. Anti-systemd side insists on init being just an init and not exceeding its duties, whereas pro-systemd are willing to make the init handle various other functions, due to the alleged benefits.

I think at this point it's erroneous to call systemd an "init system," it's far more than that and Lennart himself freely admits it in (ironically) the article meant to dispel systemd myths (http://0pointer.de/blog/projects/the-biggest-myths.html):

Well, systemd certainly covers more ground that it used to. It's not just an init system anymore, but the basic userspace building block to build an OS from, but we carefully make sure to keep most of the features optional. You can turn a lot off at compile time, and even more at runtime. Thus you can choose freely how much feature creeping you want.

I'm not entirely sure about how optional the whole package really is. I know for a fact LXC tools like systemd-nspawn, Python bindings, etc. can be removed from the build using ./configure, but I don't know the full extent to judge the veracity of his claims.

Olav Vitters of GNOME and Debian (I believe?) later echoes the same sentiment in a somewhat self-contradictory manner: http://lwn.net/Articles/575790/

Systemd is meant to do one thing and do it well: be the basic building block for Linux.

Of course, one must first define what a "basic building block for Linux" is, although that isn't really elaborated.

Personally, I don't have any strong opinions in favor of or against systemd, but I do feel it was introduced in a rather rushed manner. I think it would have payed off better for the community if people researched certain alternate init schemes that were already present before systemd (not talking about launchd/Upstart), such as Richard Lightman's depinit: https://web.archive.org/web/20050206182736/http://www.nezumi...

However, it's probably a bit late by now, since systemd's place has been set in stone, for better or for worse.
The Complicator's Gloves (2007)
I think this may be correct. Personally I always wanted the syntax highlighter to highlight only function calls and object method calls.. ex: .Trim() would get highlighted in mystr.Trim()

It also annoys me endlessly that words like 'var' and 'def' and 'function' get the brighest highlight, i know its a variable, it has a name, and i put it there.
The comment talk I can get behind. However, the change from red/green to blue/yellow for file change is non-intuitive, and I hope to never see it.
well, of course they can be buggy, they are written by humans, after all :)

but in my time as a programmer, i think i've seen one bug that was a genuine compiler bug. and this was in floating point arithmetic optimisations.

llvm/clang, well, i'd hazard to call them mature (even though apple insists on doing so).
"Pot farmers in the Sinaloa region have stopped planting due to a massive drop in wholesale prices, from $100 per kilo down to only $25. One farmer is quoted as saying: 'It's not worth it anymore. I wish the Americans would stop with this legalization.'"
More Counterfeit Apple Chargers Than You Can Shake An iPod At
Aw, I was hoping article was going to be about the highlighter's grammar rather than its colors. Perhaps there exists a system other than, "colorize keywords and comments". Or maybe build color into the language itself, as done by colorForth.
The color red is often associated with bad; needs to stop; wrong. Removal isn't such a big step from there, I think. The opposite probably applies to green.
I think that pretty much everywhere green==positive and red==negative.
Who can hold his breath for ten minutes!
24 (S09E01) Hacking and Hijacking a Drone – Can it be done?
Google’s part addressed in Apple-Samsung case
well, i'd only consider that a bug if java defines that integers will use at least as many bits as needed to store their value.

i'd guess this is not the case (but i don't know for sure)
iBeacons is bluetooth though (you interact with them via the core bluetooth framework)... FireChat does apparently also use wifi though since they use the multipeer connectivity API.
I don't buy that. Most programmers have learned that, in a diff, red = deletion and green = insertion. But I'm not sure that is "intuitive" as much as "learned behavior".
Why Comcast’s $10 a month Internet isn’t all it’s cracked up to be
I think the author is overthinking it in the second section: we're not discouraging deleting code by marking it red. We're simply denoting that it was removed, or killed off (he drew the connection of red to blood, and green to new life).

However I don't understand why diff views abandon syntax highlighting. I understand there's sometimes a challenge of breaking up highlighting that depends on syntax that spans multiple lines, but it seems like we could do better than marking entire lines bright red and green and leaving the text black. This is the biggest thing that confuses me about Github - they've left it like this for years and it's probably the most looked-at part of their site.
Anti-surveillance mask enables you to pass as someone else
There should be a nonacademic track in math education, starting around 8,9, or 10th grade.

It would focus on things like demystifying probability and balancing check books and other things that sort of fall under numeracy.

I realize lots of people will like to complain that those aren't topics for school, but the current program in the U.S. is anyway watering down the academic track. People that have not yet seen any beauty in math would get much more value from practical lessons designed to mostly be engaging than they get from suffering through abstract math that is mostly designed to be foundational.
As I read this, if the compiler determines that (with the #define set) the file is effectively empty, it knows it can just check the #define next time rather than re-reading. Without this optimization, you get the same result slower. It doesn't depend on well-behaved anything to get a result just as correct as without the optimization.

With the single possible exception of a file that changes on disk between the multiple includes in the same build step. That is not a situation I have ever encountered and I am not at all sure it is supported and there aren't a bazillion other things that would break it in any given compiler chain (certainly at least line directives would be wrong, but that's arguably minor I guess).
I find it somewhat surprising that these studies focus so much on vocabulary. Syntax seems to be much more stable over time.

All languages have so many "loan words" (do they ever give them back?) and borrowing words happens so quickly that I find it impossible to model this over millennia. Surely, we're dealing with a more general graph here, not with a simple tree.
> == Unknown
> Not sure about these. shrug
> - Gregarius/0.6.0 (+http://devlog.gregarius.net/docs/ua)

This is from Gregarius - my long favorite RSS/Atom aggregator, written in PHP: http://sourceforge.net/projects/gregarius/ (a bit dead nowadays... I'll have to migrate to day)
> his office is plastered with Japanese art, certainly compounds his image as a wannabe Mongol warlord

Japanese art to Mongol warlord! What a conclusion!!! This makes as much sense as saying he has an Eiffel Tower poster so he'd like to live in Greece.
So basically the #include granularity is extremely coarse, because otherwise it is unmanageable.

I think it is nicer to have quite specific #include's:

#include <stdbool.h>
#include <stdarg.h>
#include "hash_table.h"

Because it:

* Gives a list of dependencies at a glance

* Along with preprocessor optimizations to avoid reparsing protected headers, it can actually parse fewer headers in each compilation (reversing the performance argument by Rob)

* Can aid with greps for where modules are used

The comparison is really a strawman -- and the length of the GNU one and its many dependencies relate more to feature creep than to the #include issue here.

At least with GNU's #includes, I can see that it depends on the various stuff it needs for its feature creep.
Since I'm sitting here with a voltmeter next to me, I'll point out that red==positive and black==negative.

The bigger point I'd like to make is that any talk of universal connotations of colors is probably wrong unless you've really studied it carefully.

For some history on why red means stop and green means go, see Straight Dope: http://www.straightdope.com/columns/read/437/who-decided-red...
Apparently it dates back to early railroads, where red meant stop, green meant caution, and white meant go. They discovered this wasn't failsafe when the red filter fell out, the train saw a white light and crashed. So they moved to green for go.
My high school had such classes; is this not standard?
R and Python aren't "hip" like Haskell, Clojure, and Julia. There is no buzz, they are old news.
about comments being washed out: in the quest of writing good source code for kids (easy for kids to read, adapt and use) I found that comments should be not only an integral part of the source, but probably not highlighted as a single block, with an uniform color. For kids and beginners, we should have a highlighter for comments that bold words between *, that put some emphasis on titles in comments, that makes function/variable names in comments jump out. Also, we could highlight inline comments (at the end of a line of code, generally frowned upon but potentially useful for beginners and kids) as yellow stickies.
An individualised test that advises you to steer clear of a company because you're way less deferential to management than their typical successful hire, or provides helpful hints that they're much more laissez faire than your previous employers is potentially a lot more useful than a review site (which like any review site can easily be abused by astroturfers or ex-employees fired for good reason).
Thanks! Respect you for using your routine account and giving a reason.

I personally rarely use down-votes, and would just ignore a comment, if I sense that its written in an earnest way, even though bad in quality. I agree its not very high quality writing. But I believe, that it does hit its mark with many people. Many more people upvoted it, than those that down voted it.
Looks great! I love instant search weekend projects!
One thing i learn is also to disable keystrokes that do not change the search query; and you might want to do the same too.
Perhaps do not execute the search, if keys like 'ctrl', 'alt', 'commamnd', etc is hit.
If list.h has no include guard, it gets included with or without this optimization. If it has an include guard and you #undef it, then it gets included again with or without this optimization. If you it has an include guard and you do not #undef it, it does not get included again, with or without this optimization.

In no case does this optimization change the code emitted.
> Who by the way must also be the voters?

I am assuming this was a question and not a passive aggressive taunt. The answer is "No, it is not the case that being on a jury is proof that the juror has voted in an election." Many states use voter registration rolls as an input to the jury duty selection process but I can not find any that screen potential jurors based on actually participating in an election. Furthermore voter registration is not the only way that a citizen can end up being called for jury duty; states often use other DBs eg DMV, Hunting/Fishing licenses, etc for jury duty.
It looks like browsers basically all support SNI now, but unfortunately it also looks like that if you require SNI, you'll be giving up traffic from a fair number of RSS readers and search engine spiders, which makes this a non-starter for me. I'm surprised the author is OK giving up those 263 NewsBlur subscribers. I hope these RSS readers and spiders get fixed soon.

I don't think there's a point trying to send back an error document to clients that don't support SNI, since the client will get a certificate error before seeing any error that you send it. On the other hand, the clients that don't support SNI also look like just the type of clients that don't properly check certificates. If that's true, you're better off winging it without SSLStrictSNIVHostCheck and hoping that these old clients will ignore the certificate error and then be routed to the correct vhost anyways via the Host: header.
Water Discus underwater hotel by Deep Ocean Technology
Wow, you created an account on the fly just to post this needlessly hostile retort?
Pathlib – Object-oriented filesystem paths
The Texas limit on non-economic damages is still $250k. It is not adjusted for inflation [1]. It's only the limit on total damages in a wrongful death suit that is indexed for inflation. Punitive damages are limited to $200k or twice the total of economic and non-economic damages up to a max of $750k. These also are not indexed. Here is what Texas defines as non-economic damages [2]:

"(12) "Noneconomic damages" means damages awarded for the purpose of compensating a claimant for physical pain and suffering, mental or emotional pain or anguish, loss of consortium, disfigurement, physical impairment, loss of companionship and society, inconvenience, loss of enjoyment of life, injury to reputation, and all other nonpecuniary losses of any kind other than exemplary damages."

[1] http://www.legalmatch.com/law-library/article/texass-cap-for...

[2] http://www.statutes.legis.state.tx.us/Docs/CP/htm/CP.41.htm
I wish for a standard #once directive. It should be very simple to implement, increase preprocessing speed and reduce the size of visually disturbing boilerplate in header files.
I say hurrah! There is an awful little dance you can do to make SNI work in 2.7 with requests but it is way too complicated for most deployments:

https://github.com/kennethreitz/requests/blob/master/request...

I've actually done this once. Took all day.
Why Bitcoin’s Greatest Asset is its Community
Typing on an ideapad Y510p - its an excellent machine. I know that phones and tablets have the seat at the head table right now, but I can't imagine not having a laptop sitting on the kitchen table. Others seem to be dropping that ball ... or at least racing to the bottom. Lenovo laptops always seem a smart choice.
This. Some VPS providers don't care at all about downtime since the services are so cheap. Then, scaling that cheap service to hundreds of dollars a month for more resources doesn't necessarily guarantee any increase in quality... maybe just an increase in attention if you make a fuss
In the field of genetics-- and specifically for copy number variation (i.e., big chunks of genome deleted or inserted)-- the red/green contrast was deemed inaccessible to color-blind individuals, and so a new red/blue scheme was implemented as a consensus scheme.

red - deletion of genetic sequence
blue - insertion of genetic sequence

1: https://www.iscaconsortium.org/index.php/the-news/95-the-mea...
It consists of multiple daemons which are relied on by userland applications, are so strongly interdependent that the systemd developers don't support running them independently, and which have no stable or documented APIs between the different components. Oh, and many of them are infeasable to re-implement according to said developers.

Now, the Gnome developers may argue that technically Gnome doesn't require logind, and technically they're right. You lose the ability to shutdown, restart, sleep or hibernate your PC from the Gnome user interface - all things that worked before and that normal users expect to be able to do - but you can technically run without it. The API for those things isn't itself terribly complicated, but because the systemd and Gnome developers don't give a fuck about anything other than systemd they've bundled it together with a whole bunch of complicated, poorly-documented multiseat stuff that can only be implemented as one single, monolithic all-or-nothing API.

Which is, I think, part of the reason why Ubuntu gave up and is switching to systemd; they can hardly ship something that requires users to use the command line to shutdown or suspend their PC.

Edit: Also, the bit about how "we specifically approved some patches to allow Canonical to run logind without systemd" is... well, outdated is probably the politest way to put it. Since then the systemd developers have announced that they're breaking the ability to run logind seperately in future, they never supported it in the first place, and Ubuntu should never have done it.
"You (presumably) and I have beaten ourselves into submission to the Linux style; the authors' haven't."

An awakening!

Is it really so terrible to have things compile quickly and without the usual ./configure nonsense? It seems there are an infinite number of ways an author can organise her project using ./configure; for every one I have to spend time figuring out what they have done.

One of my favourite aspects of djb's build approach (which is what is being used here) is that it's easier (than with the popular build systems) to change compiler and linker options and make static binaries: in most cases, simple edit the conf-* files. Thankfully, authors who use djb's approach usually do not vary much from the model. This means less time spent figuring out how things are organised.

I like (portable) open source software that compiles quickly and cleanly.

djb has continued to deliver on this point.

Nice to see someone discovering this build system for the first time.
For the same reason why it is important to know who owns the house you are are living in or the company for who you work. Or the company who runs a factory across town.

It is a question of accountability and also stability.

When you start a business on a domain and you rely on that domain it is important to know that this domain is well maintained. What if the company is giving your domain to someone else. And you can't do anything about it because the company is gone.

Top level domains are a key to the infrastructure of the internet, there should be transparency and accountability. Otherwise this market will fail.
All Moms ‘Work’ From Home
It’s Mother’s Day – a day to step back and appreciate the amazing women who gave birth to us. Motherhood is no easy task, and for the modern mom, it’s not the only one they juggle. As a top destination for freelancers, Fourerr wanted to know what moms think about the working from home movement. To get an idea, we asked the Internet’s top mom bloggers to share their thoughts on working from home. The responses we got are thought-provoking, amazing – and, inspiring.