skysight-inc/HackerNews huggingface dataset:
Well, I'm an anarcho-capitalist. And I advocate no government intervention, in everything.

When I use the term "socalism" or "socialist" while discussing a political topic, it doesn't mean I'm comparing it to, or saying it is Socialism. To me, like I would assume most other anarcho-capitalists and libertarians, socialism isn't a binary. It's a grey-scale towards socialism. So, while most would not say that public schooling or a social safety-net are "socialist" or meaning we have "Socialism", the anarcho-capitalists and libertarians would just be implying that this is one of the many things on the way to socialism.

Perhaps we're wrong, and these extras and government-projects, etc won't lead to a full socialist form of government. But every single time one of those things is enacted, it's a step in the direction of a less free society. A step in less voluntary and peaceful ways of solving problems. We say peaceful and voluntary because by our definition, government is neither of those (but that's a whole long discussion just by itself).

*edit: missing word.
Show HN: Common Stash – Simple bookmark manager
> He's running a Debian prerelease with an unsupported filesystem

I'd say he was dogfooding, given that he's a Debian developer.

(Edit: fix typo)
any response form Github Inc ? i don't see any official word
Update on the systemd issue
"Other professions, like medicine, the law, and engineering, have values and a professional ethic, where certain things are valued for their own sake."

[citation needed]

I can't parse what exactly this is supposed to refer to. Doctors treat the patients they get - and frequently wind up with no choice but to use treatments that are only barely worse than the disease (see the history of chemotherapy drugs, for instance). Outside of legal academia, the legal profession is always working with imperfect information, imperfect systems, imperfect people making the calls (ffs, I feel a Law and Order episode breaking out)...

To me, the giant disconnect is that we've still got two threads of thought still mixed together under "Computer Science": the actual science-y bit, and the "shovel bits from A to B" software construction part. It's as if materials science, structural engineering, and construction management were all lumped together. Putting a new sidewalk in does not require the development of an entirely new method for making concrete.
> However if you were creating UNIX today you'd definitely want to look at OOP and inheritance as a core pillar.

I doubt it. Imposing structure and types on IPC would make it very difficult to compose separate programs.

Suppose I created UNIX-2, where the only difference between UNIX and UNIX-2 in principle is the fact that UNIX-2 programs all pipe serialized Objects to and from each other, instead of byte streams.

Now, the ls program obviously outputs more information than just a list of strings--it also outputs types of files, permissions, owners, inode numbers, sizes, timestamps, etc. I might be inclined to have ls output an lsOutputObject (derived from Object) that encapsulated all this information.

Suppose I wanted to pipe the output of ls into wc. How does wc handle an lsOutputObject? Either wc is programmed to know how to handle lsOutputObject, or it is not. Since we want an object-oriented environment, we'll assume the former case, so wc can call the appropriate object-specific methods and access the appropriate object-specific fields. But, now wc is tightly coupled to ls.

This problem generalizes. For a given program P in a set of N programs, wc will need to know how to access P's output-object-specific fields and methods. So, wc needs O(N) different subroutines to interact with the N other programs. This does not scale--each additional program I add to UNIX-2 will require me to write O(N) additional IPC handlers--one for each program.

The only way to avoid this IPC-handler-explosion in the design is to define the set of IPC objects a priori and mandate all programs know how to handle them. Then, there are O(1) IPC handlers per program, and adding a new program does not require me to couple its implementation to any other programs. This is effectively what UNIX does: there is one IPC object--a string of bytes. In UNIX-2 I could have more types of objects, but the fact that they're defined independent of the programs means that I will still be "hoping the receiving process understands" when I give it data from arbitrary programs.

Suppose I relax this a priori object mandate above to allow programs to extend the base IPC object types. But then, programs that do so will only compose with programs that implement IPC handlers for their extended object types. In this scenario, I can expect there to be disjoint sets of programs that compose with one another, but not with others. This is effectively what happens in SOA/microservice architectures: you get a set of programs that are composible only with programs that speak their (arbitrarily-structured) messages (the set of which is much smaller than the global set of SOA/microservice programs).

My point is, trying to enforce OOP on IPC will take away universal program composibility, which is the killer (if not defining) feature of UNIX.
Oh! Thin and light; missed that one. Thanks!
> Err on the side of removing noisy alerts – over-monitoring is a harder problem to solve than under-monitoring.

Absolutely this. Our team is having more problems with this issue than anything else. However, there are two points which seem to contradict:

- Pages should be [...] actionable
- Symptoms should be monitored, not causes

The problem is that can't act on symptoms, only research them and then act on the causes. If you get an alert that says the DB is down, that's an actionable page - start the DB back up. Whereas, being paged that the connections to the DB are failing is far less actionable - you have to spend precious downtime researching the actual cause first. It could be the network, it could be an intermediary proxy, or it could be the DB itself.

Now granted, if you're only catching causes, there is the possibility you might miss something with your monitoring, and if you double up on your monitoring (that is, checking symptoms as well as causes), you could get noise. That said, most monitoring solutions (such as Nagios) include dependency chains, so you get alerted on the cause, and the symptom is silenced while the cause is in an error condition. And if you missed a cause, you still get the symptom alert and can fill your monitoring gaps from there.

Leave your research for the RCA and following development to prevent future downtime. When stuff is down, a SA's job is to get it back up.
His follow-up is at: http://changelog.complete.org/archives/9241-update-on-the-sy...
It is quite a bit different than the aesthetics of vehicles that were out at the time. It fits a lot better with current aesthetics with the rise of the crossover than it did a decade ago.
They actually look worse in person. The first time I saw one of these on the road, my jaw dropped - I just couldn't believe that something this unlovable made it into production. I distinctly remember thinking "GM has gone seriously off the rails". And this is coming from someone that owns a KTM 990A and a Honda Element!
Sure, if you go through all their stuff. And then what? Do we fire 70% of our staff?
Which service was it?
>As of this year Putin is now requiring bloggers to register if they have a certain number of readers, so that his administration can curtail international misinformation.

Yeah, totally, and not because the massive protests in late 2011-early 2012 were partly organized by a blogger/activist.
Some of these attempts at what you call "preventing NSA/other evil foreign agency collecting our citizen's data" are more like "let's prevent them from using Facebook/Google/etc., force them to switch to our networks where we can happily get the data ourselves". Which is probably what's going to happen here in Russia in 2016.
North Korea is colored red with no explanatory text... is that just to say "come on, it's North Korea?"
Well he said it was overhyped, which isn't so much a criticism of the theorem, but a criticism of the hypers.
4 Reasons Why Todays PostDocs Are Tomorrow’s CEOs
Really? adventured says the US left the free-market system forty years ago and you reply with criticism against Bush?
I'm a big advocate of "worse is better" - in fact I put it in my bio even at the risk of scaring off potential colleagues or employers. The real meaning of "worse is better" is of course subjective and complicated. And as has been pointed out in these comments, "worse is better" is not about creating "worse" software and then marketing it as "better". It is something much more philosophical.

In my eyes "worse is better" is about the mindset of approaching a task. It is about diving right in and learning through production - without being paralysed by the idea of introducing hacks or ugly design. It is the idea that, for the moment, there isn't a need to be worried about covering every edge case or possible failure option. It persuades you to focus on something simple and easy to explain, with a single purpose or intent. It is better to produce something (anything) and see where it takes you.

It also says how important it is to embrace contribution and collaboration. How important it is to, after some threshold, release yourself from feelings of ownership.

But if I had to nail down exactly why I believe "worse" is so successful ("better") it is because those that create "worse" software don't focus on the software - they focus on the idea. From that the software is painfully drawn. The software might suck, but I believe ideas are better. They are more persistant, easily explored, dynamic, and shareable than software. Ideas that are good, simple, and easily taught are far more important than well designed software. That is why they survive.

There are lots of programmers and hackers who don't believe in "worse is better". Sometimes you seen them on HN with a fantastic new programming language (or something) they have designed and built in isolation - perfect in every aspect (at least to them). Nothing quite hurts like their confusion when interest dwindles and their software is forgotten. All they had seen on HN were "worse" links every day, and after years they had provided "better" - to them it is criminal that it hasn't been picked and gained momentum.

Worse is better is not going away, and I think you can either engage yourself in it as a philosophy, or struggle.
It's pretty clear from the audio that he's lecturing somewhere, so it seems likely the filmmakers selected images to go along with his pre-existing speech.
These Shoes Are Bringing Back Everything Kickstarter Used to Be Known For
Uber Gets Failing Grade from Better Business Bureau
It was ugly, but not ugly enough to be cute. See: Volkswagen Thing[0]

[0] https://en.wikipedia.org/wiki/Volkswagen_181
https://github.com/popcorn-official/popcorn-app

https://github.com/time4popcorn/popcorntime-desktop

https://github.com/time4popcorn/popcorntime-android

Are all unavailable, citing the DMCA request. So... that's probably Github's response.
Interesting. I noticed that with RESTAS (a CL web server/API server library) they make a big deal of daemonization and not requiring the usual hacks to daemonize a CL server (tmux/screen/dtach/etc).

Was this a common (no pun intended) problem among CL implementations and why server daemonization is an issue? I am just learning CL, and noticed RESTAS only really supports this daemonization feature in SBCL, if I believe the documentation.

I guess I am going to have to dive into the source this weekend and check it out.
Not sure why I was downvoted, but perhaps because it's not clear that Jon Rafman is the author of the 9-eyes project.
"Personal data protected"?
So it is protected while our government stores it for 6 to 12 months?
I should be able to expect exactly that, because systemd's supposed ability to work as a drop-in replacement for sysvinit[0] was touted. But suddenly it's unreasonable to expect it to live up to its promises. Convenient.

[0] http://www.freedesktop.org/wiki/Software/systemd/ ("compatible with SysV and LSB init scripts", "It can work as a drop-in replacement for sysvinit.")
You can read about it here: http://en.wikipedia.org/wiki/Internet_in_North_Korea
As far as I know, Github has never made any official response to DMCA take down requests. All they do is simply making them public in this repository. (https://github.com/github/dmca)
The one-line summary: "Basically, no one seems to grasp that when stuff that's fundamental is broken, what you get is a combinatorial explosion of bullshit."

Exactly. A few examples.

- C's "the language has no idea how big an array is" problem. Result: decades of buffer overflows, and a whole industry finding them, patching them, and exploiting them.

- Delayed ACKs in TCP. OK idea, but the fixed timer was based on human typing speed, copied from X.25 accumulation timers. Result: elaborate workarounds, network stalls.

- C's "#include" textual approach to definition inclusion. Result: huge, slow builds, hacks like "precompiled headers".

- HTML float/clear as a layout mechanism. Result: Javascript libraries for layout on top of the browser's layout engine. Absolute positioning errors. Text on top of text or offscreen.

- The UNIX protection model, where the finest-grain entity is the user. Any program can do anything the user can do, and hostile programs do. Result: the virus and anti-virus industries.

- Makefiles. Using dependency relationships was a good idea. Having them be independent of the actual dependencies in the program wasn't. Result: "make depend",
"./configure", and other painful hacks.

- Peripheral-side control of DMA. Before PCs, IBM mainframes had "channels", which effectively had an MMU between device and memory, so that devices couldn't blither all over memory. Channels also provided a uniform interface for all devices. IBM PCs, like many minicomputers, originally had memory and devices on the same bus. This reduced transistor count back when it mattered. But it meant that devices could write all over memory, and devices and drivers had be trusted. Three decades later, when transistor counts don't matter, we still have that basic architecture. Result: drivers still crashing operating systems, many drivers still in kernel, devices able to inject malware into systems.

- Poor interprocess communication in operating systems. What's usually needed is a subroutine call. What the OS usually gives you is an I/O operation. QNX gets this right. IPC was a retrofit in the UNIX/Linux world, and still isn't very good. Fast IPC requires very tight coordination between scheduling and IPC, or each IPC operation puts somebody at the end of the line for CPU time. Result: elaborate, slow IPC systems built on top of sockets, pipes, channels, shared memory, etc. Programs too monolithic.

- Related to this, poor support for "big objects". A "big object" is something which can be called and provides various functions, but has an arms-length relationship with the caller and needs some protection from it. Examples are databases, network stacks, and other services. We don't even have a standard term for this. Special-purpose approaches include talking to the big object over a socket (databases), putting the big object in the kernel (network stacks), and trying to use DLL/shared object mechanisms in the same or partially shared address space. General purpose approaches include CORBA, OLE, Google protocol buffers and, perhaps, REST/JSON. Result: ad-hoc hacks for each shared object.
And they have far bigger problems of their own, compared to condorcet methods. Score is the worst....any rational voter will just vote with a 0% or 100% for all candidates. Those who vote "sincerely" are at a huge disadvantage.

Approval gives a big advantage to those who can best predict how others will vote. Yuk.
That's conflating separate issues. Windows could have a CreateProcessSimple() call that spawns a new process without so many options. CreateProcess is complex not so much because it is one call instead of two, but because it has all options jumbled together.

Meanwhile the Linux/Unix decision was to have about a dozen different APIs to do variants of the same thing (fork, vfork, and clone plus execl, execlp, execle, execv, execvp, execvpe, fexecve, posix_spawn, posix_spawnp, and probably more). This isn't really any less complex.

The argument complexity of CreateProcess could not possibly derive from merging fork() and exec() because fork() has no arguments.
In both of the pics in TFA, the camera is on the ground, so we're looking up at the vehicle. That's kind of an old trick for making any mostly-horizontal object look better. The truly awful angle from which to view an Aztek [really, has no one complained about the spelling of this name?] is from the back.
Configuring the settings doesn't help with the problem of it being too opinionated. Changing the settings wasn't the problem. The fact that there were settings was. For instance, there really shouldn't be border-radius or box-shadow on .panel at all. That should be up to the designer/front-end person/whoever to add. That's a very subjective property and has nothing to do with the basics of its layout or how it functions. Having a bunch of declarations of box-shadow: 0; all over the place is just clutter. That's just one example of many. I should clarify, I am not anti-Bootstrap. I use bits and pieces of it all the time. It's just not very good for building a large, scale websites that serves many purposes. And I can't design every page and app that comes my teams way, so I'm glad that there's something my coworkers can use that won't look like an unthawed caveman (from 2002) built it.
Show HN: ReshareGroups for digital marketing
Github Terms state: "You may not use the Service for any illegal or unauthorized purpose. You must not, in the use of the Service, violate any laws in your jurisdiction (including but not limited to copyright or trademark laws)."

which seems a bit wishy washy. The use of Github to host code doesn't seem to be violating any laws. The execution of the code does however. Splitting hairs no doubt, but it doesn't seem that merely hosting code that facilities copyright infringement is in itself copyright infringement. Granted if Github wants to uphold DMCA Safe Harbor they need to respond right away.
As someone who is on a regular rotation - being oncall sucks. But there are definite advantages.

Having the team feel direct pain is a great motivator for building robust applications - if you know that that quick hack could lead to you getting paged at 3 in the morning you are far more likely to seek out additional solutions(anecdotally speaking) - it means you also have weight within the team to make the right engineering calls.

The team can bond over operations - it sucks being oncall, everyone knows that so everyone tries to make it less sucky, by clearing ops queues before handing off or making ticket messages a bit nicer.

When you start having ticket-free weeks or months it is an awesome feeling, the service works and is robust and your team can spend that time writing new stuff.

Additionally, when you have a small team building/maintaining a service it makes far more sense to rotate the oncall responsibility between them rather than an external engineer.
> Arch is great but it breaks all the time.

My arch install literally never breaks. I haven't had any problems at all for years.
for us colorblind, Russia, Turkey, Iran, Pakistan & Company aready are very very close to it. :)
How is it okay for source code that enables infringement but does not infringe itself to be taken down by a DMCA request?

The claimant in this case doesn't own any of the rights to the software yet wants it removed anyway ...
The reviews are hilarious.. "The engine fell out on the second day, but hey, what can you expect!" (slightly paraphrased)
Loginboard – iOS 8 Password keyboard
I see the argument that Emacs Lisp is what we have and works fine floated around by many Emacs veterans, but I wonder if they realize the unrealized potential (opportunity cost) of keeping Guile Scheme out (as Stefan seems to prefer, whereas RMS is in favor of Scheme), and that Emacs going forward can probably yet produce more wealth of extensions than in the past 30 years? I completely agree that keeping full compatibility with all existing extensions is the absolute priority for the new Guile engine, but I myself have kept away from coding anything in Emacs Lisp other than a simple lambda binding because of Elisp's warts and very forgettable ways to do common things (e.g. manipulate strings in general.)
For Luxury Watch Buyers, One Just Isn’t Enough
Why Does Spain Have the World's Highest Concentration of Elevators?
It's not a promotion – it's a career change
> If there are 100 possible technical solutions to a given computing problem, the ones that solve the problem more comprehensively are naturally going to tend to be more complex, this complexity comes with an adoption cost, and that cost works against the likelihood of adoption.

The opposite is true. The best solutions are simple, not complex. Piling features one on top of other features to solve every problem as you encounter it gets you started faster than first thinking carefully about the problem space and then designing a solution. That's worse is better, or better: worse is quicker.
I habitually downvote discussions about downvoting as they pretty much always distract from the topic at hand and really aren't all that interesting in themselves.

The best approach to being downvoted is not to woundedly post asking why you were downvoted, but to wait. If your post has genuine value, it will almost always be voted back up. This has happened to me more times than I can count.

If your post is not upvoted over time, perhaps you're wrong about its value. Certainly the community disagrees with you. That questioning should be directed inwardly. Perhaps sometimes the answer will be that you don't care if the community disagrees with you, you still feel your point was justified. That also happens to me.

I understand the emotional impulse to question what a poster feels to be an injustice, but all they're really doing is indulging their emotional impulse at the expense of actual on-topic and interesting discussion.

Please don't do that.
Demystifying DevOps: Q&A with Tom Limoncelli
> * Is it hard to buy an RPi and set-it-up for a home Tor node? * To buy a VPS and setup a Tor-node then route all the traffic through it?! * Run tor-browser on your desktop when/if you need Tor?

Well... yeah, it is hard. It's undeniably much, much harder than buying a box and plugging it in, even if you're the kind of person who thinks configuring a VPS safely for Tor, then flawlessly configuring local network routing is an easy task. Hell I'm certified nerd and I'd still be scared to (flawlessly) do that. Not to mention a box is cheaper than a monthly VPS.

Tor browser is slightly easier but still crappy, because as the Kickstarter says it's just your browser and less tech-savvy people might wrongly equate "my browser" with "all of my computer's internet activity".

This project is a fantastic idea.
This reminds me of an excellent talk my friend Dan Slimmon gave called "Car Alarms and Smoke Alarms". He relates monitoring to the concepts of sensitivity and specificity in medical testing (http://en.wikipedia.org/wiki/Sensitivity_and_specificity). Sensitivity is about the likelihood that your monitor will detect the error condition. Specificity is about the likelihood that it will not create false alarms.

Think about how people react to smoke alarms versus car alarms. When the smoke alarm goes off, people mostly follow the official procedure. When car alarms go off, people ignore them. Why? Car alarms have very poor specificity.

I'd add another layer of car alarms are Not My Problem, but that's just me and not part of Dan's excellent original talk.