galaxyLogic

Not so shocking. If AI can analyze human brains and detect tumors from X-rays, why couldn't it see something wrong with its weights?

The closest thing to this would seem to be Mad Cow Disease. Cows eat the brains of other cows, and their brains go bonkers.

So they are reading and analyzing the weights and probabaly run some experiments to see how modifying them will make some answers better. makes sense they can do that.

But how do they know which answers are "better"?

So it's like a smaller LLM can learn from a bigger one, but not vice versa.

But shouldn't the model-providers be the ones doing this kind of "post training learning"?

I've thought about this, tests should be easier to add to your modules. We dont' need a ton of tests, but we need them to be in more places.

Tests fix how the software can be changed and when software-spec evolves lots of tests can become obsolete. Maybe with AI it is easier to change the tests (?) which is good.

But there is another purpose for tests, besides "testing". It is to document your modules in a way that shows you how to use them, and let's you easily verify is this still working, can I trust it.

Don't we all have "second intentions"?

Altruism happens usually among members of a tightly knit group, like family members or soldiers of a given unit. Teachers sacrificinng their life to save children. FOSS-developers, are they really producing software out of altruism? Maybe some of them are but it is hard for us to know whether that is so or not.

I recently had a somewhat similar task: My 80-year old friend who is on Medicare got a $30,000 hospital bill which the insurance company declined to cover. So he wrote by hand a letter to the insurance company to request a reversal of their decision. I scanned his hand-written letter and asked AI to turn it into text (to create a professional looking letter). Could not get that to work on Gemini nor Perplexity, but it worked on Co-Pilot.

It did save me a lot time to use AI, especially should next time since I now know which AI app can handle it. So, there was a bit of overhead before I found the AI-app and prompt that would do it.

I have another friend who works for SAP as a project manager. She said she hates the fact that management wants them to use AI for everything, giving them a bonus if they do. But one reason I think their employer insists on that is that when you try to use it for real tasks you discover what works and what doesn't. Gradually we should be getting better at it.

Currently there is still a penalty caused by

1. AI not being able to do a specific task

2. Users not knowing which AI-app can do the job and

3. How to prompt the AI to get it done.

Writing the prompt is what users must do, and writing a prompt that works is a skill they must learn for every task you want AI do for you. Therefore progres is is happening but incrementally.

Farming could use all kinds of robotic work right? Let the AI seeders and harvesters on the field.

I'm interested in what will happen with factories, why couldn't robots do all the work? Well maybe not ALL the work but most of it.

Yes, someone has to make decisions, and that takes a lot of work too. AI can't do it for us because we the humans must make the decisions.

Maybe there should be an app just for doing mail-merge. That should be fairly simple I assume?

Neverthelessx having the ability to use clones helps when negotiating with MS.

Benefits of Xylitol for teeth were discovered in Finland in 1970s see link below. In Finland I think by now most candy can be bought either in the xylitol- or non-xylitol version. If this was the case also in the US I suspect it could have a major impact on national (dental) health.

And here's a question: Do dentists promote the use of Xylitol? If not, why not?

https://www.google.com/search?q=history+of+xylitol+in+US&rlz...

I'm also happy using Common-JS syntax on the Node.js. In the odd case that both the client (browser) and the server (Node.js) should run the same code, it can easily be accomplished with minimal amount of code-duplication. And such code-duplication can actually be good reducing the number of dependencies that could break in some future version of the software.

Just saying don't throw out the Common-JS sub-system with the bathwater.

The problem with ES6 modules (imo) is it does not support sync loading of dynamic imports, so you have to figure out how to handle the Promise.

My issue is buying groceries from Amazon. You have to fill up your cart to > $30 to get a free delivery (in NYC). So you start searching for whatever you might want to include to get the free delivery. But the items like milk can come from

a) Amazon ("proper")

b) Amazon Groceries

c) Amazon Fresh

d) Whole Foods

Each of these have their own "cart" which must have goods > $25 etc. to get a free delivery. If you add an item from another list it does not count, so you must add things which you maybe don't really need just because they come from the same list as milk. Or, you will need to fill up multiple carts.

Then once you reach the threshold for free delivery and make the order, you may, or may not notice an extra line in the total bill: A tip for $5 in very small print which you have to edit away, or it is NOT FREE DELIVERY AFTER ALL, like promised.

What I lament is that Amazon is making me feel guilty for not tipping the delivery person. It is making me take extra action to NOT tip -- I must be a bad person. And it's making delivery people angry at me if I don't include the tip. And Amazon is adding the $5 there always as a default, even though they already said I have earned a free delivery.

It's a transaction between me and Amazon but now Amazon can implicitly blame bad service on the lack of tipping. I assume they would like to not pay their delivery people at all, just let them live on the tips.

"entire Deno team is joining Cloudflare .."

Whom did they work for before?

I wonder how easily could you port celld to Node.js?

Why Edge of Node.js?

We need them so you can pick and choose the one that works best for your current project.

But that points to an important aspect of the platforms-game: The interface between the runtime and everything else should be standardized, to support true pick-and-choose.

Maybe but only if that gives them a competitive advantage.

I wonder if TS could evolve into a compiler whose output would use either Deno, Bun or Node? When the exe is compiled it no longer matters what libraries it uses underneath?

And seems they want to compete with Anthropic, by having expertise on JS runtimes? A big feature I think is the ability to produce an executable application and have your AI agent-tools work well with that.

I'm using Vercel PKG to compile my JS code to executables "nicely".

But PKG is not supported by anyone any more (?) and it has an upper limit on the version of Node.js base-image it will support.

If Bun supports compiling executables nicely I hope that feature somehow stays alive and is migrated to other runtimes. Or maybe it can become a standalone tool for exe-compiling?

I wonder what happens if AI itself would make such a threat?

> getting by honestly is just a way more comfortable

I think it's also much about self-esteem -- am I proud of myself? And criminals probably think highly of themselves when they succeed in their crimes.

Are you saying AI might become the Big Brother?

Good point. I've though about my own mental attitude when interacting with AI agents. When they do something good I feel like saying "Thank You". Does that make sense? I guess it does because it communicates to the model their output was correct. But it feels silly to say "thank You" to a machine. I guess I just have to get over it?

Isn't this much the same as OpenClaw or Hermes?

I think it's a good thing that AI providers are "coalescing" on an agent-model, by producing competing agent-products.

But so what would be the benefit of "Dots" over OpenClaw, Hermes, and Muse?

The problem I encounter with async/await (in JS) is that while an async method can call a non-async-function and do somewthing with the result of that, the reverse is not true, a sync function can call async-function but can not us the result of that in any way, except pass it on or upwards.

What makes it worse is that you can not simply modify a sync-function to become an async-function, if it has existing callers because those would likely break them.

This affects the whole tree of possible function calls in my program. If at some level I have a sync function but I see it needs to get to some data that only async fuction can provide, I may need to change a whole call-chain of my call-tree, not just modify a single function in that tree.

Then as I develop my program I need to make the decision for every function; should it be sync or async? In many cases it could be either one so which should I choose? Making it async would seem to make it easier to evolve the program later. But then would it make sense to make every function async?

The British rock-band Traffic said it in their "Low Spark of High-Heeled Boys" : "... we were children once, playing with toys".

I wonder if it's true that people don't remember. People maybe remember but don't want to talk about it. It is such a cognitive dissonance.

LLMs are "readonly" I guess for several reasons:

1. Technical cost of updating the mode.

2. Inability to trust every user's "truth".

3. Ability of AGENT-HARNESSES to learn with the help of the human user.

So agents learn, LLM already knows everything it will ever know, and ESPECIALLY it has already learned how to understand human language.

No 3. above means there is no danger of the LLM getting corrupted. But the agents running on user's machine learn on behalf of that user who shares the machine with them.