It's not particularly usable as a scooter without the battery.
2,755 karma · joined October 9, 2012
It's not particularly usable as a scooter without the battery.
https://news.ycombinator.com/item?id=37705563
(Although I'd say it sure is noteworthy that it is being reported in NYT!)
Worst case scenario, the router/service endpoint sees your connection responses and the other party's strange NACK responses, but I honestly don't know enough about how it works to say "everything works fine"
I'd guess that connectionless protocols will work fine and connected protocols will also work fine. The truth is probably YMMV by protocol, but there is truly no way for the wifi router to detect this is happening or isolate the redundant stations - it's an unencrypted broadcast. The only way this goes sideways is if a connection protocol is engineered to make it go sideways when you try to do that.
I'm pretty sure that any such protocol which succumbs to any unencrypted (or incorrectly keyed) traffic that isn't from the designated counterparty is insecure to begin with. It should be resilient against DoS, so most protocols aren't going to have that vulnerability. Again, I'm guessing, but I'd hope.
I would love to understand a bit better why this one gets left off the list so often. "There's just nobody interested in putting those two things together" I guess, it's surprising to me though, because Ruby is pretty popular AFAIK.
Solved by who exactly? You can't tell me with a straight face if I can show you a way that you can spend 1/100 of what you currently do on servers that run full-time by changing the architecture into a serverless one, with web assembly providing the faster startup times required to make it perform acceptably, that you're not interested in saving that money.
Performance is always a goal. Anyone that tells you performance is a solved problem is lying.
But perhaps we've heard "serverless is going to save you" one too many times from AWS and friends, and now we don't want to hear it anymore.
News flash, AWS and Azure both want to sell you more servers. So they cloud providers are all not going to seriously invest in serverless. It's not a solved problem at all. They'd all love it if serverless was an abominable failure altogether. Which is how I'll bet you actually perceive all that mess, am I right? Give me more servers, they actually fucking work.
The goal for me has never been to run code in web browsers. It has always been to write code in whatever language suits me, and run it wherever, especially libraries for reuse. To avoid rewriting the same code over and over. I never pick the browser as a target, because it puts so many things irredeemably outside of my control (which it must, because it's not my machine.)
The DX in Wasm is pretty complicated, but it gets a lot better IMO through Spin.
But that was a marketing name and a campaign that worked apparently too well. I try to think of it as a naming failure, and tell everyone I can that Wasm isn't for web browsers. I mean, it can run in a web browser, sure, but if what you're building is a server, the chances that you're going to want to run it in a web browser in the end are practically nil, aren't they? (I guess for the author, that wasn't exactly true.)
And everyone I know is building servers, or something like a component that should sit behind a server, or libraries for command line. Nobody I know is building flash games, or planning on extracting compute out of their users who arrive via web-browser, none of our code needs to run in the browser sandbox, and nobody I know would pick up Wasm for that reason (unless by some fluke they really needed to do that, and it was the thing they had been told that Wasm was supposed to do. Which many people apparently have been told by now!)
It is for sure a thing that has been promised (Wasm is for web browsers) and must be delivered, but I don't think it's where the implementation of Wasm is going to take off right now. I think people need to take their server-side apps and achieve those 1000x performance gains that have been promised, reshape their runtime profiles to be serverless-capable as it's done with the Spin runtime, and then I really do think things will start to improve for the rest of us as the tooling matures.
If you spend a lot of money on servers and you can spend less money on servers by making them start up very quickly, and shutting them down when they're not actively serving requests, then you can save a lot of money. That's the story that Spin is telling, and that's where I expect to see the movement happening at first, especially if we are heading into a recession as has been predicted by almost everybody. If you are spending money on waste, now is a great time to try and cut it out. Web Assembly has great potential to help with this.
https://www.youtube.com/watch?v=EsAuJmHYWgI&list=PLbzoR-pLrL...
https://tailscale.com/kb/1185/kubernetes/
These are great, for someone who knows Kubernetes. You should understand that creating the tailscale subnet router as a pod directly means the connection is not resilient. It's also key to understand that tailscale will break if you have more than one instance of subnet router at a time, so substituting Deployment in place of where these docs use Pod is not a really good choice without some fine tuning because of the risk that a rolling update creates another copy of the pod before the old one has shut down.
Maybe stateful set, if there was a way to permanently imply that statefulset can only have one replica. I appreciate the link anyway. I figured all this out on my own, and I'm using tailscale productively with Kubernetes based on the old docs, with my open source project. Tailscale has a great and generous free software tier for supporting OSS maintainers. :tada:
You version your apps, of course, and you would publish some artifact that represents the release. Historically this has been a Helm chart, but for Flux we are seeing many people use OCI repositories for this now. They give many of the benefits of Helm repositories without most of the drawbacks, the way that Flux uses them you retain traceability to the Git commit that started your release, and even Helm itself has already adopted OCI repositories in the current version, (just waiting for many chart publishers to catch up, we are getting there!)
The app manages its own manifests in the app repo, the app devs deploy from the main branch or a dev branch on their own app repo, but everyone else that uses the app will deploy from a release artifact. Those artifacts are tagged with semver numbers, so you can automatically move to the next version of the app as soon as its published with a valid signature.
If your app devs are the only ones using the app, then this should not change anything as they are building for production it should be versioned and managed like any production concern – whether it's for distribution or not, you still do releases.
It's not any more complicated than what you are already doing with `docker build` and `docker push` I assure you, it's nearly the same. And since those OCI manifest release tags all logically come from a git tag, there's traceability and it is still GitOps in every important sense of the word.
Automation as policy directives state declaratively that an app is always on the latest published version at any given time, a `spec.semver` with a wildcard accomplishes this very simply with a one-liner addition to your config in Flux.
When you need to roll back app A, you remove the automation (in Flux the easiest way is a wildcard) and pin your gitops config for that one app to the particular version that you wanted in git, the cluster repo, the app is pinned to the one version that doesn't have an issue. Then as the issue is resolved, you may remove the pin and put the automation back in place.
As an added benefit, you get a permanent history that shows when incident response began, how long the automation was disabled, and what version was pinned at that time, so you can calculate metrics like "MTTR" and "MBTF" that we love so much.
And anyway, if 1/5 of laptops needed major repairs and some of them got it, those go back into circulation. Are they still original laptops? (Ask my grandfather's axe...)
https://ossna2023.sched.com/event/1K55z/exotic-runtime-targe...
https://www.youtube.com/watch?v=EsAuJmHYWgI
My goal was to determine: how will I use Wasm as a Rubyist? Spoiler: I did not intend to use Rust, but embedding Ruby in a Wasm and running it from within Ruby proved to be a fool's exercise. I have a feeling that some of the claims I made in this talk about there being "no theoretical benefit" to running Ruby in Wasm in Ruby will quickly be proven incorrect. But I'm not expecting it to be faster.
If it's ever faster, that will be filed under "surprising results"
Michael Yuan who obviously knows a lot more about Wasm than I do addressed this in his talk as well, but not from the perspective of a JIT necessarily, although I guess you could consider local machine compile target optimization on the target machine at runtime as a type of "just in time optimization" it's not really (it's just the regular ahead-of-time type of optimization, but not fumbled and the majority of benefits immediately getting lost in such a way as it usually is...)
https://www.youtube.com/watch?v=kOvoBEg4-N4
The spoiler from that talk (for me anyway) was finding out that you do see surprising results sometimes, and sometimes it's due to a pathological case that (a) happens all the time, and (b) does not have a readily obvious solution in the form the problem regularly takes. Like linux distros shipping generic binaries "target-optimized" for the lowest common denominator on any given particular architecture dist target, because the binaries they ship obviously have to run anywhere.
(Recap of the conversation we had off-stage after the Q&A ended: We don't know when we say "x86-64" what modern opcode targets that means we really have available, so we have to ship a binary with only the oldest opcodes that are guaranteed to be available on any similar chip that we intend to support. Web Assembly uses a compiler on the target machine, cranelift, to translate from a platform independent binary to a platform-specific one. Running the compiler takes a while, but we can do it ahead of time. Will we come out ahead in the end?)
All of this stuff is certainly very fun to reason about :D
https://developer.fermyon.com/spin/sqlite-api-guide#using-sq...
I'm not sure what holds back from being a completely language agnostic solution, but I know when I tried binding functions into my Ruby app with wasmer I had nothing but problems, I wound up using WASI exclusively to communicate with my WASM modules. I don't honestly know how good the WASM language agnostic story is today. I gave a talk with my perspective as a Rubyist at OSS Summit and CDCon/GitOpsCon a few months ago in Vancouver. The talk (and lightning talk variant) are called "Exotic Runtime Targets: Ruby and Wasm on Kubernetes and GitOps Delivery Pipelines"
This is kind of subjective, and in the context of "is this a JS killer" which is what you're answering, I'd agree, it makes sending the Wasm to the browser a bit of a non-starter that it requires a large bundle most of which is simply boilerplate for whatever runtime, without some type of local storage and persistent cache it's difficult to imagine using Ruby in a Wasm for example. If you're deploying to a container, where you're able to use a cache warmer to ensure the wasm is ready before it's called, then a 1mb binary might not be such a big issue.
(I mean, it is still a big issue because the point was fast cold starts, and big assemblies mean no fast cold starts, but again, subjective value judgments... 1mb isn't too big in many cases and I'd wager most of the cases that I'd really care about. But in a browser...)
But if you're not trying to run the Wasm in a browser then it's still potentially quite useful. You might not be running all of your Wasm in a browser and it might still be a JS killer, and all of those might not be in conflict.
Companies don't need driving tests, individuals need the driving tests. Companies have no business taking them all off the market, leading to the condition that the individuals cannot get any. That isn't how this works, that isn't how any of this works.
Nobody asked this question after. I assumed that everyone who came to my talk had already been convinced, and the members of the audience all agreed or at least didn't complain.
The problem with explaining "why Wasm" is that you're looking (*I'm assuming a lot here) for direct effects, but I'm seeing most of the benefit coming from second-or-third-order effects.
My "Baby's first WASM experiments" talk is here: https://www.youtube.com/watch?v=SLoVn2Ao3qc (as a lightning talk) and here: https://www.youtube.com/watch?v=EsAuJmHYWgI (as a full session, with some code that ran to completion...)
I did focus on "what exactly is Wasm" and with a specific bent, from a Rubyist's perspective, how will and won't I be able to use Wasm today. It might not be the talk you're looking for if you don't care about a Rubyist's perspective.
From my perspective, Wasm helped me like this: I knew that I wasn't going to be able to rewrite my whole system and pack it into a Wasm, because reasons (Ruby...) so I decided, we'll have to find another way to make use of Wasm. Let's use it for the most important thing that isn't very important first (some core logic that is tightly scoped and exceedingly easy to verify.) It will help if we can show with a benchmark or something later that the whole process runs faster because this one part that runs 10,000 times is using Wasm now, hypothesis.
Accepting up front that this may not pan out immediately, because reasons (again) we tried to see what it will look like if the HTML parsing is done by Wasm. Well we figured out pretty quick that if we had to load and unload the Wasm every time it's used, that's not going to be an improvement unless it happens fast. And as long as we had to bundle the entire Ruby interpreter in with the Wasm, it probably wasn't going to load very fast. Experimentally verified with several runtimes.
So Wasm turned from "use any language!" to "any language, but not only that one..." real quick. And I was prepared to accept that I might need to use a different language, because I had seen the numbers this time, and I had been well coached and was prepared to blame it on Ruby. Wasm incentivized me to pick up a bit of Rust. Not because Rust is especially well-suited to solving my problem, but because any language could do it, and the performance-critical part probably shouldn't be in Ruby (and Rust in Wasm has the home-field advantage, I think.)
But, for me, the event-management code can all remain Ruby because it is in no way performance critical.
I mean, you could have just told me that Ruby is going to be a bottleneck when I get to performance-critical sections and we might have started with a different language, but "I'm a Rubyist" and I don't think that way. There's only one performance-critical part, so there isn't really a great argument to rewrite the whole thing in some other language (maybe Go instead of Rust...) but now that I have solved the core problem in Rust, I can just take that with me and use it with Go instead of a Ruby scaffold, if that was a thing of value to me. (It's not a difficult argument to make that you should just go ahead and build Kubernetes operators in Go rather than building them in Ruby.)
More important than the portability though, this exercise encouraged me to draw a box around the core bits of my program and think really hard about them until they were really solved. Separating those "business logic" bits from the rest of your program and making them pluggable is a really valuable thing to have, architecturally, even if you never swap the bits or the scaffold. Sure, you can write properly unit-ized code without Wasm to help you figure out this border-crossing situation,
...but can you coach a intern or junior engineer to do it with a soft touch and minimal instruction?
That was the a-ha moment for me. Wasm as a set of constraints naturally promotes and encourages the emergent solutions to look like this one, drawing a (sand)box around each important component. You won't build a monolith if it cannot do dynamic loading.
(So this next stage of Wasm ecosystem development, with the new component loaders capability, is set to make things quite interesting again... buckle up!)
It's times like these I regret that neighbors don't talk to each other anymore. How can we even have functioning internet if we don't have network neighborhood...
If my neighbor leaves his door open (in the winter, say), and I have cause to believe that something is wrong based on that, is a jury going to convict me for going in there to check on them? It really sounds like that's what was done here.
I guess creating an admin account while I'm in there is a bit like making a key for myself while I look around. That might be over the line. But without that step, I'm not sure how you can have proved that something was even wrong...
I'll go read the article now.
That's silly, the reason people protect themselves is so that they are protected. Legal protection is another different kind of protection, but I think it's a deep stretch to argue that one can remove all the technical protections and still keep access to the CFAA and obtain meaningful protection from the law.
> protected computer
If you're suggesting that the CFAA itself protects the computer by definition, then you've excluded the possibility of a such thing as an "unprotected computer" which renders the extra word unnecessary. I don't think that's the intention, that all computers gain the implicit protection, I think there actually needs to be a policy or standard enforced, or ownership made clear.
In the tradition of US property law, I think you need to do the bare minimum of posting "NO TRESPASSING" signs at the border so anyone that walks by them can be said to have observed the difference between your space and the public spaces surrounding it (which they are permitted to be in, just like your private property so long as it's unprotected and they haven't been asked to leave before...)
Legally, I think it's also true that an open door looks more like an invitation to enter (and it's different from burglary to simply poke your head in the door, see if anything is wrong, and not breaking or taking anything)
If an API is served on a public network and your client hits that API with a valid request which returns 200 (not 401) and that API is shaped like an open door, such that no "knock" or similar magic or special protection-breaking incantations were required in order to obtain "the access" ...
Then would you concede it's not actually like a burglary, but a bit more like going in through an open door to see if everyone is OK? (It sounds like that's more precisely what happened here, I'll admit I haven't read it all...)
But that chance isn't the sole reason why you're doing that load test. The reason is to improve the software. You're identifying defects by stressing the limits.
When you're doing a load test (or any test really) the possible outcomes are basically three: (1) it works! (2) it broke. (3) huh, that's interesting. If your tests are always coming up (1) then you're not obtaining any benefit from them. Don't you want to know where the limiting factors are in your app? If you're able to remove those limits, but not for production (at least not right now), wouldn't it be great to know what will break next month (or next year) when you do?
Think of the person who writes unit tests for every piece of code, but not as TDD. There's a school of thought that you should write the test first, then write the simplest code that passes, and that's fine but not what I'm talking about. Imagine a person who writes perfect code and perfect tests. Every code works, every test passes confirming that it worked. What is even the value of writing the test?
That's what load testing under only the expected conditions is like. We already know the software works under those conditions (likely) because it's already in production, handling that amount of load. So while there is value in a load test that runs prior to deployment, in order to check that nothing of the change is likely to induce a break under the expected/existing load, it's a different kind of testing and produces different value than a stress test that is designed to hopefully induce a failure and show you where there is a defect in code. Where it segfaults, for example.
And just because you've identified a limiting factor outside the bounds of what expected activity is likely to go through the system soon, doesn't mean you need to fix it now. Having one less "known unknown" on the table is a thing of value. Now that stress won't be able to surprise you later, when that parameter has drifted into the danger zone because of organic development, and now it's becoming a thing in the way.
laugh-crying I never said I disagreed with OP though. With all this as context he's certainly within his right to fork TF now!
(Mazel tov!)
I've also been saying, this is a blessing in disguise for Hashi because they won't have to spend the labor to maintain Terraform themselves anymore. rofl I won't be shocked if that doesn't turn out to be far from the truth, but it's going to take actual work before those would turn out to be more than just empty words.
But honestly, if I'm HashiCorp and I see the OpenTF organization spring up in response to my license change, I actually (surprise) still very much want to be the top contributor in that new forum. And it might even lend some measure of extra credibility to the whole ecosystem if it turns out that I can't actually pull that off (because the community is too strong, and overpowers me with its own contributions.)
I'm willing to admit this is probably delusionally optimistic in favor of OSS but I wouldn't cry to be proven right either.
> if there was anything that would receive attention for Terraform, I figured it would surely be a pull request fixing the six-year-old, number-one-most-popular feature request on the issue tracker
Working on an open source project, I see a lot of popular feature requests that don't fit into the roadmap and aren't aligned with the design of the project.
It's sometimes very difficult to tactfully explain to folks that "your idea is not aligned with the vision" but I have gotten better at it over time. It still takes a lot of emotional energy to wind yourself up and explain the vision, even after doing it before. And sometimes it falls on deaf ears. That's why we write FAQ documents. But not every FAQ belongs in the FAQ document.
Some questions shouldn't even be asked, because they betray the misunderstanding of the asker and in doing so they may prompt a new chain of even deeper misunderstandings that can only be prevented by heading off directly at the pass and not even entertaining the notion.
Now I'm absolutely not saying this issue is one of those issues in so many words or less. I'm not a keeper of the vision for Hashi. But I am saying, as far as selection algorithms go, if you wanted to pick a PR that would be likely to get merged...
Well, sure, you could do much worse than:
> a pull request fixing the six-year-old, number-one-most-popular feature request on the issue tracker
But I am saying that understanding that this PR having gone un-merged for 6 years in spite of being submitted multiple times, might be a signal that this change is not aligned with the intended direction and that it probably won't be merged...
I mean, it could go either way, but accepting that it can go either way, and that includes the possibility that it doesn't turn out the way you hoped, is kinda table stakes when you're dealing with a project that has like a zillion users. I mean, you wrote that big gnarly regex script to solve the issue, didn't you? How many of those things do you think went into production based on the number of people impacted? I'd say thousands. How would you have felt if the next release broke your fixup script but didn't actually solve the issue? (It kinda reads like that's what happened, anyway, so I mean, how does it feel?)
I'm not saying I wouldn't write a 10 paragraph diatribe like this, but I am saying I understand the terseness of the reply. The alternative is falling on one's sword and I don't expect anyone to be doing that for my benefit, and IMHO neither should anyone expect that of any OSS maintainer or anyone else.
Well unless TF competitors were prepared to go off and build their own (OpenTF) it's as you say anyway, Terraform doesn't just spring into existence without Hashi building it first. If you are building on it, then you have it to build upon because they built it first. License changes notwithstanding, if the ongoing efforts of HashiCorp today are worth anything to you, then it's to your advantage to go on supporting TF with a capital T and disregard the fork. But if you think they will try to extract more than their contribution is worth from you, then the choice is clear...ish. How much will it cost you to form and maintain the fork?
It's a tough calculation. Will you derive more benefit from the partnership with Hashi (assuming they're amenable to forming one) or will you derive more benefit from the ownership associated with building your own OpenTF? How much will it cost? Must be all companies with a Terraform arm are doing this calculus right now, trying to figure out if there is a "support both" option they can live with, or otherwise if they're going to have to pick one, how to not pick the loser.
I understand that for some companies the calculus may be obvious and the choices clear. If your entire business depends on Terraform, then accepting all the terms might as well be tantamount to accepting a full buyout without any price tag. It's a pretty big no-brainer of a "no deal!" but on the other hand if you are VMWare or RedHat and you need for your contracts to support Terraform with a capital T...
I think it's those companies who can't just say "we support the fork" and move on with business as usual, without taking a big hit to the credibility of their support promises. Will they actually participate in a fork, if they say they support a fork? (Will you welcome them with open arms, or skepticism? What if it turns out that their under-participation in the Terraform ecosystem of yesteryore is the actual reason we are in this position now? Again, speculating...)
What does that signal about their commitment to the tech if they do follow the fork, and what does it mean for their big clients who might have already cut some deals with Hashicorp on their own... and can one even support both without putting oneself in a precarious legal position?
They sell licenses to major (even government) institutions and Hashi OSS might be used as part of the solution, but Hashi aren't getting a cut of the deal. Let's say. I think those big companies want to have Terraform support with a capital T, and it would diminish their marks substantially to switch streams now and edge out Hashi, the smaller player (who is actually doing all of the work), by supporting OpenTF – separating them from ongoing development efforts of HashiCorp who undoubtedly are expending some significant labor to make and maintain Terraform itself.
But I don't think it's right for Open Source companies to pull the rug on other companies that have built successful products on them. I think the best outcome possible for Spacelift and companies like it now is the OpenTF route (assuming you can't get a suitably proper BUSL license grant from HashiCorp, which it seems like you might if you get them to declare you "not a competitor" even once, according to the FAQ as it reads today. IANAL.)
I think you're using the MPL software as the license was designed, and your company should be able to deliver Terraform with additional value provided through the interface and the scaffolding (eg. better Terraform Cloud) that you built around it, and charge money for it. But of course I'm not the lawyer. I am very glad to meet you here though!
https://www.hashicorp.com/license-faq#future-competitive-pro...
If in the future HashiCorp creates an offering then they will exempt me from action under the BSL according to this section. What is the likelihood of this changing later on? What is my recourse if it does? All of these questions, you can ask yourself (and your lawyers, again and again each time) now of any open source project that makes contributors sign a CLA. Since there was nothing stopping HashiCorp from doing this, what will stop others?
This is a terrible thing for Open Source IMO. Competition is good, but I understand HashiCorp have some competitors that are leveraging their good will against them and costing them deals. I hope that Hashi don't use this new license to squash their competitors and stamp out Open Source. But I won't take that as foregone conclusion, it's up to HashiCorp how they pursue these changes and up to the rest of us how to react when they do. I've got my fingers crossed for good.
When a company gives you a license that has terms written in it, that license is binding... on them as well as you. When a company gives you a document that refers to an FAQ that they can change on the fly to meet their needs, and make changes to it, that is a signal that they do not view the license's terms as binding on them. Only on you (the user / developer working on an integrated or derivative work.)
The license that grants you permission to use the software as long as you remain on the right side of this line, which we can move as we deign it necessary to move the line is not much of a license grant. I just heard it called "bullshit license" and I think that's the best explanation for what BSL actually stands for now.
I support Hashicorp's right to make money from their business, but I think these lawyers are in over their head. It doesn't make much sense to me. We'll have to see who gets a license grant from Hashi and how much they're going to pay for it.