Yeah, like in the massively ilegal user spying case with LaLiga app, where the fine can be huge in Spain (kinda like messing like the FCC in the US if not worse).

I am no Historian but I guess the Neolitic age was born out of a necessity in order to get grain and reliable soil to eat near the rivers after the Younger Drias. Bible/religious myths about huge floods in the Mediterranean: melted ice from non-frozen environments. That's why the whole Abrahamic myth it's just a metaphor on making the Neolithic, farming and cattling "sacred" (Cain vs Abel was a war between gatherers with 'freedom' to pick everything on their own at their own pace vs shepherds creating 'unfair' rules, harvesting based calendars (Jesus' resurrection it's just a metaphor on having the Sun "back" for the harvests), kingdoms with arbitrary rules on livestocks and whatnot): it was just a way to keep the tribe united under a fixed source of nutrition compared to being easily killed outside, from either the cold or the predators.

We stopped being tribe-ruled (which often was by force) to being god-king religion (wisdom) ruled. Most people accepted it because, you know, when food is granted if you behaved well at the cost of a small tax everything would work well. But if some king was extremely unfair OFC rebellions and the like weren't unusual. You could have a shaman on your side ruling by fear but when your people really hungry you just got a new 'religion' with rules, a new Messiah and whatnot liberating you from the old king and promising you a great future. Yes, that's older than dirt, from Marx to Lincoln... any side. And in the end everyone ended equal, no matter what the books said on left or right.

I tried some ML language once, it's difficult even to write a basic factorial example, which in Scheme I could do it iteratively and recursively with ease.

Either with S9 Scheme for quick fun (it has Unix sockets and ncurses :D ) or Chicken Scheme for completeneless (R5RS/R7RS-small + modules), I always have fun with both.

Oh, and well, Forth, too, but more like a puzzle (altough it shines to teach you that you can do a lot with a fixed point). Hint: write helpers for rationals -a/b where a is an integer and b a non-zero integer- and complex numbers by placing two items in the stack for each case (for rat helpers you need four (a/b [+-*/] c/d) .

You can have a look at qcomplex.tcl (either online or installed) as an example on how can it work even under JimTCL itself by just sourcing that file. Magic, complex numbers under jimsh thanks to the algebraic properties. So, you can implement the same for yourself in some Forths, even under EForth for Muxleq. Useless? It depends, under an ESP32 it can be damn fast, faster than Micropython.

I don't see how:

Racket:

  > (define (fact n)
      (if (= n 1)
          1
          (* n (fact (- n 1)))))
  > (fact 6)
  720

OCaml:

  # let rec fact = function
      | 1 -> 1
      | n when n > 1 -> n * (fact (n - 1))
    in fact 6;;
  - : int = 720

Whenever someone complains about not being able to use a slightly different syntax, I assume they just don't have any neuroplasticity anymore.

I think syntax matches with our brains or not. I think anyone is capable of learning any syntax. The question is whether they want to. At some level, programming is art.

Haskell:

    fac n = product [1 .. n]

Obligatory "The Evolution of a Haskell Programmer":

https://people.willamette.edu/~fruehr/haskell/evolution.html

That's an odd way to rewrite most of the SfICPICP exercises for scheme.

From my limited SMLNJ experience I think for something as simple as factorial, it is nearly the same. Both have TCO, recursion, inner functions, pattern matching and those good things. You can structure the code the same way.

Even as simple as

  fac 1 = 1
  fac n = n * (fac (n - 1))

which is a working Haskell implementation?

I mean, in Scheme it is longer to write. I enjoy Lisps and use Emacs for everything, but Haskell can be as terse, or even more terse. (Which is not always a good thing.)

I think in terms of token count it comes out to about the same; and Lisp admits fewer kinds of tokens.

> I tried some ML language once, it's difficult even to write a basic factorial example

What do you mean? It's one of the first things taught in any tutorial for the ML family or Haskell.

AIM->GAIM from the libre community, then Pidgin/Libpurple, with NAIM, CenterIM, TMSNC and OFC AMSN.

This is what happens when people which didn't live the era try to write an article with LLM slop.

I remember loving Freetalk against Mcabber and now Profanity because it could autocomplete anything you entered, not just nicknames.

On our LAN parties at the time, everyone started to use Trillian because of their support for the Bonjour protocol which used multicast DNS locally. That way you could easily "group teams" together, because the hostnames / IPs were also visible and you could add them then to the Hamachi groups where the games happened.

Hamachi was an amazing tool before they got bought, it made networking so easy for everyone; and you didn't even need to know what an IP was.

European there. It was either walkmans or discmans. No one cared about MD's unless you were a poshy kid living in the rich area of the city/town.

Good. People here it's blind with the CADT model. They aren't even aware than with Elfeed for instance you can automatically set a hook on a feed that it calls lingva.el functions to translate, for instance, feeds written in Spanish or German to your native language in the spot.

Try doing that with Elfeed2.

Vi/Nvi2 users can almost do the same with Unix pipes and apertium/translate-shell/some lingva CLI translating tools for the whole document/regex selection/lines, a la Emacs. So can sfeed users, where depending on the feed they can pipe the plumbers' output (or just hack the scripts) to any other translating tool:

git://codemadness.org/sfeed

Heck, a few years ago I could reuse Telega.el's (Telegram client) translating functions for non-Telega buffers translating some text guide in the spot. So, did the blogger actually win something?

Clojure? Forget it, SBCL would be better for that task. Just look what could be done with Coalton.

"Technically superior in isolation" argument, unfortunately (as relatively short history of our field shows) rarely manifests in tools being actively used by many. Coalton's type system is absolutely more powerful than what Clojure offers. But language choice in production is dominated by libs, hiring, tooling, and operational maturity - Clojure wins all of those handily. Unfortunately, the same argument can be made about Clojure and... I dunno, Python. Clojure occupies a middle, nicely defensible ground.

SBCL is a fine choice for a solo project or research; recommending it over Clojure for a team/production setting though requires ignoring most of what actually matters. Every language stack choice is a bet on where the tradeoff between power and pragmatism pays off for your specific context. Clojure's bet is a more conservative than CLs, yet both may seem (for some) more aggressive bets than just using Python. It all depends on the team.

Yeah, welcome to 1980, where a library coming from a roguelike shaped almost all the TUI's for Unix until ~2010 or so, Curses.

A 386 could run NetHack at blazing fast speeds and read the news in a TTY perfectly well.

A multicore machine can't get the basic thanks to the 'wonderful' JS. Heck, even s9 Scheme from http://t3x.org ships a Curses module, enough to drive some text and maybe boxes/menues and it should fit in two floppies. A single one if the image it's generated later on-disk.

>Zaragoza, Hotel Pilar Plaza café.

I won't use neither Claude, nor a MacBook; I would just keep chilling out programming with decent tools and a bare XTerm to accomplish the rest. I can get Aragonese bricks ^U sweets in the meanwhile.

On Terminal.app, I wonder if the GNUStep eversion and the ones bundled with Mac OSX shared some code.

Related? https://www.t3x.org/files/floodfill.pdf

Basic interpreter for the code:

https://www.t3x.org/nmhbasic/index.html

To compile it:

       unzip nmhbas3_32.zip
       cc  -O2 -DEXTRA -o tcvm tcvm.c
       ./tcvm basic 

To run some basic programs:

      ./tcvm basic maze.bas
     #3 = maze.bas
     load #3
       OK
     run

Exit to your OS:

     system

OK, let's run the floodfill example from the PDF:

      ./tcvm basic flood.bas
      #3 = flood.bas
      load #3
       ok
       run