algorithmmonkey

I keep seeing everyone guessing what the margin is on inference. You say that it's largely break even. We have this person in the thread claim 80% margin (https://news.ycombinator.com/item?id=45462442).

These numbers are complete make believe.

Can you explain how the Fed is keeping the cost of labor low, and what they should do to help folks paid enough? I'm not sure I see the connection.

Rate cuts are priced in at about 100% for a 1/4 point. It might go up for a 1/2 point, but that may also signal fear which could have the opposite effect. I think it's hard to say at this point.

The Federal Reserve operates under a "dual mandate" from Congress to promote maximum employment and stable prices (low inflation). As unemployment rises, the Fed will lower interest rates to stimulate investment (increase employment opportunities).

There are definitely some similarities. I think the main difference is the compatibility of Wasm / WASI. Often for unikernel / libOS, you would need to recompile applications to target the specific unikernel / libOS. The goal is that you should be able to take a component that you would run with Wasmtime or other component model compatible runtime and be able to run that on Hyperlight-Wasm.

This example (https://github.com/hyperlight-dev/hyperlight-wasm-sockets-ex...) demonstrates starting a sandbox and loading a component. You could imagine you'd write an app that starts and stops any number of components in their own sandboxes.

As for executing a tree of connected components, in the current state of Hyperlight-Wasm you'd probably want to take a collection of components and compose them together using something like https://github.com/bytecodealliance/wac to create a final component composed together from multiple components.

A Wasm component running inside of Wasmtime is just fine. However, when you start to use resources from outside of Wasm, e.g. systems, network interfaces, GPUs, etc., Wasmtime uses OS resources from the host that it is running upon. If this host is running on your trusted compute base, then it implies you are trusting the host implementations in Wasmtime, which for some is just fine. However, Hyperlight-Wasm gives platform builders the ability to describe the interface between the guest and the host explicitly, so you could only expose the host functionality you would want with the trusted implementation you'd want. For example, if I'm building a FaaS, I may want to provide only an exported event handler and an imported key/value interface to the guest for which I've built a safe, multi-tenant implementation and strictly disallow all other host provided functionality.

Krustlet implemented the Kubelet API rather than the containerd-shim API. That means that with containerd shims, you can use the default K8s kubelet, containerd, and extend your containerd runtime with a shim for executing Wasm. Kubelet is much higher in the stack and requires much more to implement it and everything below it in the stack.

I would like to see remote comp be structured with a flat base rate across geos, and then have bonuses for locality to corporate centers. If you feel that it is worth it, you can choose to live close to the office. A flat base rate across geos compensates folks doing the same work for the same pay.

Same thing happens with MSFT. Remote comp is location dependent.

Maybe a good candidate in this organization is one that will leverage every edge they have to produce a desired result. Resourcefulness and risk tolerance are a potent pair.

One of the things we are using it for is for running wasm workloads with cluster networking on K8s. A shim like this makes it simple to construct a small OCI image since all that needs to be included is the wasm module, rather than needing the wasm module and the runtime (500k vs 20MB). Basically, you can define a service and a deployment much the same way as a normal container image and it just works.

What is the common spec for Knative? It seems like one runs an app as normal in a container and then the special scaling sauce is handled by Knative.

When I think of a portable spec for serverless, I think of something more like a Trait of an Interface that needs to be implemented, less a app hosting model. If you think about it like that, then Web Assembly component model [1] would be a great fit for defining an interface that could be implemented in a variety of languages.

[1]: https://github.com/WebAssembly/component-model/blob/main/des...

Been using cloud-init on Azure Linux VMs for a long time (5+ yrs). Did you experience this on a specific distro?

Azure has an incubation project which is building a Golang CRD generator and a generic Azure resource controller [k8s-infra]. It will likely end up being used in Azure Service Operator [ASO].

[k8s-infra]: https://github.com/Azure/k8s-infra

[ASO]: https://github.com/Azure/azure-service-operator

The management cluster is definitely a pattern. Cluster API is designed to have a management cluster to build workload clusters across region and provider.

https://cluster-api.sigs.k8s.io/

A casual computer user is going to figure out they need to comment out a GRUB line?

Nope. That is an experience that will push them right back to OSX or Windows.

For quite a few, it is a _main_ goal for the speakers to either draw attention to their company's product or to provide an air of thought leadership on behalf of their company.

Isn't this the point of licensing?

The author or company building the software requires money in exchange for using their software. The revenue acquired through the license is then use to pay for additional development.

Revenue sharing seems to imply some kindness / goodwill agreement.

Check out https://gobuffalo.io/en/docs/testing/

Coming from a rails background, this was the closest out of the box testing experience. Tests are generally handled within a transaction and also offer fixtures and other goodies. Definitely recommend giving it a test drive.

> Of course, the stateful service feature is lost. But k8s does not have that feature either.

Persistent Volume Claims go a long way toward the stateful service "feature".

To go another step further on stateful services, SF's stateful services are only supported in a couple languages. Where mounting a volume in K8s which will follow your container is pretty darn accessible to any language.

You sure that's AMQP 1.0 or 0.9? I say that b/c ActiveMQ is AMQP 1.0 (http://activemq.apache.org/amqp.html) and RabbitMQ is probably running 0.9 unless you are using the experimental 1.0 plugin.

Nearly all the libraries working with AMQP 0.9 will not function when targeting an AMQP 1.0 service.

Also took it before the chat bot... :(

If you are thinking about a masters in CS, you must check out the OMSCS program. The cost to value ratio is completely off the charts!

"total program cost of about $6,600 over five terms"

So, get in your car at 7 am to get to work by 9 for your daily stand up. You then work your 9 - 10 hrs., because it's a good day and no major deadline looming. Then you get in your car at 6 pm (you skipped lunch or ate on the run) for your 2 hr drive. Instead of going home you go to the gym for a much needed workout, but sadly when you leave it's now 9:30 pm. Hopefully, you'll be able to grab some fast food b/c you have no time for a real meal. Finally, you get home at roughly 10:15. You are just in time to catch a show, set the alarm, climb into bed and get some zzz's before starting the grind tomorrow.

And that glimpse is without a family...

Thank you for the heads up about ruby devs liking *nix tools and not ide's.

The fact of the matter is grep is a poor tool to try to find your step definitions. There are tools out there that are much better for such things, vim with http://www.vim.org/scripts/script.php?script_id=2973, or an ide or <your favorite tool>.

You could make the claim that any abstraction is unnecessary if you see no value in it. It doesn't mean others will not find value in it.

Personally, I find it quite easy to understand and convey to non-devs the stories told through gherkin. That is part of the value prop for me.

If no one is reading them but the devs, I'd rather use something other than gherkin.

Disclaimer: I'm not for or against the use of cucumber.

The second claim against cucumber / gherkin is not it's fault, it's the toolset's fault. Using grep to find your step definition is not very effective.

If you use a tool like Rubymine, you can jump directly to the applicable step definition through one key combination.

News site via an iOS sim, so I can read more news in the browser. Turtles all the way down.

I still get a kick out of seeing apps running in the browser. It blows my mind. Oh, quick link if you want to try a few https://www.cisimple.com/featured_apps.

true story. we could do worse than moving toward something like: http://stateless.co/hal_specification.html.

I'm not knocking what you are doing. I love the effort, and I think it will improve developer experience for the most part. I'm just raising the questions of "Should we have to do this?" and "Didn't we go down this path before?".

The thing that the library is doing, is now replacing a wsdl with an expert that develops a swagger document. This to me sounds problematic. The wsdl had some idea of versioning of the contract, and was dependent on the developer of the service to update the wsdl with updates of their service.

I imagine, and correct me if I'm wrong, but the swagger doc will have to updated by the expert per release of the service (obviously, pending any implementation changes of the service). This actually puts the consumers of the framework at risk of incompatibility via 1., the developer changing the service, and 2., the expert not updating the swagger definition upon 1. Is this accurate?

Please don't take this as me saying that I'd like to go back to wsdls. That is certainly not at all what I'm advocating.