1,391 karma · joined October 24, 2009
So no, nobody is saying you can't run chef/salt in agentless mode, but in practice nobody wants to because it's a lot of work. And it's not like ansible doesn't also run in a managed-by-master-node mode, that's the entire basis of ansible tower.
And to be clear, it's not that I like ansible because it's agentless. It's because the benefits of the tool being designed-from-the-ground-up as agentless leads itself to beneficial properties.
> You literally can create a golden image with chef-client and your done
This is a lot more work than you let on. That client needs to be configured to point to a particular master node. So yes, you can create a golden image, and it'll talk to one master node, and run on one platform. Good luck getting your golden AMI to run locally in VMWare, or virtualbox, or in a LXC container. Good luck adding in the functionality to make your client dynamically select a different master. It's not impossible, it's just not dead easy. The fact that this is an annoying thing to do is proven by the existence of salt-bootstrap (it's a tool that SSH'es into a node and sets it up as a salt client, hrm, now where else have we seen a tool that manages a node only using ssh?)
> I think Ansible capitalized on people's wariness/lack of experience using chef
I think this is a rather unfair generalization to make. I've personally had many years of production experience with chef/puppet/fabric and the only reason I have no actual production experience with salt is because ansible came out soon after (I still follow their development with interest). In my experience, the people I know who use ansible are neckbeard admin types with battle scars from other orchestration frameworks.
Because of this difference it's really easy to incorporate into an existing infrastructure with no current frameworks. Pretty much every job i've had started off with a bunch of existing servers they set up ad-hoc, which we then wanted to add automated orchestration to.
It's also really easy to use your defined playbooks against different contexts (just use the hosts file switch to run against staging, or a cluster of test vms, or a bunch of lxc containers).
But does that mean ascii is inherently denser? I wouldn't use ascii to communicate with aliens because to understand it you require knowledge of the majority of the english language (again, english knowledge is shared ahead of time). In fact, the Voyager Golden Record has line drawings on the cover, and not a single character.
Is there really less information required to represent text than data? It just seems easier to encode ascii text because we've settled on an encoding schema that optimizes for the english alphabet. The example of the twitter icon using 2000 bytes is only because the author decided to use a png. Using the font-awesome typeface, the twitter icon is just 2 bytes. And I can whip up in 5 minutes a typeface where the twitter logo uses 1 byte. We can come up with an encoding format where dingbats and logos take up 1 byte and the english alphabet uses 2TB. It'd be a useless encoding for practical purposes, but goes against the idea that text is inherently more informationally compact than images.
Granted, it's not a commonly used feature by solo devs working on their own projects, but is useful for team repos that get large enough where you need to do audits on the codebase.
Crypton itself has been audited a couple times by crypto persons, see https://crypton.io/docs/security/audits.html
(disclaimer: i used to work at spideroak, but neither on crypton nor encryptr. i still think they're all awesome though)
Some other notes: SpiderOak didn't surface after the Snowden leaks. It was around at the same time that dropbox started. However, the Snowden leaks did prompt a lot more interest in zero-knowledge cloud services, so if you mean "surface" as in "became more popular with the public" you're right on those lines.
Also, while I'm not sure if Encryptr has been audited or not, the Crypton project itself has been at least a couple of times. See https://crypton.io/docs/security/audits.html
Math.sqrt((p.x - c.x) ^ 2 + (p.y - c.y) ^ 2) > c.radius
If you're doing this test many, many times (especially as in a Monte Carlo simulation), it'd be more efficient to use distanceSquared: (p.x - c.x) ^ 2 + (p.y - c.y) ^ 2 > c.radius ^ 2
Not having to calculate square roots will cut the compute time drastically.Thus, all these machines with duplicate keys are VERY vulnerable to MITM, because anyone with access to one of them has access to the private key.
ps = pyscribe.Scriber()
x = 0
ps.p(x)
ps.watch(x)
for x in range(4):
pass
# x is now 3
[x for x in range(5)]
# x is now 4For one, it seems the only type of change you can watch for are changes via assignment for top level variables. For example, any of the mutable built-ins (and I confirmed this by trying to use pyscribe) can't be watched for all changes. For example, mutating the list later with .append() doesn't log anything, nor does changing a value in a dictionary. You also can't watch a particular key in a dictionary, or an attribute in a class (these lead to parse errors when trying to run pyscribe).
Even if you modified the code to support this, you wouldn't be able to control access everywhere that piece of data went. Suppose I had a dict and and some point:
...
d = {'foo': 'bar'}
ps.watch(d)
ThirdPartyLib.do_stuff(d)
If that third party library mutated d, there'd be no way for you to know, unless you also were able to desugar those files (basically impossible because in some cases the source code isn't even available).In any case, this type of mutation is generally what causes the most bugs. A value changing by assignment doesn't need a run-time logger. These change are in plain sight; just do a search for the variable name in the local body of the function. Mutation that occurs in other contexts (when the object has been renamed, or passed to another function where access is through a different variable name) is the difficult thing to debug, and pyscribe cannot handle that with the current design.
Honestly, I think this is better handled with mocking objects. See how python Mock library does things, and possibly use it yourself (it wouldn't be all that much work to write your own wrapper, but Mock is seriously powerful). Basically watching a variable means wrapping it with a mocked object that defers all reads/writes to the real object, while logging all those changes. Not relying on desugaring also means you can watch what happens to your data when you pass it into third party libraries.
The only situation where I think that could be avoided was if we were quick to grant them rights as individuals. And still, we have enough problems getting along with people of other (skin color, age, gender, religion, political denomination, geographic location) that it's very unlikely we'll avoid conflict.
It seems to me the argument for OpenResty is: if you already have nginx in your stack, you might as well run your app in it as well.
(not saying a libuv based server in lua is pointless, I mean I've used tornado behind nginx. I also concede it would be super useful for non-web servers (say, a custom protocol/IMAP/DNS/etc.))
What we're still lacking is good jobs, and access to VC funding for companies we want to build. mbloom is not the fund that we need to grow our tech industry, if anything it's looking like it'll poison the waters.