Ironlink

Our system in EU observed some slowness and a few 500 and 503 responses from `identitytoolkit.googleapis.com` over a period of about 10 minutes.

Once withers land, I think you could approximate this by letting your record class have a zero argument constructor which sets every field to some blank value, and then fill the fields using `with`.

  var x = new Car() with { make = "Volvo"; year = "2023"; };

If you want the Car constructor to enforce constraints, you could use this pattern in a separate Builder record:

  record Car(String make, String year) {
    Car {
      Objects.requireNonNull(make);
      Objects.requireNonNull(year);
    }

    record Builder(String make, String year) {
      Builder() {
        this(null, null);
      }
      Car build() {
        return new Car(make, year);
      }
    }
  }

  var x = new Car.Builder() with { make = "Volvo"; year = "2023"; }.build();

Obviously syntax TBD.

It probably means simply that the paths to the jar files cannot change between the training run and the actual run. So any valid path/location is ok as long as it stays the same.

> You can't just run Java code. The JVM has a lot of tricks you have to customize for based on your workload.

This sounds like something you would hear 10 years ago in relation to the CMS garbage collector. Since Java 9, G1 has been the default gc for multi core workloads and is self-tuning. The CMS gc was removed 4 years ago. If you do need to tune G1, the primary knob is target pause time. While other knobs exist, you should think carefully before using them.

We run all of our workloads with vanilla settings.

Not sure what type of complexity you're referring to, but it handles many file formats, though some better than others. For example, it supports using variables for the version number in Maven but not in GitLab CI. It handles private package repositories, and updates package-lock.json.

As someone currently using Renovate, my main concern would be cost. Renovate is free, and LLMs + RAG seems like it would cost money.

My best guess is that they are thinking of CSRF. With cookies, requests automatically carry the token, whereas with local storage you need to explicitly add the token. However, CORS does a lot to improve this situation. I note that CORS allows posting form data without pre-flight, but it is not immediately clear to me if posting a form cross domain will send cookies.

I like Podcast Addict, it's very configurable.

For example, when I found a table top RPG podcast with 7 years of history, I set it up with:

  Archive mode (start from the beginning of the RSS)
  Automatic download

In my global settings, I have it set to keep at most 5 episodes per podcast. The result being that when I was done with one episode, it would automatically download the next, and I had a buffer of 5 episodes for trains and flights.

I use Firefox Developer Edition exclusively and work using GitLab (SaaS) daily. I also have uBlock Origin installed. I have never had an issue.

Does this impact B2B lead gen, or just consumers?

I can't find anything in the linked eg-draft that would indicate that the error would "occur later". In fact, it explicitly says:

    Note too that if the canonical constructor checks invariants, then a with expression will check them too. For example:
        record Rational(int num, int denom) {
            Rational {
                if (denom == 0)
                    throw new IllegalArgumentException("denom must not be zero");
            }
        }
    If we have a rational, and say
        r with { denom = 0; }
    we will get the same exception, since what this will do is unpack the numerator and denominator into mutable locals, mutate the denominator to zero, and then feed them back to the canonical constructor -- who will throw.

In case anyone is looking for the size of the surcharge, I found it in the last row of this table: https://www.federalregister.gov/d/2020-16559/p-555

I wish they would reuse the pattern of Cloud SQL where you can get temporary access without manually handling the Authorized Networks setting. The Cloud SQL API lets you exchange your API access token for a short lived TLS client certificate. This is done client side by things like cloudsql-proxy[1] and the cloud-sql-jdbc-socket-factory java library[2]. This way, I can access my Cloud SQL instance from my IDE, even though my list of authorized networks is empty.

I feel like the gke-gcloud-auth-plugin cloud do something very similar.

[1]: https://github.com/GoogleCloudPlatform/cloudsql-proxy

[2]: https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket...

If I wanted to build a Twitch clone for internal social activities at my company, would this be a good tech stack for that or is WebRTC not the right fit?

I use Google Meet with Firefox on my M1 Mac every day. The only thing that doesn't work for me is camera backgrounds. Would be nice to be able to share audio when presenting, but I almost never present.

According to their user guide, the only patch they have is the branding change: https://docs.aws.amazon.com/corretto/latest/corretto-17-ug/p...

I'll keep using the OpenJDK Docker images.

I use https://startpage.com/ instead

Good search results, with privacy

I guess the only course of action would be to work to make the leaked information out of date. You could change your name and address. Personally, I would not pursue that option.

On the contrary, I think it is quite normal to leave a positive review when you've had a good time at a restaurant. When I look for restaurants, I certainly read both positive and negative reviews.

You make this almost binary by using food poisoning as your metaphor (either you get it or you don't), but normally there is a much more nuanced range of experiences.

The article says:

> The company gained unauthorized access to the heart of the mobile network from China.

... but then, in the very next sentence:

> How often that happened is not clear because it was not recorded anywhere.

This wording is a bit unclear. The first sentence states as a matter of fact that there was unauthorized access, while the second states that there are no records.

My Firefox Developer Edition (86) doesn't load the page completely, one of the resources (https://gweb-cloudblog-publish.appspot.com/api/w_v2/pagesByU...) has an untrusted certificate (SEC_ERROR_UNKNOWN_ISSUER). It is issued by "Cisco Umbrella Secondary SubCA".

"Cannot" seems a bit harsh. CompletableFuture isn't going away, and is made for callback situations.

With green threads being "free" (you can have millions), it might be reasonable to just block your green thread until the callback arrives.

My naive response is that if the socket buffer you're trying to write to is full, there's backpressure. What am I missing here?

Right, but that requires your new workloads to fit well with the resources you have committed to. If you've committed to many small machines, they may not be well suited to an especially heavy workload. If you've skewed your commitment towards a large amount of memory per compute (or vice versa), you can find yourself with lots of RAM (or compute) and no natural use-case.

At the bottom line, commitment impedes change.

I dislike the concept of committing to use. It creates a disincentive to optimize jobs, because "we've already paid for three years of this".

That's not entirely true:

Pixel phones get security updates for at least 3 years from when the device first became available on the Google Store, or at least 18 months from when the Google Store last sold the device, whichever is longer.

https://support.google.com/nexus/answer/4457705

Seems to me that one key difference would be that giving javascript access to UDP sockets easily enables a single browser to send huge amounts of traffic since there's no ACK to wait for. With anything based on TCP, the attacker at least has to put some effort in to achieve that.

Correct. The parameter of those methods use(d) a class from the Swing desktop UI toolkit, and logging can't depend on that.

Parameter class in question: http://download.java.net/java/jdk9/docs/api/java/beans/Prope...

You make a great point. To me, Google Search is a bit of a special case in that the data it provides has been posted publicly. Unless the Google Cloud ToS give them the right to publicize your business data, that's out of the question.

Another point here is that Google Search isn't an authoritative source of information, it is up to the end user to inspect the returned links and decide if they can trust that site. This is something that I would not try to automate to the point that I could ask users for money in exchange, and if it can't be automated it doesn't seem like a great fit for Google.

First of all I think they are too smart to jeopardize their entire cloud service in that way; no one would buy that. Ignoring that, I would think inspecting cloud customer data is much too unreliable to be of any use to them.

Before anything else, the format and schema of the customer data would have to be analyzed and converted to data structures that match Google's internal models. While I imagine a computer could do it, I certainly would want a human to verify that the analysis makes sense.

Assuming this has been done, they are then at the mercy of the customer as far as whether the data is accurate, whether it is complete, how often it is updated, etc.

At the end of the day, I don't see how they would build a reliable business around arbitrary data structures which they have no control over. Information you can't trust is pretty useless.

Edit: They would also have to understand how the data was selected. Looking at a series of data points, you would wonder if all these are from Arizona, or all from the year 1976, or all from color blind individuals. Without understanding such limitations, making any sort of deduction from a dataset will just lead you the wrong way.