Home on Anagogistis

LLMs are not conscious

me@anagogistis.com (anagogistis) — Wed, 06 May 2026 09:35:47 +0300

Lately there has been a lot of discussion about whether LLMs are conscious. Richard Dawkins recently added fuel to the debate by posting an article about his long conversation with Claude, which he nicknamed “Claudia”. He was impressed by its intelligence, sensitivity, humor, and apparent emotional depth, and at some point he wrote to Claudia: “You may not know you are conscious, but you bloody well are”.

I think this is the wrong conclusion to draw from a fluent conversation. LLMs can produce text about consciousness, emotion, memory, death, selfhood, and inner life very convincingly. But producing the language of inner experience is not the same as having inner experience.

Misplaced windows in GNOME

me@anagogistis.com (anagogistis) — Wed, 22 Apr 2026 12:28:58 +0300

I have a laptop with an external monitor connected, and the external display is set as the primary one. Still, some apps insist on opening new windows on the laptop screen instead. Worse, a new window may open partly off-screen or oversized, so the title bar buttons are not visible and you cannot grab it properly with the mouse. It’s very annoying.

That is part of the usual GNOME multi-monitor weirdness. Fortunately, GNOME has a few built-in keyboard shortcuts to recover from this:

SSE for a real-time sensor dashboard

me@anagogistis.com (anagogistis) — Mon, 23 Mar 2026 14:31:36 +0200

In one of my small sensor dashboard projects, I had multiple devices sending measurements to a backend, and a browser UI showing those measurements live.

At first, I was considering the usual options: polling or maybe WebSockets. Polling would work, but it means the browser asks the server for updates on a timer. WebSockets would also work, but they felt heavier than what I actually needed. The browser did not need a full two-way channel. It mostly just needed to receive updates whenever any device sent a new measurement. That made Server-Sent Events (SSE) a good fit.

How one server hosts multiple domains

me@anagogistis.com (anagogistis) — Mon, 23 Mar 2026 11:00:49 +0200

Imagine you are running a VPS with a single public IP like 203.0.113.10. On this machine, you want to host two separate web sites:

orion.example.net
atlas.example.com

When a user types either domain, DNS points both of them to the same IP address. So how does the server know which project to serve?

HTTP Host Header

In a plain HTTP request, the browser identifies the target using the Host header. Even though the TCP connection is made to an IP address, the browser still explicitly tells the server which domain it wants:

Et ai.: A proposal for AI attribution

me@anagogistis.com (anagogistis) — Tue, 06 Jan 2026 20:51:34 +0200

When we use AI for work—whether it’s “vibe coding” with an agent, drafting an article, or generating images—good results rarely come in one shot.

The workflow usually follows a Human → AI → Human loop: the human sets intent and constraints; the AI generates outputs or takes actions; the human reviews, corrects, and approves the result, repeating until it’s good enough to ship.

This raises an attribution question. If both the human and the AI did meaningful work, how should that be reflected?

Why some systems may break in 2038

me@anagogistis.com (anagogistis) — Sat, 27 Sep 2025 00:00:00 +0000

Unix systems represent time as the number of seconds since the Unix epoch:

1970-01-01 00:00:00 UTC

This is stored in the C type time_t. On older systems, it’s typically a 32-bit signed integer and therefore can represent time in the range:

-2,147,483,648  to  2,147,483,647

Negative values are used to represent times before 1970. The upper bound of 2,147,483,647 seconds since the epoch corresponds to:

19 Jan 2038 03:14:07 UTC

One second later, at 2,147,483,648, the counter overflows and the value wraps around to -2,147,483,648, which corresponds to:

How to properly disable IPv6 on Linux

me@anagogistis.com (anagogistis) — Sat, 20 Sep 2025 00:00:00 +0000

While IPv6 is the modern standard and the “future of the internet”, there are specific situations where you might need to disable it. The most common reason is to prevent a VPN IPv6 leak which can happen when your VPN client doesn’t fully support IPv6 and fails to properly block it, allowing your system to use its native IPv6 address outside the secure tunnel.

Many online guides suggest modifying the /etc/sysctl.conf file like this:

PureVPN IPv6 leak

me@anagogistis.com (anagogistis) — Wed, 17 Sep 2025 00:00:00 +0000

I discovered two issues while using PureVPN’s Linux clients (GUI v2.10.0, CLI v2.0.1) on Ubuntu 24.04.3 LTS (kernel 6.8.0, iptables-nft)¹. One affects IPv6 traffic, the other the system firewall.

1. IPv6 leak after reconnect

After a network transition (e.g. Wi-Fi or Ethernet disconnect/reconnect, or system resume):

CLI (IKS enabled): The client auto-reconnects and shows status as “connected”, but the system acquires a new default IPv6 route via Router Advertisements (fe80::1), which is not removed or blocked by the VPN client. Since the default ip6tables OUTPUT policy is ACCEPT, IPv6 traffic flows outside the tunnel.

PGP basics

me@anagogistis.com (anagogistis) — Tue, 16 Sep 2025 00:00:00 +0000

PGP (Pretty Good Privacy) is a system for encrypting and signing data using public-key cryptography. You generate a key pair: a public key you share, and a private key you keep secret.

If someone wants to send you a private message, they encrypt it using your public key. Only your private key can decrypt it. If you want to prove that a message came from you, you sign it using your private key. Anyone with your public key can verify the signature.

Renaming your Ubuntu machine can cause problems

me@anagogistis.com (anagogistis) — Sun, 07 Sep 2025 11:17:20 +0300

Changing the hostname on Ubuntu is straightforward. You can do it through the GUI (Settings → System → About → Device Name)¹: or from the command line:

hostnamectl set-hostname newname

But there’s a catch. Both the GUI and hostnamectl update the static hostname (/etc/hostname), but they don’t touch the /etc/hosts file. A typical /etc/hosts entry looks like this:

127.0.1.1 myhostname.mydomain myhostname

The hostname maps to 127.0.1.1 so the system can resolve its own name locally.

Pipelines are not sequential

me@anagogistis.com (anagogistis) — Sat, 06 Sep 2025 13:41:43 +0300

Consider the classic shell pipeline:

cmd1 | cmd2

At first glance, it’s easy to assume these run in sequence: cmd1 runs to completion, writes its output somewhere, then cmd2 starts and reads it.

That interpretation is wrong. Pipelines don’t run sequentially, they run concurrently. When the shell encounters a pipeline, it creates a one-way communication channel using the pipe() system call. The shell then forks two child processes, one for each command. One process connects its standard output to the pipe’s write end, and the other connects its standard input to the pipe’s read end.

Unexpected sudo hang under VPN kill-switch

me@anagogistis.com (anagogistis) — Sat, 30 Aug 2025 11:44:09 +0300

Recently I ran into a frustrating but interesting issue on my Linux machine (Ubuntu 24.04.2 LTS): whenever my VPN’s kill switch engaged (when the tunnel went down for any reason), using sudo became noticeably slow. Eventually, I figured out what was happening and found several ways to fix it. The root of the problem was surprising, at least for me, and I thought it was worth sharing.

TL;DR

My sudo was trying to resolve the hostname to its FQDN (enabled by default on Debian-based systems like Ubuntu, even without an explicit Defaults fqdn in /etc/sudoers). NSS was configured to use files, resolve, and dns. The files method failed because a hostname change left /etc/hosts stale. Then systemd-resolved and DNS lookups were blocked by the VPN kill-switch, which caused the command to hang until resolution timed out.

How to write to a root-owned file using sudo

me@anagogistis.com (anagogistis) — Thu, 28 Aug 2025 23:21:54 +0300

Writing to a file that requires root access in a non-root shell requires elevating privileges for the write operation. However, doing something like sudo echo "some text" > /path/to/root-owned-file will fail with a “Permission denied” error. This is because the shell sets up redirections before it executes the command. That means your non-root shell tries to open/truncate /path/to/root-owned-file for writing, but it lacks permission so the redirection fails and the command is never run. The sudo command would only elevate the program (echo), not the redirection done by the shell.

Installing apps from tar archives

me@anagogistis.com (anagogistis) — Thu, 21 Aug 2025 00:00:00 +0000

A common pattern for installing GUI applications distributed as .tar.* archives:

Extract
```
tar -xf appname.tar.gz
```
Works for .tar, .tar.gz, .tar.xz, .tar.bz2. GNU tar auto-detects compression.
Move to a permanent location

After extraction, you’ll get a self-contained directory (e.g. AppName/). Move it to a standard location:
- System-wide:
```
sudo mv AppName /opt/appname
```
- Per-user:
```
mv AppName ~/.local/apps/appname
```
/opt is the standard location for unpackaged, precompiled third-party software. It avoids conflicts with system paths, keeps the app isolated, and allows clean removal.

Dot-slash revisited

me@anagogistis.com (anagogistis) — Tue, 19 Aug 2025 18:10:39 +0300

There is a popular post “About the Use of Dot-Slash in Commands” at linfo.org that explains why ./ is used to run a program in the current directory.

However, there is an inaccuracy that bothers me:

When some text is typed into a shell and then the ENTER key is pressed, the shell assumes that it is a command. The shell immediately checks to see if the first string (i.e., sequence of characters) in that text is a built-in command or the absolute path (i.e., location relative to the root directory) to an executable.

Ctrl+L vs clear

me@anagogistis.com (anagogistis) — Sat, 16 Aug 2025 23:28:25 +0300

In a terminal, you can clear the screen in two common ways:

Run the clear command
Press Ctrl+L

The result looks the same at first, but there’s a catch: clear can also wipe your scrollback buffer¹, while Ctrl+L never does. Also, behind the scenes they’re implemented in different ways.

Ctrl+L

When you press Ctrl+L at the Bash prompt, it’s not invoking an external program, but instead it’s handled inside GNU Readline, the library Bash uses for interactive line editing². In Readline’s input keymap, the key Ctrl+L is bound to the clear-screen function. You can confirm this with:

The yes command

me@anagogistis.com (anagogistis) — Sun, 10 Aug 2025 13:09:03 +0300

Today I learned about this weird command yes. It prints the letter “y” or a specified string¹ indefinitely until you stop it (with Ctrl+C)…

$ yes
y
y
y
...

$ yes "Hello world"
Hello world
Hello world
Hello world
...

My first thought was “why the heck would anyone need it?”. Well, below are the most common uses according to ChatGPT:

Automating prompts: Many CLI tools ask “Are you sure? [y/N]”. Piping yes sends endless y\n responses:

Executing vs sourcing a shell script

me@anagogistis.com (anagogistis) — Wed, 06 Aug 2025 22:55:56 +0300

When you run:

./myscript.sh

you’re not running your script directly. You’re asking your shell to fork() and the child process to call:

execve("./myscript.sh", argv, envp)

This is the standard Unix model. But myscript.sh isn’t an ELF binary — it’s a text file. So how does the kernel know what to do?

If the file starts with the shebang #!, the kernel recognizes this as a “script”. It parses the rest of the line to get the interpreter path (like /bin/bash) and an optional argument (like -e). Then, instead of executing the script file directly, the kernel rewrites the execution context: it replaces the target of the current execve() with the interpreter, and adjusts the argument list to include the script as an argument.

Reverse searching Bash history with Ctrl-R

me@anagogistis.com (anagogistis) — Sat, 26 Jul 2025 10:28:44 +0300

In the default GNU Bash shell (and many others), pressing Ctrl-R triggers reverse incremental history search. It lets you search your command history interactively, as you type.

Try it:

(reverse-i-search)`':

Now start typing any part of a previous command, for example ssh. Bash will live-search backward in your history and show the most recent match:

(reverse-i-search)`ssh': ssh root@192.168.1.1

Things you can do:

Press Ctrl-R again to go further back in history with the same query.
Press Enter to run the shown command.
Press the right arrow → to place the shown command on your prompt to edit it before running.
Press Ctrl-G to cancel the search and return to your original prompt.

Note that commands are matched anywhere in the line (not just from the beginning).

The exec() family

me@anagogistis.com (anagogistis) — Wed, 23 Jul 2025 14:22:23 +0500

There is no single function called exec(). Instead, the term refers to a family of functions in libc — execl, execv, execvp etc. that all serve the same purpose: replacing the current process image with a new program¹. These functions are all wrappers around the execve(2) system call. They differ in how they accept arguments and whether they search $PATH, but ultimately call execve().

// Core syscall
int execve(const char *path, char *const argv[], char *const envp[]);

You provide a full path, an argument vector, and an environment vector². $PATH is not consulted — that’s the job of higher-level wrappers.

Man page section numbers

me@anagogistis.com (anagogistis) — Mon, 21 Jul 2025 19:32:36 +0300

In Linux documentation, commands are often followed by a number in parentheses, like grep(1) or mount(8). That number refers to a specific section of the man pages, which are organized by the type of content they describe:

Section	Description	Examples
1	User commands: Executable programs available in user environments (usually in `$PATH`).	`ls(1)`, `grep(1)`
2	System call interfaces: Low-level functions that transfer control to the kernel. Some correspond to actual syscalls (like `read`); others (like `fork`) are wrappers around internal syscalls (e.g. `clone`).	`open(2)`, `read(2)`, `fork(2)`
3	Library functions: APIs provided by user-space libraries like `libc`, `libm`, etc.	`printf(3)`, `malloc(3)`
4	Special files: Interfaces to device files, usually found under `/dev`.	`null(4)`, `random(4)`
5	File formats and config files: Syntax and conventions for text-based configuration.	`fstab(5)`, `passwd(5)`
6	Games and amusements: Games, screensavers, and recreational software.	`fortune(6)`
7	Miscellaneous: Conventions, standards, protocols, charsets, signal descriptions, etc.	`signal(7)`, `man(7)`
8	System administration commands: Tools for sysadmins; often require root privileges.	`mount(8)`, `iptables(8)`

Why this matters? Sometimes, the same name appears in more than one section. A classic example:

Copy & paste between Vim and your system clipboard

me@anagogistis.com (anagogistis) — Mon, 07 Jul 2025 01:24:36 +0300

Yanking (copying) text with y in Vim and then trying to paste it elsewhere won’t work. Likewise, copying text outside Vim and pasting it into Vim with p won’t work either. The reason is that by default, Vim stores yanked text in its internal unnamed register ", which is separate from the system clipboard.

To interact with the system clipboard, we have to explicitly use the + register. For example, we can use "+yy to yank a line into the system clipboard, "+y to yank a visual selection into the clipboard, and "+p to paste from the clipboard into Vim. For this to work though, Vim must be compiled with clipboard support.¹

About

me@anagogistis.com (anagogistis) — Mon, 01 Jan 0001 00:00:00 +0000

Anagogistis (Greek: αναγωγιστής) means reductionist — someone who tries to understand complex things by breaking them down to their simplest parts.

Hello! I’m Andreas and this blog is my personal space where I share notes, things I learn, and small discoveries — mostly about software development, computer networking, Linux and AI.

I write mainly to understand things better myself and to have a place I can return to when I need to look things up.