skysight-inc/HackerNews huggingface dataset:
No, it really doesn't. People have been combining BSD and "other" stuff for decades. How many systems shipped with the TCP stack (or zlib, or libjpeg, or...) linked right into their binaries? How many of them ran into "really messy to use" license problems? They just shipped it. The license says they can, and they did.

This just seems extraordinarily meta to me. What is the actual risk here? Quantify "messy" and "be safe".

(And FWIW: the fourth clause was considered bad because it put a restriction on how the software was distributed and communicated about. None of the licenses we're talking about in this thread include the advertising clause, or anything like it.)
ZoomCharts Facet Chart – browser shares, hierarchical structure
Awesome ES6 Patterns for React and Flux (Coding with React Like a Game Developer)
Canonical Launches Ubuntu Advantage Storage Support Service for OpenStack Swift
It's an issue when dealing with management or clients. They can see long commits as a problem with someone with too much time on their hands.

The whole point of a version control system is that it contains everything related to the code. On lots of web dev and game projects you also commit the finalized assets (the generated javascript from coffeescript, the compressed 3d textures, etc. etc.)
Your questions are valid, and you are correct that one size does not fit all. Frankly, the Google use case ('run lots and lots of as-yet-unwritten stuff on lots and lots of identicalish infrastructure') demands thie style of automation, but sacrifices other aspects of the final solution. This is a close use case to public cloud computing providers. However, in many cases (performance, security, etc.) it is not the most desirable model. This dichotomy is in my view one of the key points being overlooked by the dual champions of containerization, docker (non-profitable silly-valley hypetrain for LXC) and kubernetes (rethink of Google's internal container utilization seemingly in response to docker and EC2).
Why aren't these manufacturing shops in the US? I consistently hear of difficulty working with offshore manufacturing plants like this - skimping here and there, poor quality build, etc.
Exactly. Couchbase trades some availability during rebalance for more lightweight client interactions. As Damien argues in his post, this allows it to meet the same SLA with less hardware.
Its kind of like ice cream in that it looks beautiful when acquired but once you have it in your hands it tends to melt in to an unrecognizable puddle of sticky shit really quickly.
I'm never sure when these plugs become too much, but...

I created a language called bish that allows you to write your shell scripts in a sane and comfortable syntax. No more remembering which one of those conditionals to use! Bish compiles to bash, so you also get to keep all of the portability that comes with bash scripts. I haven't had much time to work on it recently, and it's still missing some features, but it's ready to use now:

https://github.com/tdenniston/bish
Maybe I'm misunderstanding, but wouldn't opening a file descriptor to a process via /proc have the same race condition issues with process id wraparound? After all, processes in /proc are opened by process ID (the only exception I can think of is /proc/self... maybe I missed some other exceptions?)

Overall, it seems easier to avoid process ID wraparound attacks via using the full 32-bit number space for PIDs. There may be a few programs that need to be changed because they did something silly like cast pid_t to short, but I think overall most programs would work just fine. As far as I can remember, the reason for using low numbers was because people didn't want to type longer ones at the shell. Internally the kernel and libraries store everything as 32-bit, at least on Linux.
Cassandra has rack awareness...
The linux kernel knows what is happening in the containers. There is little performance overhead, and security is not a big advantage of the approach, VMs are better.
It's not true, so I wouldn't bother looking too hard. ;)

The linux kernel does not "lose track" of processes/libs inside containers, they are simply namespaced, like a more extensive chroot environment.
Didn't mean to overreact toward the OP. I really haven't heard or seen about him to judge either way. As you can see, I was rather traumatized by those 2 clients from hell.
Good question. I found onboarding at Google really fun and interesting. I took several great classes, the best being the end-to-end class that in 8 hours let you write code that used most of Google's infrastructure - that class was so awesome that I would have payed Google for that day at work :-)

Also, they had code labs that are self paced modules for learning specific tech. I didn't spend much time at work doing code labs, but I could access them at home with my corporate laptop and I went through about a dozen of them at home. One other nice thing is even mentioning that you couldn't figure out something from the documentation or code labs would cause someone to jump in to help you.

Also, I don't think that people leaving Google have problems getting other jobs :-) The retention rate at Google is surprising low, given the pleasant atmosphere there. People leave to go elsewhere, start their own companies, etc. I was 63 when I worked there, and although it was probably not the most awesome place I worked, it was really great.

Apply for a job if you are interested, or go the easier route and get a contractor position.
There is also a requirement to submit a signed CLA, as seen here[1].

Additionally, on that page there is a requirement for a standard copyright header, specifying "The Go Authors" as the copyright holders.

[1]: https://golang.org/doc/contribute.html#copyright
I understand that, but my point was that Fish is yet another big missed opportunity.
Lyft Lets Passengers Rate Each Other and Connect After the Ride Is Over
> I'm an admin for Wikipedia, writing articles specifically on traditional multihull vessels that have hundreds of thousands of pageviews and have been front page featured, but that didn't seem to count. They wouldn't let me in.

Welcome to what it's like for any actual authority on a subject to write on Wikipedia. That's just karma, right there.
> Quantify "messy"

Having to add multiple headers in my code that reuses crypto.go specifically, rather than using the same header that I use when reusing every other piece of code in the Go standard library.

> People have been combining BSD and "other" stuff for decades.

Yes, though not without practical implications, as described in the link I posted in my previous comment.

> They just shipped it. The license says they can, and they did.

They license says they can as long as they follow the terms of the license. If they do not include the correct header in all derivatives, they are no longer complying with the terms of the license.

I am willing to bet that the vast majority of projects out there that use BSD-licensed code do not actually comply with the terms of the BSD license. They're usually small and the licensors don't notice (or care), so they get away with it. But that doesn't make it right for the licensees to do so, either ethically or legally, and they could easily find themselves in legal hot water if the original licensors wanted to make their lives difficult[0].

> (And FWIW: the fourth clause was considered bad because it put a restriction on how the software was distributed and communicated about.

It was also considered bad because it was complicated to comply with in practice. From the page I linked in my previous comment:

> When people put many such programs together in an operating system, the result is a serious problem. Imagine if a software system required 75 different sentences, each one naming a different author or group of authors.

[0] And in this case, the "original licensor" in question would be Intel. If Intel wants to make your life difficult, they can make your life difficult.
Introducing Google Play Books' New Font, Literata
Node.js and Io.js Merge Under the Node Foundation
Each 'container' is in effect an application plus all its dependencies.

So if one or more active containers could share resources then they won't, which leads to inefficiencies because you'll be running a much larger number of processes than you would otherwise (because of duplication) requiring a larger memory footprint and probably less efficient cache and/or IO utilization.

The deployment of the apps will be easier (which is a definite plus) but machine utilization will be lower and the amount of software running on a single machine will be far larger than otherwise, especially if multiple versions of dependencies are present on the same system.

A container is very much not a single process, it can contain many processes and some of those processes will likely duplicate components in other containers but without the resource optimizations that a kernel can normally perform.
This is an article written for the sake of writing an article. I'd question if the author even knows what the role of an Industrial Designer is, considering they labelled the engineer as the guy who builds the functionality, and the designer as the guy who makes it pretty. The fact that you drone on about not choosing an "angular box" isn't as amazing as you think; it's actually basic design semantics (i.e.; curvy is fun and straight is boring). The entire article is complimentary masturbation for a company that thinks it's the next Apple.

Industrial Designers are concerned with environment, business, usability and manufacturing. We're not just stylists. Look up Yves Behar's profile on The Verge if you want to begin to understand Industrial Design.
I couldn't care less.

I found a bug and 5 months later still not resolved.

https://bugs.mysql.com/bug.php?id=75293

Maybe start fixing things people may want to use, instead of claiming "yeah we can do that".

I no longer use MySQL, I have upgraded to something more "enterprise" and more useful.
Probably because you're missing the point?
Thank you for expressing this, especially in a caring and respectful way.
Thanks for the input; that's a good point. For my part, I don't tend to run into this, as I either run a stock distro shell or I go all the way and install the half-sentient metavirus that's my homedir repo. Which I've taught to deal with such vagaries rather efficiently over the years.
Onboarding at Google was great; Unlike similarly-sized and oft-mentioned competitors, Google has a set of really good classes that take you through the various systems, showing their design, reasoning, historical anecdotes, etc. Each of these has a more in-depth version, as well as a couple of classes called "Searching Shakespeare" that are designed as a two-day full-stack quickie to build something that uses a little of ever piece.
I'm just saying it takes about 30 seconds to explain the Metropolis-Hastings algorithm in plain english, and the wikipedia article is almost intentionally esoteric on the matter:

http://en.wikipedia.org/wiki/Metropolis–Hastings_algorithm

Meanwhile the much more complex Firefly algorithm is adequately explained in just 3 sentences that are obvious to understand:

http://en.wikipedia.org/wiki/Firefly_algorithm
Account linked from the Wikipedia article: http://arstechnica.com/science/2014/09/the-little-known-sovi...
Aww, after seeing that I'm a little disappointed. Each CSS file is basically just a giant truth table that describes which state each bit should be in under all possible combinations of inputs.

It makes for a cool demo of how simple Boolean circuits work, but you can't really say it's "doing computation" in CSS when all of the actual computation has been done ahead of time.

Still, it's clever.
AWS CloudTrail Notifications via Lambda, SNS and S3 Events
A funny and somewhat off topic story -- back in 2003, before the Google IPO, Google was doing a recruiting event at Berkeley. They brought a few of their folks with them: their founder Larry, one of their female engineers, Marissa, and some others. They did a little talk, and during the Q&A, professor Brewer told Larry that there was an opening in the PhD program and he was welcome to it. Larry politely declined.

Afterwards I asked Larry, "so, do you think you'll ever finish your PhD, either here or at Stanford?". He said, "If this Google thing doesn't work out I might, but I have a feeling it will work out ok."

It amuses me that Professor Brewer is now working for Larry. :)
The linux kernel knows what's happening inside the containers but it can not de-duplicate any components that are present in multiple individual containers and it can not ensure that only one version of a package is present. This will potentially lead to cache trashing and more IO than strictly speaking required for a given workload.

Of course it does make it easier to package and deploy applications (and to ensure their correct application) but to pretend that there is no cost associated with this is simply not true.
> Nobody will pay $1 for electricity to generate <$1 of bitcoin.

Hobbyist miners are convincing themselves that <$1 of Bitcoin will be worth >$1 the future. Major miners seem to have question business models as well, where they are either losing money or have something shady going on with their cost of electricity. BTC still seems to be very prone to pump-and-dump schemes, so major miners may be able to pump the price enough to sell their coins profitably before the next crash.
Yes, I think it's safe to say that Google operates at scale.

A lot of user-facing services at Google have to be over-provisioned in order to handle the cyclical usage patterns (the daily query peak is far higher than the average for most services) and to be able to survive the loss of a datacenter or two. This results in a lot of under-utilized servers for a big fraction of the time. So by packing lots of medium and low priority jobs on those same servers (and over-committing the resources on the server), you can soak up the slack resources; in the event that the resources are needed by the user-facing service the kernel containers ensure that the all the less latency-sensitive jobs on the machine don't compete for resources with the user-facing services.

It's true that the performance isolation when there are tens of jobs running on the same machine isn't going to completely match the performance isolation of running a service on a dedicated server, even with kernel resource isolation via containers, but you have to make cost trade-offs somewhere. The number of Borg services that could justify requesting dedicated machines was very small.

And to address your other concern about the OS not having so much insight into what's going on - Borg containers consisted generally of a single process, running on the machine's normal kernel. The containerization was just for in-kernel resource accounting/isolation. (Using Linux control groups, rather than anything fancier like LXC or Xen)
When birds squawk, other species seem to listen
More than that, better QA or better software doesn't actually make you money. As in, you can't make your software twice as good and make twice as much money. It's a lot more nuanced and much more indirect than that.

So certainly you can say "investing X QA hours per month should help reduce customer incidents by 50%, which will reduce churn rate by 30%, increasing MRR by 100% over 1 year, given current churn rates". Or whatever other metrics affect your actual revenue.

Overall, you need to draw a much stronger connection between QA and money, esp if you want to claim a continuous function between them.
>While you may die poorer, my belief is that you should always choose integrity and substance over money and hype.

Well said.

However, the two choices aren't always mutually exclusive. Ideally: make money via a path that has a high amount of integrity and substance. :)
> The "self-pipe trick" is ugly, involves a lot of unnecessary overhead, and runs the risk of deadlocking if you receive enough signals to fill the pipe buffer before you read them back

The unfortunate terseness of the original "self-pipe trick" description makes the solution to this difficult to see. As far as I've figured out there are two things to notice:

1) You're supposed to set the pipe to be non-blocking. Presumably you also then don't check the return code of the write(2) call in the signal handler. While this solves the case of a signal handler blocking forever, it does mean you might have dropped writes that correspond to signal receptions. That leads us to:

2) The self-pipe trick specifically calls out handling SIGCHLD (probably because it's one signal that you don't want to ignore!) But given the chances of dropping a byte as described in 1) and the fact that SIGCHLD and fork are explicitly called out, I can only assume that the lesson here is: only have one pipe per signal you intend to handle. Since multiple signals sent to a process may result in a single signal being delivered, your real signal handling code (the stuff that's watching the other end of the pipe) already has to deal with this situation.

As for Capsicum, I can't wait til they implement pdwait(2)! Until then, at least pdfork(2) ensures that the parent process' death kills the child process...

[1] http://cr.yp.to/docs/selfpipe.html
I'd guess it's not as bad as wood-smoked meat.
This is the only way to cook meat. (Aside from special purpose stuff.) I thought I'd end up using my sous vide maybe once per month and I probably use it three times per week. It's perfect for fish, pork, duck, and of course steak. The best thing is that you can cook chef cuts (like hangar and such) that would otherwise be really tricky to get right.

I generally finish in a cast iron skillet, and haven't seen any need to cool the meat off before the transfer. That's usually a good idea if you aren't going to sear right away, as it prevents bacteria growth from going into overdrive, but isn't strictly necessary to cooking if you're doing everything at once. Then again, I'm not an expert.

I really want to get a good torch though, since skillets are a lousy way to finish bone-in meat since the meat contracts away from the bone.
The ethereum white paper starts with an excellent explanation of Bitcoin. https://github.com/ethereum/wiki/wiki/White-Paper
Go Oracle database driver
Isn't this only true if your container build process pulls in the same version of a library in multiple different virutal filesystems? That is, if you are using the same base image for a number of applications and the libraries are installed in the base image rather than the image the application resides, in the kernel should recognize the shared libraries being used as coming from the same place and be able to perform deduplication as normal?
With Haskell, you aren't limited to 64-bit.

Prelude> let fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
Prelude> :set +s
Prelude> fibs !! 10000
33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875
(0.03 secs, 15,213,608 bytes)

If you have a practical use for large Fibonacci numbers, this seems an entirely practical way of producing them.
Kernels Without Abstractions: A History and Motivation
Oh god, I still swear at the whole "\rm" thing. I guess it's been a benefit a couple times where I might have deleted something by accident, but considering I mostly work on Git repositories, the inconvenience added by the wrappers is totally not worth it.
SDN’s Scale Out Effect on OpenStack Neutron
can you tldr what immoral means in this context? How did he define this and why should we accept his definition?
I noticed something similar when I was studying math: Exercises of the variety "Prove x" or "Disprove x" were much more than twice as easy as exercises of the variety "Prove or disprove x".
Is there a simple, sane introduction to PowerShell? I've read through a dozen PowerShell scripts in the last week and find them incomprehensible compared to Bash scripts.

I know I learned Bash 15 years ago, but it's not just familiarity that's causing the confusion
Thanks for that info. Citrus eh? Hadn't heard that one, bananas I have just started eating more regularly. I'll try the citrus too and see how that goes. I wonder sometimes if the caffeine I consume is part of the reason I sometimes have trouble focusing.
> I had to switch away from fish as well because of its lack of vi bindings.

No you didn't. I use vim and fish just fine. Just put this in your .vimrc:

set shell=/bin/bash
I'm glad I'm not the only one that did by gaming.

While not a MUD, I played a lot of EverQuest back in its heyday. I went from hunt-and-peck to 60+ wpm.

Though admittedly, typing lessons would have taken a lot less time.
Because it's bad practice to demand people use it when it's not required.
The reason it puts downward pressure is because large scale miners are forced to sell all their BTC almost immediately, if not pre sell future mined coins at a locked price (Hedgy.co solving this issue for them) So if people are forced to mine and sell every bitcoin instantly it applies heavy downward market pressure on the exchanges. Look at the volume in China, most of this comes from miners.

If electricity wasn't too bad, and/or the price was significantly hire per BTC the pressure to liquidate and pay bills wouldn't be there as much, leading to less (immediate) downward pressure on the markets/price.
And their webpage is broken
If you mean the fact that a removed autoloader function may be autoloaded again, then yup, that's fixed in 2.2. Here's the issue that tracked it: https://github.com/fish-shell/fish-shell/issues/213
Could you just throw in some charcoals in the lava to get diamonds and pay for the whole thing?
In what way is Rust, Golang, Nim safer than Java ? Rust I understand provides some nice semantics for thread safety but these exist in Java as world.

And I don't understand why anybody should care about CPU cache hit rate. The bottleneck is always going to be in the I/O pipeline. And Java is faster than C++ and vice versa in various situations.
Most Borg containers were in fact single processes (or more correctly, a shell wrapper around a single process)