fxj

R is already a Lisp dialect disguised in algebraic syntax. Here is the first example in R:

  factorial_recursive <- function(n) {
    if (n == 1) {
      return(n)
    } else {
      return(n * factorial_recursive(n - 1))
    }
  }

https://cran.r-project.org/web/packages/codetools/codetools....

then gives:

  (<- factorial_recursive (function as.pairlist(alist(n = )) 
    ("{" (if (== n 1) 
      ("{" (return n)) 
      ("{" (return (* n (factorial_recursive (- n 1))))))
    ) NULL)
  )

You think Lisp is hard to read? Then try J! And still people use it and are very successful. It is not always the ease of readability but the power of the syntax that makes a good programming language.

https://www.jsoftware.com/

p.s. R is Lisp with a nice syntax. Much more readable and still very powerful.

just my 2 ct

FYI: The problem at hand is an existence problem. No real construction of any real formula for the solution is provided, only a singular perturbation expansion.

In short: The problem is about whether a solution (of the NS Equations with external driving force) can be found that blows up in finite time. i.e. exhibits infinite velocity at a point even for a viscous flow.

The solution: Take a circular curl ansatz which shrinks in xy-direction and elongates in z-direction and see whether you can find linearized waves so that these waves show a blow up when propagated on the curl. Then prove that the higher orders of the perturbation are regular before the T0 singularity time and you have solved the problem. The external force is just the remainder of the NS-Equation right hand side.

It is a lot of tedious formula juggling of all the higher orders and some singular perturbation expansions. Perfectly suited for algebra systems. OpenAI was using probably python sympy for the formula work and the researchers had to guide the LLM what to do in higher mathematical language.

Here is the paper:

https://cdn.openai.com/pdf/32d9f210-8b73-45e0-91bc-82a30aef8...

when you upload it to chatgpt astra can explain what they do and why it works, have fun.

wow it is great to see that there is still life in distributed programming languages. I would like to know what are the differences to MPI programming, chapel and PGAS languages like Co-Array Fortran and the rust extension ChoRus?

Can you you give a hello world example in each of them and show where your languages shines?

There is a free emulator here:

https://www.fullbucket.de/music/fb3300.html

The PS-3300 is a 3 layer synth with 49 voices where each voice has its own VCO/VCF/VCA. So you end up with 16 voices when you use 3 layers. It has microtunality and a reverb for each of the layers.

Here is a sound demo:

https://soundcloud.com/full-bucket/fr33ze?utm_source=clipboa...

I think the battery life of a smart watch cannopt be underestimated. I have all the old pebbles which I love darely but then I got a Amazfit Bip and I stayed with it until today. One month (!) of battery time with a HR sensor and notifications is all I need so why ever change.

I dont know why apple, samsung and google are not getting it. But I would not even touch one of their products with a 2 feet long pole.

Just my experience and 2 ct.

And one thing: Pebble2 is really really nice, but 200 euro? The Amazfit Bip is (was) 40 euros. Why the price difference?

People talk about a Butlerian Jihad against AI as if you could just ban LLMs and be done. I bet some govermenst would like to do that for ordinary people. They can ban visible products (chatbots, public APIs, GPAI services), and laws are already targeting those.

but you cant ban the math!

the same transformer/attention ideas work great as compressors, function approximators, and surrogate models in physics, chemistry, CFD, etc., where they show up as "PDE‑Transformer", "Neural Operator", or "Hybrid Surrogate Model", and not as "chatbot". ;-)

So even if you outlaw certain AI uses, the core tech will just move into scientific and engineering workflows under different names, where most people won’t recognize it. Would be interesting whether it is possible to write a LLM-like program just using compression and function interpolation algoritms.

just my 2 ct

One thing to consider:

The (well-known) Sapir–Whorf hypothesis (if dont know it, look it uop) is often invoked for natural languages, but there’s a pretty direct analogue for programming languages: the language you "think in" during solving a problem biases which abstractions and idioms you reach for first.

If you force an LLM to first solve a problem in a highly abstract language (Lisp, APL, Prolog) and only then later translate that solution to C++ or Rust, you’re effectively changing the intermediate representation the model works in. That IR has very different "affordance", e.g.

- Lisp pushes you toward recursive tree/list processing, higher‑order functions and macro‑like decomposition. (some nice web frameworks were initially written in LISP, scheme, etc...)

- APL pushes you toward whole‑array transforms, point‑free pipelines and exploiting data parallelism. (banks are still using it because of perforance)

- Prolog pushes you toward facts/rules, constraint satisfaction, and backtracking search. (it is a very high abstraction but might suit LLMs very well)

OK, and when you then translate that program into C++/Rust/python, a lot of this bias leaks through. You often end up with:

Rule engines, constraint solvers, or table‑driven dispatch code when the starting point was Prolog.

Iterator/functor pipelines and EDSL‑like combinators when the starting point was Lisp.

Data‑parallel kernels and "vectorized" loops when the starting point was APL.

In principle, an LLM could generate those idioms directly in C++/Rust. In practice, however, models are heavily shaped by their training distribution and default prompts. If you just say "write in Rust", they tend to regress towards the most common patterns in the corpus (framework‑heavy, imperative, not very aggressively functional or data‑parallel), even when the language would support richer abstractions.

By inserting a "thinking" step in a different paradigm, you bias the search over solution space before you ever get to Rust/C++. That doesn’t magically make the code better, but it does change which regions of the design space the model explores.

Same would also be true for python which is already a multi-idiomatic language. So it might be a good idea to learn a portfolio of different languages and then try to tackle a problem with a specific language instead of automatically using python/go/rust because of performance.

Something to consider...

p.s. how would a problem be solved when the LLM would have to write it first in erlang? Is it the automatically distributed?

p.p.s. the "design pattern" of the GoF comes automatically to my mind, which might be a good hint to the LLM to use.

You can of course use any language but here is my advice: you should use the language that you know best to make your life as uncomplicated as possible when you want to understand what the LLM was creating.

Remember, you are the judge whether the code is OK and if you use assembler you might get really performant code, but can you trust it?

Of course it might be a good incentive to learn rust or go. Or challenge yourself to learn something really cool like LISP, COBOL, FORTRAN, APL or J. (just kidding...)

just my 2 ct...

In the long run there is no alternative to really reading your codebase and understanding what is going on. You can leave the nitty gritty details to the LLM but you have to be in the drivers seat and know how the parts of your codebase works together. You have to be the architect and can leave the plumbing to the LLM, but dont try to make a plumber an architect.

just my 2 ct

God I miss openstep and CDE. It needs 16MB RAM (yes MB!) and together with a lighweight firefox clone you get everything you need. Eye candy is nice to have but not at that cost.

A claw is an orchestrator for agents with its own memory, multiprocessing, job queue and access to instant messengers.

He also talks about picoclaw (a IoT solution) and nanoclaw (running on your phone in termux) and has a tiny code base.

He also talks about picoclaw which even runs on $10 hardware and is a fork by sipeed, a chinese company who does IoT.

https://github.com/sipeed/picoclaw

another chinese coompany m5stack provides local LLMs like Qwen2.5-1.5B running on a local IoT device.

https://shop.m5stack.com/products/m5stack-llm-large-language...

Imagine the possibilities. Soon we will see claw-in-a-box for less than $50.

TOTP is also just password + some computation. So where is the difference? There is a lot of security theatre around TOTP with the QR code and then need of an app but you can write a 8 liner in python that does the same when you extract the password out of the QR code.

   import base64
   import hmac
   import struct
   import time

   def totp(key, time_step=30, digits=6, digest='sha1'):
        key = base64.b32decode(key.upper() + '=' \* ((8 - len(key)) % 8))
        counter = struct.pack('>Q', int(time.time() / time_step))
        mac = hmac.new(key, counter, digest).digest()
        offset = mac[-1] & 0x0f
        binary = struct.unpack('>L', mac[offset:offset+4])[0] & 0x7fffffff
        return str(binary)[-digits:].zfill(digits)

https://dev.to/yusadolat/understanding-totp-what-really-happ...

WebAssembly in the browser does feel great when you look at things like Pyodide/Pyolite, JupyterLite, xeus, webR and even small tools like texlyre – you get a full language/runtime locally with zero server, just WASM and some JS glue. The sad part is that VS Code for the Web never really became that kind of self-contained WASM IDE: the WASI story is focused on extensions and special cases, and running real toolchains (Emscripten, full Python, etc.) keeps breaking or depending on opaque backend magic. So right now the best “pure browser” experiences are these focused notebook/tool stacks, not the general-purpose web IDE people were hoping vscode.dev would become.

MCP is just a small, boring protocol that lets agents call tools in a standard way, nothing more. You can run a single MCP server next to your app, expose a few scripts or APIs, and you are done. There is no requirement for dozens of random servers or a giant plugin zoo.

Most of the “overhead” and “security nightmare” worries assume the worst possible setup with zero curation and bad ops. That would be messy with any integration method, not only with MCP. Teams that already handle HTTP APIs safely can apply the same basics here: auth, logging, and isolation.

The real value is that MCP stays out of your way. It does not replace your stack, it just gives tools a common shape so different clients and agents can use them. For many people that is exactly what is needed: a thin, optional layer, not another heavy platform.

Get money from donors. Wikipedia shows how that can be done. Or get money from the EU.

Mozilla is a strawman for google that they can claim there exists another browser that is not chrome because of antitrust laws. And now that Microsoft forcefeeds win11 user with Edge it will not take long and google doesnt need firefox anymore.

For sure I would give a donation to firefox if they would build a decent browser which listens to the user but not as they do now.

just my 2 ct

Does it run on M5Stack Tab5 or the CARDPUTER? Did anyone try?

I see it at our place that seniors get more productive but also that juniors get faster on track and more easily learn the basics that are needed and to do basic tasks like doumentation and tutorial writing. It helps both groups but it does not make a 100x coder out of a newbee or even code by itself. This was a pipe dream from the beginning and some people/companies still sell it that way.

In the end AI is a tool that helps everyone to get better but the knowledge and creativity is still in the people not in the input files of chatgpt.

In my experience AI is wikipedia/stackoverflow on steroids when I need to know something about a field I dont know much about. It has nice explanations and you can ask for examples or scenarios and it will tell you what you didnt understand.

Only when you know about the basic notions in the field you want to work with AI can be productive. This is not only valid for coding but also for other fields in science and humanities.

I agree, you need to know the "language" and the keywords of the topics that you want to work with. If you are a complete newcomer to a field then AI wont help you much. You have to tell the AI "assume I have A, B and C and now I want to do D" then it understands and tries to find a solution. It has a load of information stored but cannot make use of that information in a creative way.

Also AI cannot draw conclusions like "from A and B follows C". You really have to point its nose into the result that you want and then it finally understands. This is especially hard for juniors because they are just learning to see the big picture. For senior who already knows more or less what they want and needs only to work out the nitty gritty details this is much easier. I dont know where the claims come from that AI is PHD level. When it comes to reasoning it is more like a 5 year old.

Learning == Compression of information.

It can be a description by a shorter bit length. Think Shannon Entropy and the measure of information content. The information is still in the weights but it is reorganized and the reconstructed sentences (or lists of tokens) will not provide the same exact bits but the information is still there.

How good can you recreate an image that is described by words? Obviously not bit by bit and pixel by pixel. You get something that resembles the original but not an exact copy.

It is at least as lossy as jpeg compression. Details get lost and artifacts are generated.

how long would it take to do a complete memory dump of your brain by voice stream? days? months? years?

this is more like writing one's autobiography.

The question is: Is it like jpeg compression where the errors do not accumulate but the image comverges to a self inverse compressed image or does the data set converge to a single point which is meaningless?

just tried this: take the graph of the functions x^n and exp(x) how many points of intersection do they have?

chatgpt gave me the wrong answer, it claimed 2 points of intersection, but for n=4 there are 3 as one can easily derive. one for negative x and 2 points for positive x because exp(x) is growing faster than x^4.

then i corrected it and said 3 points of intersection. it said yes and gaev me the 3 points. then i said no there are 4 points of intersection and it again explained to me that there are 2 points of intersection. which is wrong.

then i asked it how many points of intersection for n=e and it said: zero

well, exp(x)=x^e for x=e, isnt it?

That not only works for compilation but also for more general code transformations like code parallelization with OpenMP in C and Fortran, Array-of-lists to List-of-arrays, or transform python code to parallel C-code and make a python module out of it.

I have created some pipelines this way where the LLM generates input files for a molecular dynamics code and write a python script for execution on a HPC system.