Have you noticed there are some shameless thefts, basically clones, in the world of terminal emulators? At least the ones for GNOME?

For example, Kitty, Tilix, and Terminator have at least one clone, nothing changed, just repackaged, repackaged on the repository even. I won't name them, but those guilty should feel the burn of shame at their hearts!

And now that we got that out of the way, these are the temus I use actively, like each for a certain task:

• Tilix
• Kitty
• Alacritty

Alacritty is fast, but it's not customizable. Kitty is best. Tilix is good, especially since it's a WM of its own. But it's not as 'crisp' as Kitty is.

I don't like Terminator and its clones, because they have this fruity red bar on top, very distracting. Plus Tilix does what these inbred family do a thousand times better.

Now I wanna know if there are temus I am missing, like obscure ones. Should be able to run on Gnome.

I especially want something like the new Micropeni$ Windows terminal. Also terminal emulators that are based on more modern systems languages, e.g. Rust, Zig, Go. Ones that don't 'necessarily' stick to TermInfo.

So; Not some Xterm clone crap. There must be a million Xterm clones out there. I did not name Xterm because every terminal emulator for X is virtually a clone of Xterm lol.

Thanks!

Can someone please help me understand how one could make his own frontend for the Ferdiverse? It seems like to run on a bespoke protocol, and has HTTP endpoints as well. The help says you can create your own frontend, divorced of HTTP. What I am wary of is the documentation being out-of-date.

So if there's a bespoke protocol, is there a middleware that translates it to HTTP requests to make it possible to run on a browser? Sorry I am very bad at web and network in general.

So to sum my question up:

1- Is there a bespoke protocol, non-HTTP, to access Fediverse?

2- Where can I lay my hands on the latest documentation for creeating a custom frontend, especially one that runs on a non-traditional 'view'?

Sorry if I mention the bespoke protocol for the third time, but what is the use of such protocol? Like is there a client for it? Or do they just mean a protocol ON TOP of HTTP? Because it would be moot. If there's an HTTP protocol I could just use libcurl. If this protocol is as 'bespoke' as they say, is it well-described? Like do they have ABNF for it?

Again I am not very good at network and web in general. This would be my first 'webapp' so to speak.

Even if such thing exists, I would wanna do it.

Thanks.

Based on my understanding of what is written in this book, I understood that 'Operational Semantics' is something for imperative language, and 'Denotational semantics' is for functional languages. In a way, the former is more 'practical 'and the latter is more 'theoretical'.

So I made the thread in the Rust instance about GC being possible by Rust being an 'imperative language with denotational semantics' and people told me I am wrong.

I kinda knew I am wrong, I just went all brazen-like. So I am not brazen anymore.

What exactly did I get wrong about the difference between Operational vs. Denotational semantics? Just a hint would be good.

There's another type of semantics, Axiomatic. That I don't even attempt or try to understand! This one is really puzzling for me.

These are complex subjects and I wanna understand them; and you only understand complex subjects if you ask people.

Thanks.

PS: No academic dishonesty, I am not a student.

I think ---DOCKER--- is doing this. I installed based, and userspace(7)-pilled liblxc and libvirt and then this asshole inserted a dependency when I tried to install from their Debian package with sudo dpkg -i. One of them was qemu-system, the other was docker-cli because they were forcing me to use Docker-Desktop, which I would not be caught dead using.

So is this accidental, or another predatory move by one of these 'ooh I wish I did not open source' companies (e.g. HashiCorp)? Why don't we all use LXC and ditch this piece of shit?

I could be misunderstanding how Debian-based packaging works. But this is too '''accidental'''. Correct me if I am wrong.

uname -a for context:

Linux pop-os 6.8.0-76060800daily20240311-generic #202403110203~1714077665~22.04~4c8e9a0 SMP PREEMPT_DYNAMIC Thu A x86_64 x86_64 x86_64 GNU/Linux

This is nice huh? I remember there was a dude here who wanted to make a language called 'ParenScript', I don't know if he wanted to make it Scheme compliant or not but this is a good resource for inspiration.

Many people hate on JS for its syntax, I don't exactly know what is wrong with JS' syntax

it's just a Fortran-derived syntax. But these people have no reason to hate it if they use this

Unless they hate S-Expressions too? Then I guess they're just chuds lol.

Now this does not have syntax-rules, which is a pity but I guess the old macro system is good too (define-macro). Keep in mind that these macros, like Mike Rotch, are not hygenic. Meaning if you name something foo in the macro's body, and there's another thing named foo in the closure the macro is invoked at, they will conflict.

Thanks, enjoy.

VOID WRONG

It seems like I misunderstood some stuff.

Over the years, up until Rust, there were 4 ways to have a 'safe' language:

• A virtual machine (e.g. most languages today)

whether it's a high-level (scripting languages) one or low-level one (JVM, CLR)

• What C++ and similar languages do, destructors, compile-time bound checks, make a global heap and shit in it, make a local stack and piss in it, etc (basically my AllocPPx.pl but baked into the language)
• Bake the VM in with the machine code. That's what D and Go do, and I think Nim does that too. This will make the point of your language being compiled entirely moot imo.
• Finally, the most 'controversial' decision for imperative-loving chuds: make a functional language. ML/Scheme/CLisp achieve memory safety through closures. Haskell achieves this through Monads. Functional languages have a property which allows them to be be both compiled into machine code and bytecode, and also, interpreted like an scripting language.

The problem with all these approaches is the trade-off between safety and speed. There's another factor, and that is low-level access to the system. Languages like OCaml came close to achieving a balance, and that's why Rust bassed itself on it.

Most imperative languages have 'operational semantics', but not 'denotational semantics'. You can't describe what C does with math. What C does depends on the platform, the CPU, etc.

Rust's safety is achieved by 'flattening out' the memory model of a functional language like Ocaml. OCaml is a language with denotational semantics, because it's a functional language. Rust is an imperative language but it has denotational semantics. At least when comes to memory management.

I am not going to even attempt to describe the denotational semantics of Rust because I am just an amatuer and i don't have a master's in LDT. But if someoen tries, they could.

I think people might have already done it. I am not sure.

If you tell me no, and Rust does not have denotational semantics, I stand by my great-great grandfather's barber's grave that yes, it does!

So why do I say Rust 'flattens out' the functional model for memory management? It does at least with lifetimes. So imagine this: lifetimes are just 'let' bindings, but with a different syntax.

OCaml:

let rec factorial = function
  | 0 -> 1
  | n -> n * factorial (n - 1);;

Scheme

; This uses `let` under the hood
(define (factorial n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))  

So these two in Rust would be:

fn factorial<'a>(n: u32) -> u32 {
    match n {
        0 => 1,
        _ => n * factorial(n - 1),
    }
}

I know 'a is almost useless here, but what I meant was, that 'a makes it similar to the 'let' bindings in the prior to examples!

Semantics here is clear. Right?

But C:

int factorial(int n)  {
   if (n == 0) return 1;
   else return n * factorial(n - 1);
}

We do have operational semantics here, but who's to say what are the denotational semantics? Right? What is a 'function' in C? Well most C compilers translate it to an Assembly subroutine, but what if our target does not support labels, or subroutines?

You see what I am arriving at?

Conclusion

Rust is a semi-functional, semi-imperative language, but the difference between Rust and other languages with functional aspects is: denotional semantics!

Note: A language having lambda closures does not make it 'functional', you can do that in GNU C too ffs! Denotational semantics make it functional.

TCC fails with GNU's regex.h:

echo '
                                              #include <regex.h>

                                              int main() { return 0; }' | tcc - -run
In file included from -:2:
/usr/include/regex.h:682: error: '__nmatch' undeclared

Would building it from source fix the issue? I know from my experience that Pop_OS! apt repositories are not very up-to-date with smaller apps. For example, NekoVM is from 2017, the latest one is from 22 I believe.

I thought this might interest you Rust folk. This is kinda like an LLVM bitcode to JVM bytecode translator. So run rustc with --emit=llvm-ir (I think that's the flag) and then pass the bitcode image to this program, then get JVM bytecode which you can make a JVM bytecode archive (JAR) from it. Could be an interesting? The author says it can JVM code from Clang output, so why not Rustc?

Keep in mind that these are two different beasts, JVM is designed for a safe virtual machine and LLVM is chiefly used to be translated into machine code. However, stupider and more wonderful things have been done with LLVM and JVM, for example, there's an LLVM to 6502 translator, so you could be making NES games with Rust.

I will test this in a few days, busy implementing my own JVM (hope I can do it) and I don't have the Rust toolchain installed on my system. But hey maybe someone can make a Cargo plugin from it (is it possible?)

Thanks, later.

I honestly have issues browsing to even the simplest of non-static pages. I think it's like, the graphical version of lynx(1) or w3m(1). I think it's based on X's browser right? So basically, it's based on the Open Webkit Standard. It uses the GTK+ WebKit engine. This engine has a programmatic interface.

You can install it via:

sudo apt install epiphany-browser

Make sure you add the -browser, otherwise some shitty game that crashes your system is installed. DO NOT RUN THIS GAME! This is not a joke.

Of course this only works for Plebian-based systems. Other package managers may, or may not have it.

So as I said, I had a lot of issues navigating. I was experiencing network isseus at the time. Tried it again when they were fixed. SLOW AF!

It's not that fetching www is slow, rendering hypertext is slow as well. Lik, I monitored tcp/443, it got done fetching the text and it was STILL struggling to render!

Soo... 'render' is the key here. It's obvious why it's slow. It does not use Direct Media Access.

But that does not mean it's useless right?

I can imagine lots of uses for web automation chuds. Basically bind libwebkit2 to Python and you'll be free of automation protocols. Although it does support automation protocols as well.

In fact you can use wpewebkit-driver to interace with Epiphany's web driver. Good thing about it is, the protocol hackable af.

sudo apt install wpewebkit-driver

So anyways, if you did not know about this, now you know.

And I think most people DO know about it, because another browser that uses libwebkit2 is GNOME browser which comes as default X browser on most Plebian systems. I don't think anybody uses it though. It's kinda like an extremely un-intrusive IE6 lol.

Thanks.

So I want to implement my own ROFF. I collected this to have a database for me, and everyone else, about ROFF, especially GROFF.

No-lifes at BSD are trying to push away ROFF in favor of Mandoc. I say booya to that. I will implement a 'new new roff'!

Anyways I hope you enjoy this series of documents and datasets. ROFF is really, really sweet. It's the reason we have UNIX.

RIP Lorinda Cherry, she's the author of eqn and passed away not long ago. When I saw her on the UNIX internal documentary I thought she's a secretary

and I hope you forgive me since 1980s CS was not exactly a knitting circle.

Ossanna was also a key developer of ROFF. He died not shortly after it was developed.

You can find some blog posts of people reminiscing about using GROFF 'mom' package to format their essays and dissertations even! Kinda jelly. I guess when your first PC you are given at 12 has MS Word 2003 installed on it, you don't think much about DSLs for typesetting. I wish I had something to typeset :D

Thanks.