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: ocaml let rec factorial = function | 0 -> 1 | n -> n * factorial (n - 1);;

Scheme 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:

rust 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:

```fish 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.

So we have all these control characters in ASCII and besides newline, horizontal tab and carriage return (on Windows) the only use for them is on terminal emulators (which I am making one!) Also as an extension, us NeoVim/Vim users have extensive use for them.

But all these control characters are 0-31, for example, newline is 10, horizontal tab is 9, carriage return is 13, etc. But DEL is aaaalll at the bottom, the last one, 127!

Here's my theory. So, DEL is supposed to delete one row of text, it's backspace that is supposed to just delete one character (I think backspace is 31?). So since 127 is literally 7 1s, marking it on a punch-card 'by mistake' would be kinda hard right? So you want have delete ruin your batch. It's kinda like a built-in 'Are you sure you want to delete this row of punch-card?'

Now I could be wrong. Opinions?

PS: If this is so, this kind of 'physical sentinels' is nothing new. According to Alan Kay, the earliest linked lists were not data structures, THEY WERE 1-TONN MAGNETIC DISKS! So basically, you had the address, and by 'address' I mean the physical address, a real location on planet earth, of the next magnetic disk stored on a fixed location on the previous magnetic disk. Fun huh?

Problem is it can't find mkdev.h:

cpio.c:101:10: fatal error: sys/mkdev.h: No such file or directory 101 | #include <sys/mkdev.h> | ^~~~~~~~~~~~~

Now a UNIX system, especially both POSIX and SuS is impossible without mkdev.h --- at least a shitty wrapper. And when I googled mkdev.h to see the specifics the first result was an LXR.

WHY DO MY SYSTEM HEADERS DON'T HAVE A BASIC UNIX HEADER FILE THAT LOONIX HAS? (OR HAD)

Problem is I really wanna make Heirloom. I whole-heatedly disagree with GPL because RMS drinks children's blood. I refuse to use free software and in fact I use Pop_OS! which has more binary blobs in it than a 80s musical composer for Disney movies has had dicks in him. Heirloom is based on Solaris' utilities and they are unfree as my semen is to super modles. I WANT THIS.

joking aside, what is going on here?

ls -R /usr/include/ | grep mkdev

Exits with 1. Nothing.

So I guess this is a Pop_OS! thing? Should I install some package to get this header?

Or was it removed from 6.8?

uname -r => 6.8.0-76060800daily20240311-generic

Thanks.

I began programming when I was 16 and like most people my age (31) it was with some gaming-related DSL. Personally for me it was GML. I made a tetris game which my younger brother played to death but ever since the closest interest I have to vidya is Ncurses and X11. Which makes me think, why is there not such standard for vidya?

So hear me out. We need to make common runtime VM for vidya. Standardized. And it will sport a post-fix language like PostScript. You can learn more about PostScript here.

PostScript is the predecessor of pedophile language, like cat a PDF file and you'll see. Except pedophile language allows of binary blobs. PS does not. There's a lot of differences.

Pedophile and PS are 'page description languages'. Another PDL is ROFF, what UNIX manpages are written with. Launch loonix via WSL2 (I know none of you game devs run loonix natively! You won't be able to work!) and bring up a manpage like man awk. ROFF was why UNIX was written!

So I say, let's make a 'vidya description language', you could just use PS itself with addition of:

• Input
• 3D shapes

And Bob's your uncle (am I using this phrase correctly?). PS is a Turing-complete language, it has control structures and you can make a 'game play loop' with it (basically a non-halting decidable TM).

So this language will execute on a runtime VM, a stack VM of course, and this VM is common across several hosts. Just like Java's VM. In fact, Java's VM is already a 'common runtime vm' for vidya right? This time we'll have something more specific.

So this VM will execute the same VDL (Vidya Description Language) code the same across different hosts. Linux, Windows, MacOS, Haiku, Solaris, MacOS, Plan 9, BeOS, BSD, iOS, Android, FireOS, etc. Also it could target various APIs e.g. Meta, Vulkan, OpenGL etc.

I know Unity already has such runtime. But VDL and VdlVM will be more of an 'standard'. In fact, we would develop the 'standard'/specficiation first, then we'll develop the software. We would make one implementation, but someone else could make another implementation, both compliant and compatible! And our implementation of VDL and VdlVM would be FLOSS, released under GPLv3 --- but Johnny Schlomo can make a super duper closed-source implementation!

So you may look at PostScript and say, damn man, I can't code in this language! Well my good man it's not meant to be coded in directly. That's what I mean by 'assembly of vidya'. It's a language other engines and runtimes target. This is called a 'terese' syntax. The aim of a terse syntax is to have non-binary ASCII text as a portable way to move your code around. In fact, VdlVM does not need Vdl to function. VdlVM reads from binary cishet files, not directly from Vdl files.

Thoughts/critiques/appendages? Would really like to know what you think of this idea. I would implement thi,s, but as I said, it's an standard. An standard needs a community. An standard needs a publicity. An standard needs design. This is not a one-man job. If you would like to develop this standard with me, let me know (chubakbidpaa [at] riseup [dot] net). We can make a mailing list (Discord is for babies!).

Thanks.

About a few days ago I posted this, asking for help to implement the parser. It seems like I boomer'd and I forgot to set the Gist to public. This is public (hopefully!). Someone did gave me a link, but I kinda could not 'parse' it (get it? get it?). I still would appreciate it if you would give me guidance in parsing with Scheme, and not just tokenizing. I am using my experience from this to write a documentation language + macro preprocessor in Scheme called 'Makroon'. I will use your help in giving me tips for parsing to parse that, and also, more complex projects like my C compiler in Ocaml (Cephyr). Like I re-began this project soooo many times!

Enjoy.

With some help from the LLM that shall be unnamed, I created a full dossier on PostScript. You can build it to the original Markdown, or convert it to HTML, Latex, PDF, etc.

I will guarantee that you will at least learn 'a bit' about PostScript with this dossier.

Mind you, PostScript is meant to be compiled to, it's not a high-level language. As I say in the overview, it's a 'visual assembly'!

Some people may not know what PostScript is --- well, this is understandable since PostScript's hayday is long since overdue, we got PDF now. PDF is kinda like a superset of PostScript though.

I am trying to make my own PostScript interpreter. I named it Nock. But first I need to see what I can do with it. There's enough PS toolchain around. I was working on an EBNF to PostScript translator in Scheme. But I realized I really dunnno not much about it so I spun this up to learn.

You may remember my PostScript manpages from... yesterday was it? Anyways those suck. Don't use them. Use these. You can even use Pandoc to make manpages from these:

``` cat _ps-dossier.md | pandoc -fmarkdown -tman | groff -man -Tascii | most

need to install most, you can use less or more to page

```

Thanks.

These toolchain are created for experts to create industrial-level compilers. Even if you think you got a syntactic design concept that is such hot shit that you can't wait to get it bootstrapped, even if hell, it proves Rice's theorem wrong, please, write a simple interpreter for it to prove your syntax works. In fact, I think one way you can test your language's design is to have it mooch off an established VM like JVM, CPython's VM or CLR.

But if you wanna 'learn' compiler design, I beg you to roll your own backend. You don't need SSA or any of that shit. You don't need to super-optimize the output at first try. Just make a tree-rewrite optimizer and that's that.

Same is true with LP generators. From Yacc to ANTLR, they just make the experience harder and less rewarding. I know hand-rolling LP is hard in a language like C, in which case, don't fucking use it lol. There's honestly no inherent worth in using C in 2024 for compiler design.

But there's still use for C in being the subject of your compiler. It's a very simple, straightforward and more importantly, standardized language, you don't need to write a runtime for it, because when it comes to both UNIX and Windows, runtime is OS itself! Just make sure you add a syscall interface and then C runtimes like glibc and CRT can be easily strapped.

I'm going to do exactly this. I named my C compiler 'Cephyr'. I have started over several times now. I am using OCaml.

I know my point about using LP generators is preaching to the choir and most people despise them --- but I just don't understand why people love to use IRs/ILs when doing so teaches you shit.

I recommend beginning to design your language with the IR -- your IR.

I don't just wanna focus on Cephyr. There are other stuff I wanna do, like Nock, a PostScript interpreter in Rust (because GhostScript had made me hard-reset 4-5 times. GhostScript is just un-secure, leaky garbage).

Anyways tell me what you think about my 'take' on this. Of course I am not saying you are 'less knowledgeable' for using LLM or MLIR, I'm just saying, they don't teach you stuff.

Still, some people just use LLVM and MLIR as a final 'portable' interface, having done the optimization on graphs and trees. i think there should be some sort of 'retargatble assembly' language. Like something with fixed number of registers which.. oh wait that's just a VM!

Also you don't need to necessarily translate to a super super low-level language. Just target C. GNU C to be exact. Cyclone does that, in fact, I am planning to bootstrap my functional language, which I named 'Xeph', based on Zephyr ASDL, into GNU C as a test. Or I might use JVM. I dunno. JVM languages are big these days.

PS: Do you guys know any cool VMs I can target beside CPython and JVM? Something with AoT perhaps?

Thanks.

I've been trying to learn PostScript so I made this. Took almost a day and a half. I'm still not sure all the pages are up to code. Please report any errors you see.

I know I promised Rust manpages, but with the experience from this, that would be easy. I am very new to this whole programming thing and I did not know much about scripting either (which is embarrassing because I'm 31 -__- ). But I with some help from ChatGPT (it did not generate any scripts because when I do I get confused, I guess it takes a lot of skill to not get confused by the scripts and programs ChatGPT generates) I just used it to ask questions about utilities I could use. For example hxpipe is the utility it recommended and it rally helped. Problem was that these HTML files were too old and rusty. I used tiidy and hxnormalize and hxclean to clean them up then I passed them through hxpipe. Then I parsed the script with Perl etc etc.

Sorry something happened to my displays I think I mistakenly pressed a shortcut key. Anyways if there's any problems lemme know.

Thanks.

In the Gist, I have explained my problem, and I have provided my tokenizer as well. If you can help me with the parser, that would be great. Also if my tokenizer is not very well-structured, please tell me.

btw the tokenizer is written in extremely portable Scheme. I think Chez is the best interpreter for Scheme.