I did this 10 years ago. I now run windows server as my windows guest so I dont get all the client cruft. Works like a charm

Could this be used to infer the alignments done by the creators of the models by passing in a common set of questions to before and after and then comparing the results? Would be interesting to see what Elon has done to his XAI model in comparison to OpenAI.

There is a Rust based browser project ongoing that can use this (if its not already).

Considering that Microsoft was a completely different beast in that time, I'm not surprised it does not seem that silly.

M$ (appropriate name for that time) of the day was doing its best to own everything and the did not let up on trying to hold back the open source internet technologies until the early 2010's I believe. Its my opinion that they were successful in killing Java Applets, which were never able to improve past the first versions and JavaScript and CSS in general was held back many years.

I still recall my corporate overloards trying to push me to support IE's latest 'technologies' but I resisted and instead started supporting Mozilla 3.0 as soon as they fixed some core JS bugs for our custom built enterprise JavaScript SPA tools in the early 2000's. It turned out to be a great decision as the fortune 500 company started using Mozilla / Firefox in other internal apps in later years long before it became common place.

I don't think it was Microsoft that killed Java applets. I mean, for one thing, they always worked in IE, which was really the only avenue through which MS could have affected them.

No, Java applets failed because they became the poster child for "Java is slow" take. Even though it wasn't exactly true in general, it was certainly true of applets, what with waiting for them to download and then waiting for the JVM to spin up.

What killed them was 1) HTML/JS itself getting better at dynamic stuff that previously required something like applets, and 2) Flash taking over the remaining niche for which HTML wasn't good enough.

Another reason Java applets ultimately failed was the never-ending stream of sandbox escapes, which is inherent to their design of running trusted and untrusted code in the same VM and trying to keep track of which is which. It turns out it's much more straightforward to sandbox the whole VM.

A representative vulnerability is "trusted method chaining". You (the attacker) construct a chain of standard library objects that call each other in unexpected ways. You can make use of the fact that you can subclass a standard library class and implement a standard library interface, in order to implement the interface methods with the base class's implementations, to construct more unusual pathways. Then you get some standard library entry point to call the first method in the chain. Since your code doesn't appear on the call stack at any point (it's just the standard library calling the standard library) whatever is at the bottom of the call stack, at the end of the chain, infers a trusted context and can access files or whatever. Of course, finding a method chain that's possible to construct and does something malicious is non-trivial.

Even prior to HTML5 stuff, Flash was just a better UX than applets, which always felt like your browser was loading an application, vs being an element in a page.

Java Applets also froze the entire browser when loading. Even more so than the Windows Media / QuickTime / Real Player plug-ins. Only the Flash plug-in didn't noticeably freeze the browser. It was heavily CPU optimized and even used AVX for rendering, as far as I remember.

> > No, Java applets failed because they became the poster child for "Java is slow" take.

> Java Applets also froze the entire browser when loading.

More than just "poster child", I believe Java applets are the origin of the "Java is slow" meme. The first time many people heard of Java would be when it locked up their browser for a whole minute while loading an applet, with a status bar message pointing to Java as the culprit.

Applets died because of many reasons, like absurd startup time for the JRE (often just for silly animations), absurd memory requirements (for the time) and associated crashes, weird compatibility issues in the initial releases of the Java platform, a silly security model based on the assumption that only good actors will be able to get a CA certificate in order to do whatever they want in your PC, an immature sandboxing technology in browsers (not only IE), etc.

> M$ (appropriate name for that time)

It’s even more appropriate nowadays, I’d say.

M$ used to be an appropriate name for Microsoft. It still is, but it used to be, too.

Never not been appropriate.

Yeah, it’s just that Googl€, A₽₽le, etc. have all caught up with them. If they’re all the same then there’s less of a need to differentiate anymore.

A₽₱le!

Microsoft hasn't really changed that much besides getting a better PR department.

They've adopted a different flavour of devilishness. See VSCode versus Visual Studio, or their approach to AI.

Bill Gates would've bought OpenAI. Satya shares their mission of developing AI for the good of humanity. He charitably donated billions of dollars in Azure credits in exchange for nothing besides a voice at the table and a license to help enable other organisations use AI through MS services.

In a way it's a PR difference, but I feel that understates the change.

It also has a lot more competition in the Evil Big Tech Co space than it used to.

Then there was Amazon: https://github.com/aws/s2n-tls

I had high hopes for s2n, but looks like it never really caught on outside of AWS.

Microsoft is still trying to hold back everything they can - they're just losing.

Brodie Robertson just posted a YouTube video summarizing this including Linus’s response. It’s definitely a doozy. I’d be interested to hear the BSD folks perspective on this.

While researching which SCS to use at Honeywell in early 2000’s, I read the RCS thesis and it was short concise and a fantastic read. I recommend any SCS N00b’s to read it first.

Thankfully at the time, I chose SVN over CVS and although SVN was only at v0.8 my small team never lost any data. I never regretted my decision.

Correct. I just checked the project yesterday and they are presently at 3.4 :-|

I don’t recall paste w/ formatting ever working well. IMHO, the OS’s should allow for some global config for default for Ctrl-v, Ctrl-shift-v.

I did a very rough BOM analysis of just the raw components and if you buy them at their highest rate (1pc cutoffs), the raw component cost excluding the PCB was about $100 USD. My guess is you would be looking at about $200.

Personally, I would be jumping in if I could buy a fully populated PCB and take care of 3D printing, final assembly and software. However, doing electronics like this is far out of my wheelhouse.

Thanks, this was very helpful to me. At $200 with no subscription fees, I would definitely consider one of these for my dog. :)

Love this. I’ve written a ton of Python in recent years but never used the ‘is’ operator. After reading this I’m glad I did not.

I can see usecases but clearly it should be used sparingly.

To be honest this response underscores the problem with pages like this. In Python, strings and numbers are objects, and “is” tells you if they are the same object. You wouldn’t compare strings or numbers in C using a pointer comparison, and you shouldn’t do it in Python either. The fact that it works sometimes in cpython is a coincidence.

It’s interesting to learn about how the interpreter is implemented, but that’s about it.

You should absolutely be using `is` where appropriate. `x is None` is almost always preferable to `x == None`. If you're checking for object identity, use `is`. If equality, use `==`. They're different use cases.

Especially since == can be overwritten, while 'is' can not.

That's right. Any class can define its own __eq__ method.

How is that your response, after reading this article? The is operator checks whether the two items are the same object, which is critical in some circumstances.

How do you check for None?

Or check that two dicts really are the same object, as opposed to two different dict objects that just happen to have the same keys/values?

I'm not sure I've ever had to do that. When is that a need?

My immediate first thought is, optimisation? If you know you’ve been the same object, you could skip e.g. comparison, or change update logic

This kind of micro optimizations don't make much sense in Python. They complicate the code, and you are still 100 times slower than compiled languages.

It really… doesn’t have to complicate. And I disagree that optimising python code is never necessary. Not everybody is writing 100-line one-off glue scripts.

Also, you are somewhat changing the topic from “what is an example of when you might want to is-compare two dicts”, no?

You are correct. I kind of took `is None` for granted as it just feels boilerplate when coding in Python.

Although I have written over a hundred thousand of lines of code in Python over the years; I use Python mostly for dev ops tooling, reporting, monitoring and automation so they don't get super complex and they mostly can lean on procedural programming patterns.

I could imagine complex frameworks needing heavy use of Objects that could lean on the 'is' keyword.

I personally do use "if var is None:", but can't you just use "if var == None"?

‘is’ checks if it the object ids are the same, with None having a unique one. Equals can be tricked.

Here’s a class that is equal to None, and everything else:

    class EqualsEverything:
        def __equals__(self, other: Any) -> bool:
            return True

Thanks, I saw this on SO too.

Just curious: would it ever happen in practice?

every little thing happens in practice... usually unnoticed and buried while refactoring something innocent/ly.

sooner or later the __eq__ method will be redefined for some class, then reworked, and then.. == None might not be what was supposed to be..

or, my favorite, x='a' ; (x,)[0] == x[0] == x .. but are only equal until x changes to something not-1-long-sequence..

I try to avoid statistical programming, preferring determinism, driven by intent. ;)

So, I use "is" since "is" is not a context dependent concept, like equals is. I've seen this once in the wild, and it made sense for its use:

    def __eq__(self, other):
        return bool(self) == bool(other)