jbreiding

Give https://github.com/abiosoft/colima

A try, I’ve been using it for a few months on both m1 and x64.

It works really well.

While I haven’t run rancher desktop, i have been running colima.

https://github.com/abiosoft/colima

Which also is built on top of lima.

It’s been great, some network wonkiness, and works on m1 perfectly.

The rancher devs have been contributing back to the project helping improve both.

I’m not sure about hidden dependency if the metrics break immediately. Important metrics should have alerts when absent or change unexpectedly.

Communication and the decision to depend on the logs as a source of metrics would be key to keeping these systems connected and functioning.

Taking a dependence on logs based metrics without communicating that is the failing here.

The same breakage could happen by depending on the event being emitted and a developer changing the event structure.

Communication and understanding helps both scenarios, not duplicating the effort by emitting logging for debugging, events for auditing and metrics for business.

Logging should be treated as a source for events.

Most log collecting solutions have ways of producing metrics and alerts from logs.

It takes more discipline to be able to understand why a metric or alert happened without supporting logs.

Sourcing logs from multiple services, including dependencies, allow for creating more intelligent metrics.

Treat logs as a stream of events rather than noise created by developers and logs become more useful.

My word choices might not have been the best here.

But consider if everyone was able to take the first year at some percentage less of regular salary. Then public funded care available with learning included?

My wife would have preferred this to having exhausted fmla just before giving birth because of early complications.

Returning to work was not an option for her, 6 years later returning to work was one of the most emotionally draining experiences for her.

I would argue we just need to bring public school earlier.

We don’t need this tied to an employer like health insurance as this is something that benefits us all.

If you had access to all the necessary information, what would the formula look like that you would have to track at funding rounds to give any early indication that as an employee you're not going to make anything.

This is something that I have been thinking about lately and I am just not well versed enough to know what inputs I need to build this.

I would like to be able to have a some sort of data driven risk assessment.

I would love some input here and would like model this and track when it's time to say goodbye.

I believe it's data privacy advocate?

Here is a guide I've found useful in the subject, https://engineering.fb.com/security/scalable-and-secure-acce....

I used rocketbook for a time and it worked really well. Just the erasing and having to use specific pages to take notes on meant I couldn't just grab anything to take notes on and archive it with search capabilities.

This seems like it could be nice to tinker with building something similar.

I prefer hand written notes but prefer to be able recall the notes digitally from a search.

I think the terminal output is the figma viewer. I have a hard time seeing the point of the role and software if a front end developer has to hand translate the design to actual code or styling.

Graphql is generally referred to as be4fe, meaning backends for frontend.

Not exactly client side, but the main consumer is the client and s2s or service to service isn't intended target.

For me it's where I'm developing a task to do stream processing and classify the data by an arbitrary subset of the data and don't want to model the entire structure to avoid losing/changing the original data structure.

I'm sure there's better ways to do this, but that's an example I'll throw in.

#1 seemed to work for Amazon didn't it? Sure it put some of the way they do business under a micro scope, or unneeded attention. But musk seems to not care too much about the attention.

Charter schools seem like the best opportunity to vet this style/evolution of education.

There are sure to be holes, like does this lead to treating the in person teacher as a commodity and reducing the value of that in person time?

But definitely this is a time for disruption in this space.

Have you tried mermaid? I guess it really depends on the editor and viewer you are using.

I've used this mostly with vscode and rendering from gitlab/hub, https://marketplace.visualstudio.com/items?itemName=bierner.....

It's the difference between service orchestration and choreography, respectively.

There are pros and cons to each approach, and the details matter with regard to how services will be scaled and the coordination of that scaling happens.

There are lots of finer points in the details, but knowing the difference between the two approaches can help with the decision making process on which path the adopt.

This may be difficult to grasp. But likely where you are seeing this feature is in a corporate setting where you are the "end user", not the paying customer. The corporate entity that is making use of this feature is who you should be protesting the use to, not Microsoft.

It's more of intranet plus internet search. It may appear like filesystem but that is because it's searching internal services like SharePoint to the company that has chosen this integration.

It's also not mixed in, last I remember using this feature it was displayed in a banner section and made it really obvious these results came from a different sources.

-H for header

-d for data

-X for execute

There was a reasonable attempt at this already. There are going to opinions on either side. And through regular use the flags would become muscle memory.

Really the need for a decent text editor out of the box isn't necessary if support for chocolatey repos is the first thing installed.

Having a simple/sane package management either out of the box or within a single step is really the right pattern to enable ease of installing whatever your text editor/customisation of choice is.

Yeah, I share that same feeling.

However, where this starts to break down is highway miles. Shifting into overdrive and having no lights for miles, coupled with the always connected to work ethic might have different results.

I do think it ultimately comes down to culture and conditions on the road.

I can only speculate, but I would say this data doesn't disprove the causality of the other cohorts. Just because the results are absent in another region it doesn't mean those same conditions will yield the same results, although it's idea of something to try.

Owning a smartphone and using it while driving aren't the same thing. I think work culture differences my contribute more than mere smartphone ownership.

This makes sense, give both feet and both hands a role in the driving process and we are forced to pay more attention. Perhaps we need to turn the shifters of automatics into Simon says games where if you lose the pattern you hit a soft rev limiter.

Sorry but those choice of words, 'tend to not buy', does not sound like it's backed by evidence or facts. Similarly to the parent who used anecdata. I myself see an alarming number of people on phones in cars, it's more of a distraction than eating in the car. It is hard to argue that we've not become more and more distracted as we drive, that is the problem to fix. With commutes getting longer, not shorter it seems like an up hill battle.

So code generation isn't an anti pattern, persisting the artifacts generated is? To me that is still code generation, one is more durable and able to be tested, the other is a runtime exception.

I've not seen any long lived python projects that don't end up implementing runtime checks to validate the shape of these generated objects.

I've always solved this with unit/functional tests. The test runner effectively acts as a compiler, for the purposes of checking the contact. in this process.

This is something that's baked into a gate check on merge to the source repo. Or rather it should be.

Sorry, I've heard this statement a few times, code generation in dynamic languages is an anti pattern. Do you happen to have any more reading on this?

Sure the generated code is usually not readable which is against the zen of python. But writing code to generate code, especially if it's contract driven, is the correct approach no matter the language.

So really what I'm looking for is more substance of why generating code is an anti pattern in python but not in C.

I've always thought this was really obvious. Benefits tied to employment will stifle entrepreneurs who aren't already well off.

This tips the scales towards the largest employers for labor, how many low paid internships could be replaced by high risk startups?

Before anyone has had a chance to accumulate to many obligations, that is the perfect time to grow by taking a risk and going after something disruptive.

That also would be the time in which many have the energy and optimism to do good rather than for greed or meeting obligations such as feeding/housing a family of four.

Not the consumer as I read it but the credit issuer would have to collect this evidence, so they would have the burden. Also this would help build a reputation that is auditable of the credit issuers.

This feels like an idea that would benefit consumers and be a business opportunity targeted at creditors if we could only convince them this is their responsibility.