xonix's comments

Re: TCO

Does the language give any guarantee that TCO was applied? In other words can it give you an error that the recursion is not of tail call form? Because I imagine a probability of writing a recursion and relying on it being TCO-optimized, where it's not. I would prefer if a language had some form of explicit TCO modifier for a function. Is there any language that has this?

Reminded me of bytebeats (though I admit it's a different thing): https://bytebeat.demozoo.org/#t=0&e=0&s=44100&bb=5d00000100f...

Long time ago I was obsessed with Prolog. I found that if you bend it enough you could implement imperative code (a-la JavaScript) evaluation, still being valid Prolog:

https://github.com/xonixx/prolog-experiments/blob/main/Prolo...

This was super funny, but obviously absolutely useless

No AWK?

You could also like my tool: https://makesure.dev/

https://maximullaris.com/makesure-vs-make.html

https://maximullaris.com/makesure-vs-just.html

My take on this is that it's not always the best idea to abstract-out SQL. You see, the SQL itself is too valuable abstraction, and also a very "wide" one. Any attempt to hide it behind another abstraction layer will face these problems:

- need to learn secondary API which still doesn't cover the whole scope of SQL

- abstraction which is guaranteed to leak, because any time you'll need to optimize - you'll need to start reason in terms of SQL and try to force the ORM produce SQL you need.

- performance

- deceptive simplicity, when it's super-easy to start on simple examples, but it's getting increasingly hard as you go. But at the point you realize it doesn't work (well) - you already produced tons of code which business will disallow you to simply rewrite

(knowledge based on my own hard experiences)

Right, this is not the problem par se. To me this is a rather philosophical question. Related to the motivation behind the project.

If someone has some particular domain problem to which they need to introduce the new programming language, then, probably, it should look somehow different to all existing languages, otherwise they would be used.

Alternatively, the motivation could be: OK I need ExistingLanguageX(-alike) but in the domain/environment where it's not present yet, for example, WASM.

The motivation question is always of interest to me since it allows to judje for the long-term perspectives of the project.

However don't take this as a discouragement rant, learning case is a good motivation/raison d'être too.

It's funny to watch how often new programming languages resemble visually (and conceptually) the language they are written in. You can put it the other way: just look at a syntax sample and try to guess the implementation language.

I can see some problem here. Probably, it means the author is under heavy influence of the implementation language, that limits their thinking and creativity scope to the concepts of that language.

  email:string( regex(".*@.*\\..*") )

This is incorrect regex for email. The correct one is https://pdw.ex-parrot.com/Mail-RFC822-Address.html

Or makesure: https://makesure.dev/

You can also implement includes in couple (tens) of lines of AWK: https://maximullaris.com/revamp_define.html#mglwnafh

Nice.

Once I did some experiments at programming in Java using only sun.misc.Unsafe for a memory access: https://github.com/xonixx/gc_less. I was able to implement this way basic data structures (array, array list, hash table). I even explicitely set a very small heap and used Epsilon GC to make sure I don't allocate in heap.

Just recently I decided to check if it still works in the latest Java (23) and to my surprise it appears - it is. Now, apparently, this is going to change.

You can also program in Python just in list comprehensions: https://maximullaris.com/abusing_python.html

makesure, a similar tool (https://maximullaris.com/makesure-vs-just.html) I'm developing, doesn't require installation in the traditional sense: https://github.com/xonixx/makesure#installation.

Also, I was considering adding the same feature (generating the equivalent shell script) to my tool, but after doing some analysis decided not to pursue this idea for the following reasons: https://github.com/xonixx/makesure/issues/83#issuecomment-98....

It has: https://github.com/xonixx/gron.awk/blob/e5040a7b1384c5839dca...

Strange, should be much less failures: https://github.com/xonixx/gron.awk/blob/e5040a7b1384c5839dca...

Could you please file a bug with the details?

My pure-AWK variant: https://github.com/xonixx/gron.awk (features complete JSON parser in AWK).

True. Probably, only AWK is an exception.

I've just turned off all the Feed filters to show empty feed. This way it's more useful, than with it's "new content". I've bookmarked the direct link to https://github.com/dashboard-feed, unfortunatelly on mobile the font is too small.

For me the most relevant selling point of GraalVM is beeing able to compile to native self-contained executable. But on the other hand, Golang delivers on this aspect much better (or at least much faster).

Correct me if I'm wrong, but to me passing the access token in the GET URL is not a good security practice. This increases the probability of unintentionally exposing the token. The URLs can be logged by proxy servers, application logs. Simply, user can accidentally send the link with token in chat, etc.

Usually in REST APIs the auth token is passed via some HTTP header.