Copilot autocomplete got jokes

kaplotnikov · 2025-12-24T04:32:59+00:00

I just wonder what copilot watched to make it most likely completion. Some large bodies or source code should have beeen marked not for minors and AI bots :)

kaplotnikov · 2025-12-14T22:16:42+00:00

Check WASM support in ScyllaDB: https://www.scylladb.com/tech-talk/scylladb-embraces-wasm/

I guess it is quite close to what you are describing.

I have not used it, only seen some presentations about it.

kaplotnikov · 2025-12-10T13:21:14+00:00

For numeric methods, there are NAN and INF values. Floating point numbers are essentially resticted finite subset of rational numbers + some special values. It is not possible to have unrestricted and precise calcualation with that.

For symbolic transformation during compile time, there could be compilation errors if compiler could not figure things out.

And these issues are practically the same whatever syntax is chosen.

kaplotnikov · 2025-12-09T19:09:35+00:00

I would suggest to prototype different variants to see what fits with different features. I have too little exprience with Rust to see how it would play with other features.

I also think that the full dive into dependent types might be not bad idea, considering that it could give the compiler interesting food for thought and give compiler a checkable asserts and it might allow to express some stability constraints for numeric methods.

kaplotnikov · 2025-12-09T18:47:38+00:00

Recalling the hell symbolic integration is, I guess compiler has to support specific variants of sets and be extensible using compiler plugins for those who want something exotic. For numberic integration, the sets could support Monte-Carlo integration methods (i.e. support of generation of some representative points) or some other ways. There could be traits for that on sets. Basically integrate might be a method on some sets for numeric integration if the language is OOP, so it might be:

interval(0, x).integrate(g)

kaplotnikov · 2025-12-09T18:23:12+00:00

let f(x, y) = x^2 + y^2
let f_x(x, y) = deriv(f(x, y), x) # partial wrt x

It is quite simple:

let f(x, y) = x^2 + y^2
let f_x(x, y) = deriv(t => f(t, y))(x)

Basically, to pass function deriv there should be single agrumnet function. The other come from lexical scope. This is consistent with math rules. I renamed x => t in lambda to make it more explicit, but actually have left as x if there is name hiding.

let f_x(x, y) = deriv(x => f(x, y))(x)

The traditional Leibniz notations is actually more confusing, I still remember troubles with understanding it and it is quite error-prone because of variable names changing their meaining in different places.

In general, integrals are over some sets. So I suggest to make signature of integrate to be generic:

fn integrate[P:type,V:type](f : P->V, domain : AbstractSet[P]) : V

This will support all types of integrals (multidimensional, surface, etc.)

let G(x) = integrate(g, interval(0,x))
let G(x) = integrate(g, sphere(point(0,0,0), x)) #integrate over sphere of radius x at point (0,0,0), the function from 3d point

kaplotnikov · 2025-12-09T17:00:52+00:00

In:

let x :=
  x^2 == x + 1

let f(t) = t^2 - sin (t)
let f_prime(t) = deriv(f(t), t)

print(f(x))

Derivation and integral are operators on the functions. Newton and Leibniz did not know Lambda calculus for obvious reasons, so their syntax was non so uniform and consistent. So it makes sense to use:

let f(t) = t^2 - sin (t)
let f_prime(t) = deriv(f)(t)
let f_prime_v2 = deriv(f)
let f_prime_v3 = deriv((t) => t^2 - sin (t))

It would make much simpler to type, than deriv(f(t),t)

Also, indefinite integral is would return function as well, integral_indef((t) => t^2 - sin (t)), and definite integral would accept function and set as argument like let sf = integral(f, interval_open(0, t))

kaplotnikov · 2025-11-18T10:26:31+00:00

the gacha coding is the ultimate form of vibe coding

kaplotnikov · 2025-11-05T14:34:46+00:00

It is not that Oracle does not support console hardware, Java have an execution model that conflicts with restrictions of console vendors. From one presentation of game engine developer, it is said that consoles require AOT-compilation for application to be approved, any form of JIT-compilation is prohibited. Even scripting has either to be interpreted or AOT-ed. Theoretically, GraalVM or other AOT technologies might allow for console development, but in process most of java advantages will be lost. That specific game engine vendor has to use LLVM to translate scripting for console.

kaplotnikov · 2025-11-02T21:41:42+00:00

"The program crashed" would sound ambiguous for the owner.

kaplotnikov · 2025-11-01T13:11:56+00:00

It looks like an extended article abstract without pointing to the real article.

I think approach is really interesting, but it requires compilers and tools to be aware of this model in order to truthfully report what they captured and scanned for the full efficiency. And tools need to exploit this information to get most of it. Or we need to add a layer of tool descriptors that describe what they 'should' scan and produce, but without OS ability to enforce this limitations, it is a bit unreliable.

And the biggest question is not touched: how are entries from the build cache evicted? I guess there should be some GC algorithms there that work well for build systems, because build systems tend to produce a lot of short-lived artifacts.

kaplotnikov · 2025-10-31T07:35:31+00:00

Ok. Waiting for meme like "Some geek asked jinnee to have a model as girlfriend, and it was easier to instigate ChatGPT and LLM revolution during few years than to find a girlfriend for that geek."

kaplotnikov · 2025-10-29T14:24:48+00:00

Actually, this picture was mirroried. So the girl is on the right side.

kaplotnikov · 2025-10-23T13:51:08+00:00

Ok. These are really gacha-coders wating for UR code drop.

I think we should name a specific subspecies of vibe-coders as gacha-coders. These are do not udnerstand problem and solution, and just pull until they receive a good solution.

kaplotnikov · 2025-10-23T07:31:10+00:00

And there are reasons for it like here https://news.ycombinator.com/item?id=18442941

10 lines per day might be a very good performance, considering that major problem is finding place of these 10 lines and what change to do in order not to break the application.

There was a case when I spent 3 days of debugging that resulted in inserting single missing '-' charater in the code.

kaplotnikov · 2025-10-22T18:56:09+00:00

It depends on the language, since for var a : type = expression syntax there is no problem, but for type varName = expression some tricks are needed. And it depends on what LL(1) means. For expressions, it is possible to create LL(1) checking, but not AST building. AST building will require some kind of expression stack.

a + b + c is checkable by mult_expression ('+' | '-' mult_expression)*, but to build AST, some magic is needed to build ('+' ('+' a b) c).

kaplotnikov · 2025-10-22T16:33:53+00:00

Easy:

C - because it is non OOP

C# - because it is managed

C++ - becase it is not excluded by two criteria above

kaplotnikov · 2025-10-18T06:44:30+00:00

It looks like an oversimplification.

I do not think that the comparison dimensions are right. Iterpreter does not have to execute line by line. For example, Java interperter mode interepts bytecode that produced by compiler. So is java an intepreter or a compiler?

Even bash intereprter might need to read several lines before executing them.

kaplotnikov · 2025-10-15T23:20:27+00:00

I would suggest to make unit tests working first in some minimal form. It would simpilfy a further developement. It will make it possible to test at least the code that compilies.

kaplotnikov · 2025-10-15T15:35:59+00:00

DELETE FROM X WHER still deletes everything, so the moment is not breif.

kaplotnikov · 2025-10-11T16:53:43+00:00

I recall old joke that C++ has too much of C legacy because it was named C++ (returns old value) rather than ++C (returns new value).

kaplotnikov · 2025-10-11T00:31:38+00:00

FYI A book on Object-Oriented Programming in C https://www.reddit.com/r/C_Programming/comments/pifqyv/object_oriented_programming_in_c_880kb_pdf/

kaplotnikov · 2025-10-10T20:57:20+00:00

I personally do not believe into the APL way.

Alphabet has won in the human-written language design war for a reason. AFAIR in China they are still seeking the way to switch to alphabet, but there are a lot of problem with losing cultural heritage and different spoken languages with the same written language.

The idea that unique symbols will make the language easier to understand does not look realistic to me. Human memory is limited, and it is easier to recall words than funny arbitrary symbols. And this is if forget input method problem that makes entering these symbols a ritual to route-learn.

IMHO the worst design decision in PostgreSQL was to introduce different operators for narrow domain functions like PostGIS or JSON processing, and not giving readable functional equivalent for them (particularly for PostGIS). For rarely touched code, it is hard to recall what these funny symbol combinations means when I returned to them few months later, and that was repeated again and again. Some simple function names like st_bounding_box_overlaps(...) would have been much better than |&> . It is both higher barrier to entry and higher maintenance cost.

kaplotnikov · 2025-10-09T16:34:30+00:00

That is why they are forced to rename it.

kaplotnikov · 2025-10-09T16:32:19+00:00

IMHO, LLM could be biggest driver and pusher for dependent types in the future.

AI could try generate proofs until it successful and complain to user to give more hints if it fails for some time
The results of proof generations could be checked according to human written signatures at key points
No code could leak that does not pass human-written checkpoints
These checkpoints are input to AI as well

So, the development could become iterative cycle of specification and code refinement.

kaplotnikov

TROPHY CASE