What changed in my studying

I’ve recently switched to Omarchy for the built-in agent integration and moved much of the “computer” out of my way. I spend less time coding by hand and more time studying with gnosis, while working with my agent to improve the tools around it. I’ve added FSRS, 3D models for anatomy, and agent support for creating custom study sessions.

For a concrete comparison, I can have my agent write lecture summaries in about two minutes. The same amount of work would take a colleague three to five hours, often arriving later that day. By the time the summary arrives, I could already have spent those hours studying it.

I used to have average grades and was probably the laziest student in my classes. Now I’m among the top students. I haven’t suddenly become obsessed with grades or developed a love for every subject in my syllabus. I’ve developed an itch to optimize my learning, and making software around it has become cheap enough to keep scratching.

The social cost

I used to collaborate with colleagues to create questions and notes for our classes. We maintained shared resources and passed them down to the next generation of students. Even as the lazy one, I used to organize people so I could maintain my laziness :)

Now I hardly interact with most of them. Until they are agent accelerated as well, collaborating on this work slows me down. A lecture summary takes my agent two minutes and a colleague half a working day. Dividing up the work used to save me effort. Now it means coordinating with people and waiting for something I could already have in front of me.

Most of my colleagues aren’t into tech. Some still take notes with pencil and paper, while I’m having an agent turn lecture material into resources for my study environment. We sit the same exams, but I can no longer plan my studying around the pace of that workflow.

Working with people who also use agents is another matter. But that isn’t the circle I’m in. For passing my classes, setting up my own agentic bubble and staying inside it has become the most efficient option. I see less value in coordinating that work with other people now. I still want their company; I just don’t need to organize a study group to get a lecture summary written.

Maybe the issue is how much of my social life I built around getting something done together. There was always an exam to prepare for, notes to divide up, some task to coordinate. Remove the need for that work and a surprising amount of the interaction disappears with it. I probably need to get better at meeting people because I want to spend time with them, without needing a shared task as the reason.

Why I find it hard to stop

Almost every waking hour now goes into studying, improving my study tools, or working out. My sleep schedule was already messed up; now it’s closer to a vampire’s. My adenosine receptors probably consider caffeine a permanent tenant.

I study with the agent too. I have it teach me the material, explain things I don’t understand, and constantly quiz me. Studying becomes an ongoing conversation: I ask questions, try to explain things back, and answer its questions instead of just reading another page of notes. There is always something to respond to, and I want to keep going until I understand it.

Getting more done hasn’t made me want to work less. Between that conversation and improving gnosis, studying itself has become much more rewarding. When I notice a problem with how I’m learning something, I can have my agent help improve the tool and use the change in the same study session.

An idea that would once have taken a weekend of coding can now be worth trying before bed. Or I want one more explanation, then another round of questions to see whether I’ve understood it. Going to sleep means putting down work that I actually want to do. Being this engaged in studying is much harder to walk away from than being bored.

Freedom and dependence on compute

What attracted me to the hacker community was self-reliance. I wanted to learn how to adapt my tools to fit my needs, rather than accept whatever a guy in a corpo decided I should want.

I want to own my software and decide what it does. Agents have made that cheap enough to act on. Coding by hand is no longer worth my time. Knowing how to manage agents is worth more to me now than being able to write all that code myself. I’ve had them produce millions of lines, from Haskell to Python, that I could never have written in the same period even as a full-time developer.

Writing my own OS, from the kernel up, used to be an absurd demand on my time. Now I look at it and think about how much compute I could throw at it.

That puts an expensive condition on self-reliance. I can make the software do what I want, but keeping that ability independent of a model provider requires compute of my own. Having the source on my disk doesn’t give me the hardware to run the agents that produced it.

For the way I want to work, powerful hardware is becoming more important than the software I start with. I can have agents replace software. I can’t prompt a GPU into existence.

I hope more smart people work on chips, manufacturing, and production capacity so that what costs $100K in compute today becomes accessible for $5K in the future. One can hope. Self-reliance gets a rather different meaning when the equipment costs more than most people can afford.

Some people will want to yell at the cloud about this change. I still think it’s for the best. Programming often felt like a priesthood: learn the language before you’re allowed to ask the machine for anything. The “agent reformation” lets many more people build the software they want. But if the congregation still has to rent access to the machine from a handful of companies, we haven’t gone as far as I want.

I want the means of production on my desk. :)

I am a medical student who still ships free software. My hours are finite. I will not burn them answering people who treat agent-assisted work as a moral crime and then demand my attention on top of it.

The forge was never neutral

Codeberg is not uniquely cursed. It is just where a lot of this shows up. People moved there for decent reasons. Fine. That does not make the surrounding culture immune to fashion, or to using a public desk as a free harassment channel.

If your software politics mean other people owe you free labor on your terms, that is not freedom. That is a small tyranny with a FOSS sticker on it: treat maintainers like unpaid hands, call refusal immoral, and pretend the whip is principle.

Primary sources already live on git.thanosapollo.org. Mirrors were convenience, not principle. I am done maintaining emacs-forgejo too. Own forge, own tracker. Autonomy without the branding.

The pirates became the copyright cops

I am anti-copyright. I admire Aaron Swartz. The old hacker line was not subtle: information wants to be free; we are your worst nightmare. That meant universal access, not “free only when it flatters my identity as an artisan.”

Who is dissolving paywalls and locked-up code right now? Mostly the companies everyone loves to hate. Models ingest everything and make trapped material queryable. Swartz’s dream, approximated for profit.

And a large chunk of FOSS answered how? Crying theft. Crying copyright. Filing the same weapons they used to despise. People who correctly hated SOPA now beg copyright maximalism to save them from a model that read their README.

The pirates became the copyright cops. The corpos became the accidental liberators. I am not licking OpenAI or anyone else. Profit is not virtue. The inversion is still real. The purity crowd flipped the second the information being liberated was theirs.

That is guild protection with better vocabulary. Call it free software if you want. I will not.

“Anti-human” is historical illiteracy

Say agents are useful and that hand-coding routine first drafts is mostly dead labor, and a certain type arrives on schedule: lazy, fake, traitor to craft, anti-human.

Humans invent levers: fire, writing, compilers, package managers, tests. Using a stronger tool is the oldest human move there is. Refusing one can be taste. Do not dress slower labor up as morality.

Every serious GPL project already says it: ABSOLUTELY NO WARRANTY. Not hand-typed by saints. Useful software, as-is, your risk. Calling agent-built free tools anti-human while the license disclaims warranty is fashion, not engineering.

Life update

I am back putting the boxing gloves on and training again, not just talking about it. Exams are going well enough that I am not living entirely inside the next deadline. That matters more than another forge notification.

I still care about free software. I care more about software that answers to me. Codeberg is no longer home base. Free licenses stay. Self-hosting stays. The demand that I apologize for levers does not.

Current work: gnosis moving toward a gnosis-core with FSRS, plus Emacs and web clients; emacs-jabber, XMPP gateways, Nix machines, local trackers, Emacs front-ends to the agents I run. Agents under review and constraints, not vibes as a personality cult. Fewer attention sinks; I already wrote about that in Cheap Code, Expensive Attention.

If a project teaches me something, improves a tool I run, or puts me next to people whose judgment I trust, it can have my attention. Status anxiety and FOSS-skinned harassment cannot.

Want the code? Use the git server. Want an argument about whether compilers were also cheating? Keep it. I have patients to study for, rounds to throw, and a homelab to maintain.

I used to contribute to quite a few FOSS projects. Lately I have stepped back from several, especially the ones where the attention required started to feel out of proportion to what I got back.

Take packaging work for GNU Guix, where I was briefly involved. This PR updated a package I maintain, emacs-jabber. Writing the recipe took roughly five minutes. After an initial positive review, the thread expanded into a longer discussion about dependency handling, recursive checkouts, and vendored cryptographic code. There was no clear owner of the review and no obvious stopping point. The total attention cost ended up being many times higher than the original contribution.

I am not singling Guix out. Plenty of projects have the same structural problem: review processes that can turn small patches into open-ended attention sinks. When I can point an agent at the same task and iterate quickly, or just maintain the package outside the main distribution, the old calculation stops making sense.

The question is no longer “can I do this?” It becomes: Is my limited attention better spent here than somewhere else?

This does not make all FOSS contribution pointless. It just raises the bar. A contribution is worth my attention when it teaches me something new, meaningfully improves a tool I actually use, or connects me with people whose judgment I value. That thread did none of those things.

Nobody becomes a better Schemer by writing yet another package recipe and reading build logs. An agent running a decent model could have handled most of that loop and caught the obvious review points. Without clear policy and explicit review expectations, even a checklist-driven agent can be more useful than unstructured human review.

This applies to any contribution where the work itself is now cheap enough that a model can do it for a few cents, but the human coordination around it has stayed expensive. At that point, doing it by hand is no longer obviously worth your attention.

Code has become cheap

ESR recently wrote that the age of hand-coding is mostly over. I think he is mostly right. The real shift is not that humans stop writing code. It is that code has become cheap enough to meaningfully increase individual autonomy.

When I already know what I want a tool to do, what stack it should use, and how it should fit into my workflow, I no longer need to hunt for an existing project, evaluate its abstractions, adapt my process to it, or inherit its maintenance burden. A local model can just generate a focused implementation for me.

This changes the dependency relationship. Instead of relying on third-party developers I do not know, whose priorities, judgment, and long-term commitment are always uncertain, I can produce exactly what I need. The result is often higher quality for personal use, because it contains only the behavior I want and none of the assumptions or baggage I do not want.

Cheap code does not just make development faster. It reduces the need to outsource small but important parts of my computing environment to strangers.

Why I use GNU Guix for my server

GNU Guix is my preferred system for every machine I use, recently I even switched my home server (back) to Guix. I use my home server to host this blog as well as my cgit instance, so far I recommend using Guix, as a hobbyist, for the following reasons:

• Roll backs
  • I had tried both Gentoo and Debian before for my server, more than once I had one or more of my self hosted services down because an update broke my setup. My time is limited and those breakages would often occur at busy weeks where I didn’t have the time to fix them. With Guix I can just roll back to a previous working generation if an update or a misconfiguration of mine breaks something.
• Reproducibility
  • Define your setup once, run anywhere. I do not want to manually setup anything.
• Simplicity
  • The entirety of Guix code lives in one repo and is almost entirely written in one language, guile scheme. If you find any issues with a service or a package you can redefine it as you like in your configuration.

Why self-host a git server?

Why would you not self-host your own projects? I find it antithetical to the FOSS ethos, and perhaps even ironic, to rely on proprietary platforms for distributing free software.

Hosting a Git server is straightforward and requires minimal resources.

git-http-backend “/” uri issue and fix

Guix has a separate configuration data type for serving Git repositories over HTTP. Currently, the regex it uses does not allow the root "/" to be used a URI for serving (ref archive).

The issue is in the (gnu services version-control) module, specifically in this part:

(define* (git-http-nginx-location-configuration #:optional
                                                (config
                                                 (git-http-configuration)))
  (match config
    (($ <git-http-configuration> package git-root export-all?
                                 uri-path fcgiwrap-socket)
     (nginx-location-configuration
      ;; ISSUE here: regex won't allow for "/"
      (uri (string-append "~ /" (string-trim-both uri-path #\/) "(/.*)"))
      (body
       (list
        (list "fastcgi_pass " fcgiwrap-socket ";")
        (list "fastcgi_param SCRIPT_FILENAME "
              package "/libexec/git-core/git-http-backend"
              ";")
        "fastcgi_param QUERY_STRING $query_string;"
        "fastcgi_param REQUEST_METHOD $request_method;"
        "fastcgi_param CONTENT_TYPE $content_type;"
        "fastcgi_param CONTENT_LENGTH $content_length;"
        (if export-all?
            "fastcgi_param GIT_HTTP_EXPORT_ALL \"\";"
            "")
        (list "fastcgi_param GIT_PROJECT_ROOT " git-root ";")
        (list "fastcgi_param GIT_CONFIG_GLOBAL "
              (plain-file "gitconfig"
                          (string-append "[safe]\n\tdirectory = " git-root "/*\n"))
              ";")
        "fastcgi_param PATH_INFO $1;"))))))

Thankfully, we can easily resolve this by redefining (gnu services version-control).

• My changes (diff) to fix this issue, as well as specify git actions:

diff --git a/gnu/services/version-control.scm b/gnu/services/version-control.scm
index a7f40812a6c..e33e5de21f0 100644
--- a/gnu/services/version-control.scm
+++ b/gnu/services/version-control.scm
@@ -235,7 +235,11 @@ (define* (git-http-nginx-location-configuration #:optional
     (($ <git-http-configuration> package git-root export-all?
                                  uri-path fcgiwrap-socket)
      (nginx-location-configuration
-      (uri (string-append "~ /" (string-trim-both uri-path #\/) "(/.*)"))
+      (uri (string-append "~ "
+			  (if (string=? uri-path "/")
+                              ""
+                              (string-append "/" (string-trim-both uri-path #\/)))
+			  "/(info/refs|git-upload-pack|git-receive-pack)"))
       (body
        (list
         (list "fastcgi_pass " fcgiwrap-socket ";")
@@ -254,7 +258,7 @@ (define* (git-http-nginx-location-configuration #:optional
               (plain-file "gitconfig"
                           (string-append "[safe]\n\tdirectory = " git-root "/*\n"))
               ";")
-        "fastcgi_param PATH_INFO $1;"))))))
+        "fastcgi_param PATH_INFO $uri;"))))))


 ;;;

You can find the full module that I use here in my dotfiles repo.

I’d recommend creating your own module and load it by running the following command:

sudo guix system reocnfigure ~/dotfiles/guix/server-config.scm -L ~/dotfiles/guix

Configuring cgit-service-type

Guix provides a cgit service module (gnu services cgit).

A couple things to note:

• You can provide css and favicon using an external url. You can find the css styling that I use here.

Example cgit-service-type

(define my/git-repos
  (list
   (repository-cgit-configuration
     (url "repo1")
     (name "repo1")
     (desc "Example Repo 1")
     (path "/srv/git/repo1")
     (section "Section 1"))
   (repository-cgit-configuration
     (url "repo2")
     (name "repo2")
     (desc "Example Repo 2")
     (path "/srv/git/repo2")
     (homepage "https://myhomepage")
     (section "Section 2"))))

(service cgit-service-type
         (cgit-configuration
           (package cgit)
           (root-desc "Root Desc")
           (repository-directory "")
           (root-title "Root Title")
           (repositories my/git-repos)
           (enable-index-owner? #f)
           (enable-http-clone? #f)
           (clone-prefix '("https://git.thanosapollo.org")) ;; change this to your own url
           ;; Cache
           (cache-root "/var/cache/cgit")
           ;; 20000 = 5 hours.  Feel free to adjust this.
           (cache-size 20000)
           (cache-static-ttl 20000)
           (cache-dynamic-ttl 20000)
           (cache-repo-ttl 20000)
           (cache-root-ttl 20000)
           (cache-scanrc-ttl 20000)
           (cache-about-ttl 20000)
           (cache-snapshot-ttl 20000)
           (case-sensitive-sort? #f)
           (css "https://thanosapollo.org/cgit.css") ;; My personal css.
           (nginx
            (list
             (nginx-server-configuration
               (server-name '("git.thanosapollo.org"))
               (root cgit)
               (try-files (list "$uri" "@cgit"))
               ;; I use cloudflare tunnel, which handles certs for me.
               (listen '("80"))
               (ssl-certificate #f)
               (ssl-certificate-key #f)
               ;; ;; If you use certbot try the following:
               ;; (listen '("443 ssl"))
               ;; (ssl-certificate
               ;;  "/etc/certs/git.my-host.org/fullchain.pem")
               ;; (ssl-certificate-key
               ;;  "/etc/certs/git.my-host.org/privkey.pem")
               (locations
                (list
                 (nginx-location-configuration
                   (uri "@cgit")
                   (body '("fastcgi_param SCRIPT_FILENAME $document_root/lib/cgit/cgit.cgi;"
                           "fastcgi_param PATH_INFO $uri;"
                           "fastcgi_param QUERY_STRING $args;"
                           "fastcgi_param HTTP_HOST $server_name;"
                           "fastcgi_pass 127.0.0.1:9000;")))
                 (git-http-nginx-location-configuration
                  (git-http-configuration
                    (uri-path "/")
                    (export-all? #t))))))))))

You can find my home server configuration here.

Not anymore :)

TLDR: I switched from a thinkpad x220 to a Raspberry Pi 5, which I use to access my desktop remotely.

Raspberry Pi 5 with 3d printed custom VESA mount on Raspberry Pi Monitor

Project Goals

My aim with this “project” is to have a small, portable, and modular device that I can simply toss in my bag and not worry about it’s battery life throughout the day.

The extra thing that I want, is to prove that you do not need to “sell your kidney” and bow down to a corporation for the ‘privilege’ to use their hardware designed for obsolescence or their bloated software.

Hardware I’m using:

• Things I’ve purchased:

  • Raspberry Pi 5 8GB
  • Raspberry Pi Monitor

• Things I’ve already had:

  • 27000 mAh power bank
  • Keyboard

I bought a Raspberry Pi 5 kit that came with a case fan for 100€. The total cost for this project was 195€, for the Pi and the monitor.

Battery Life

I’m usually out of home for over 7 hours a day for my studies, and I enjoy studying in cafes and libraries. I’ve missed having a device with a battery life of 10+ hours, as my x220 barely lasts more than 4.5 hours.

Using a 27000mAh power bank, I get ~15 hours of battery life. I also carry an extra “emergency” power bank.

With great power (and battery life) comes great productivity

The monitor consumes more energy than my Pi.

Modularity

I strongly dislike laptop keyboards and I insist on using ones with a trackpoint. I’m currently using a shinobi keyboard, which I can simply plug into my Raspberry Pi and use just like on my desktop.

If I do not like something about my Pi setup, it’d be trivial to change, such using a new monitor, a new keyboard or another power bank.

Performance & File Synchronization

Can the Pi outperform a modern laptop of >1000€ price range? Yes and No :)

Now, you might be wondering; how can my Pi deliver better performance than, say, a MacBook Air? A valid question, but as a GNU+Linux user, I’ve come to embrace the possibilities. Anything’s possible with a bit of hackery and FOSS magic.

I use waypipe, a Wayland proxy, to run Emacs remotely over a network. Emacs runs on my desktop, but I access it from my Pi, great performance while seamlessly accessing all my desktop files, such as my notes and PDFs, this also removes any need for syncing files between devices.

I have fiber connection, so there isn’t any latency issues between my devices using a wireguard VPN.

Accessing my desktop Emacs session remotely, opening a PDF and eshell.

Conclusion

I will be using this setup for the rest of the academic year. I might record a more detailed video with tips and tricks for others that want to try something similar.

So far this has been more than an ideal setup for me, since I quite often forget to sync my notes and projects between devices. Not having to worry anymore about the battery life of my device is quite relaxing as well.

Here’s a simple code snippet to launch an emacs temp frame for input instead.

(defun thanos/wtype-text (text)
  "Process TEXT for wtype, handling newlines properly."
  (let* ((has-final-newline (string-match-p "\n$" text))
         (lines (split-string text "\n"))
         (last-idx (1- (length lines))))
    (string-join
     (cl-loop for line in lines
              for i from 0
              collect (cond
                       ;; Last line without final newline
                       ((and (= i last-idx) (not has-final-newline))
                        (format "wtype -s 350 \"%s\""
                                (replace-regexp-in-string "\"" "\\\\\"" line)))
                       ;; Any other line
                       (t
                        (format "wtype -s 350 \"%s\" && wtype -k Return"
                                (replace-regexp-in-string "\"" "\\\\\"" line)))))
     " && ")))

(defun thanos/type ()
  "Launch a temporary frame with a clean buffer for typing."
  (interactive)
  (let ((frame (make-frame '((name . "emacs-float")
                             (fullscreen . 0)
                             (undecorated . t)
                             (width . 70)
                             (height . 20))))
        (buf (get-buffer-create "emacs-float")))
    (select-frame frame)
    (switch-to-buffer buf)
    (erase-buffer)
    (org-mode)
    (setq-local header-line-format
                (format " %s to insert text or %s to cancel."
                        (propertize "C-c C-c" 'face 'help-key-binding)
            (propertize "C-c C-k" 'face 'help-key-binding)))
    (local-set-key (kbd "C-c C-k")
           (lambda () (interactive)
             (kill-new (buffer-string))
             (delete-frame)))
    (local-set-key (kbd "C-c C-c")
           (lambda () (interactive)
             (start-process-shell-command
              "wtype" nil
              (thanos/wtype-text (buffer-string)))
             (delete-frame)))))

Make sure wtype is installed in your system for the above snippet to work.

All you have to do now is just bind emacsclient --eval '(thanos/type)' to a shortcut of your liking.

On my Hyprland setup I’m using the following settings

bind = $mainMod, j, exec, emacsclient --eval '(thanos/type)'
windowrulev2 = float,class:^(emacs)$,title:^(emacs-float)$ # Launch as a floating window.

For xorg users, you can simply rely on the Emacs Everywhere package. Unfortunately it does not support Wayland yet and I have not tried it.

XMPP is a libre decentralized collection of technologies, alternative to closed communication services. I’ve started self hosting my own xmpp server, and begun moving people from my close circle there. This is a summary of my collection of notes that I made for XMPP thus far, published as a short article. If you are interested in learning more on XMPP I recommend reading their official website.

What is XMPP?

XMPP stands for eXtensible Messaging and Presence Protocol, it’s a set of libre technologies that can be used for communication services, such as instant messaging, voice & video calls as well as file transfers. This is done by routing XML data.

XMPP operates similarly to HTTP, with the client initiating a communication socket to an XMPP server and maintaining it open for the entirety of the client’s active session.

XMPP was originally developed in the Jabber community to provide an open decentralized alternative to closed messaging services.

XMPP is used by a few popular platforms, these include WhatsApp, Facebook Messenger & Jitsi.

Why should you use XMPP?

For me, the primary appeal of XMPP lies in its interoperability, versatility, and extensibility. Via transports or gateways, XMPP enables a seamless connection with communities across various platforms including IRC, Matrix, WhatsApp, Telegram all from a single client.

Furthermore, the decentralized nature of XMPP is designed for self hosting, with minimal resources. This gives me the freedom to establish and manage my own server, creating an ecosystem that provides me with freedom & respects my rights, to which I can bring my family and friends.

How to communicate with IRC & Matrix using XMPP?

You can use a gateway that connects to your desired platform/protocol. For example, for IRC you’d use biboumi or btifrost for Matrix.

There are publicly available gateways, for example you can use the the biboumi gateway from jabberfr.org to connect to the emacs IRC channel in libera.chat like this #emacs%irc.libera.chat@irc.jabberfr.org

Self hosting an XMPP server

If you are not interested in self hosting an XMPP server, refer to this list to find servers to register to.

ejabberd

I opted to use ejabberd server for my setup, which I found really simple to setup with voice & video calls.

Setting up an ejabberd server is that simple that it does not really require instructions. I’d recommend you use their RUN Installer or if you are on debian/fedora to check out their releases for an rpm/deb package.

Other server & client options can be found here.

XMPP clients

All in all, XMPP offers user friendly clients in all platforms, that everyone can use, as always refer here for up-to-date recommendations.

This is what I personally have been using this past week with XMPP & recommend.

Mobile

• For android, I’d recommend to use cheogram, it’s based on conversations with a few visual tweaks and additional features.
• For iOS, I’ve installed Monal to my friends & family. I’m not sure if it’s the best one available since the iOS ecosystem is foreign to me, but the people I’ve installed it on found it pleasant to use.

Desktop

• I’d recommend Dino, it’s been really easy to use with full support of most xmpp features (OMEMO encryption etc.)
• There is also emacs-jabber, an emacs jabber extension, that unfortunately does not support any kind of encryption. It’s decent for public unencrypted channels.

Setting up immich is quite simple, just follow the official documentation. They even offer an installation script.

Recommendations

I advise against using services like Cloudflare Tunnel to make Immich accessible publicly for security and privacy concerns. Instead, consider using a VPN service such as tailscale/headscale for a more secure & convenient setup.

If you are using iCloud for your photos, there is a memory leak bug that will cause the iOS app to crash when uploading large amounts of media files. Either first download all your photos from iCloud & then upload to them Imminch, or “babysit” your phone while it’s uploading.

My new setup

For the past ~6 months, I have been relying on a VPS service from Ionos, which offers a decent service for it’s price plans, to host this site & my git server, as well as to occasionally port forward media services such as jellyfin using an ssh tunnel. This weekend, I opted to migrate to an old thinkpad that I had collecting dust plus cloudflare tunnel.

Cloudflare tunnel is ideal for securely connecting a self hosted web server to Cloudflare’s global network. But be aware that cloudflare can decrypt your traffic. I do not recommend using cloudflare tunnel to host sensitive information, or to share large media files.

To share media with friends, I use tailscale, I plan in the future to host headscale, a self hosted implementation of tailscale. Tailscale is a zero config VPN, you can add your family & friends to your account or just “funnel” content to a public address to give someone quick access.

Transition Tips

First of all, evaluate your current VPS usage and identify which services can be easily self hosted. I’d recommend to start slowly migrating your services to your own hardware & use ssh tunnel for port forwarding.

Test out cloudflare tunnel, tailscale and other similar services until you find the one you like the most.

I should also note that I consider Spaced Repetition to be a cheat code for learning, that should be used by every student.

What is Spaced Repetition Learning

Spaced Repetition is based on the following premise: > Repetitive exposure to information contributes to the elongation of memory retention.

Our cognitive faculties are inherently programmed to retain pertinent information while discarding extraneous details, a process contingent upon the frequency by which we encounter such information.

TL;DR: The more frequently you are exposed to information, the longer you retain it

My ‘gripes’ with spaced repetition software

I have chosen to develop my own SRS (Spaced Repetition Software/System) instead of relying on existing, well-established ones. Through my implementation called “gnosis” (GNOH-sis, meaning knowledge in Greek) I aim to address and overcome the challenges and limitations associated with current SRS solutions. With gnosis, I hope to resolve most, if not all, of these issues and provide a more refined and advanced learning experience.

Not libreware

This refers to proprietary software that implements spaced repetition, some of which are even guilty for removing the spaced repetition feature that their users paid for. I had a paid subscription with quizlet only to find out that they removed the spaced repetition feature I had already paid & was using, rendering my then workflow obsolete.

Do not depend on software you don’t own for your work. You don’t “own” proprietary software, despite paying for it.

You should strive to use only libreware for your workflow.

Lack of customization

Good software should fit your workflow like a glove, to do that it has to give a lot of room for user customization. Trivial changes such as color-scheme changes to more advanced feature customization like adding your own custom card types and changing the spaced repetition algorithm should be simple and easy to make. For example, a med student would use a longer time interval for his algorithm than, let’s say, someone trying to expand their Japanese vocabulary.

Since we already established the need for our ideal software to be libreware, making changes to the core components would be trivial. But it should be added that customization to fit different needs & learning styles should be a primary goal when designing a SRS.

Flashcards are an inferior learning method.

Flashcards are quite trivial to make, prototypical spaced repetition methods utilized physical flashcards. Today’s computers allows us for more sophisticated ‘review’ methods, such as using user input.

Utilizing user input to assess the effectiveness of a review is preferable to simply revealing an answer and asking whether it was known or not. This approach ensures not only the comprehension of the answer but also the accurate spelling of it. Moreover, it leads to more efficient retention compared to simply displaying the answer without any active engagement from the user.

Ideally with Gnosis I would also like to implement MCQ type to simulate the USMLEs exams which I will hopefully soon be undertaking. This will make it possible to simulate any other MCQ exam

No self-rating

It is recommended that users do not self-rate their answers. The review process should involve a binary assessment of success or failure, where users either recall the answer correctly or not. This success/failure rating will be used to determine the next interval for the specific note, optimizing the spaced repetition system for effective learning.

Collaboration

Most spaced repetition software relies on databases for storage, but the downside is that databases are not easily readable or editable by humans, hindering sharing and collaboration.

To address this limitation, I intend to incorporate exporting capabilities on gnosis. This feature would enable users to export a deck of notes in a user-friendly format, which can then be easily shared and collaborated on using tools like git repositories.

This collaborative approach would allow us to work together, share, and create valuable learning materials that can be used and modified by everyone involved.

Syncing between devices

Anki makes syncing between devices a breeze! But it gets terrible slow if you are syncing a new device when you have a lot of material in your account, plus you depend on Anki’s servers for it to work.

Since on gnosis I will be using sqlite as my database implementation, I would just be using git to keep my database in sync between different devices.

Gnosis

You can find gnosis on my git server here, read the about section for installation instructions.

It’s still not even in alpha version yet, but it has the fundamental functionality there already for you to test. Feel free to email me if you have any questions or requests for gnosis.

Disclaimer: This post contains a healthy amount of sarcasm, just in case you didn’t catch on.

About

I’ve been an Arch Linux user for a while now, Arch Linux was the first distro I’ve ever installed on hardware. It treated me well over the past year, but after trying out gentoo on a virtual machine I think I’ve found my $HOME. Now I’m running Gentoo on all of my devices for the past 2+ weeks.

What did you enjoy so much about Gentoo?

Gentoo Handbook

The Gentoo Handbook, I can’t really stress this enough, the Gentoo Handbook, is extensively documented with every detail you might need, specifically for using Gentoo. The Arch Wiki is awesome, it includes documentation for a wide range of programs, but it’s a generic documentation that feels more like a general “Linux wiki” rather than specific for Arch Linux. Even the parts that are specific to Arch Linux, such as the installation instructions, are severely lacking, which leads to most of the Arch Linux users to rely on third party guides even on how to install their OS.

No other Linux Distribution has a centralized “book” that takes you “by the hand” from the installation process all the way to working with native software tools that you’ll interact with on a daily basis, that can compare to the Gentoo Handbook.

Community

One thing that I advocate about choosing which software to use is:

Use software projects that you wouldn’t mind / would like contributing to

Gentoo community is the most helpful one that I’ve found so far, specifically I’ve had people on the GURU Project, analogous to the AUR package software that I needed as well as help me on contributing, which has been a rather pleasant & chill experience.

If a project has a “toxic” community that you don’t want to interact with, its a huge red-flag for me.

But… Why would you compile everything from source?

Because someone has too…

Jokes aside, there are many advantages to compiling your system from source rather than installing an already made binary that someone else compiled, hoping that it is compiled the way you want.

Mental Outlaw (Invidious) has made a nice video explaining some important details/reasons for running Gentoo, as well as 10leej (Invidious), if you want to learn more.

It takes way too much time install, nobody has time for that!

It doesn’t really take that much more time from installing Arch Linux, I’ve installed Gentoo on my desktop (Ryzen 7 5800X) the first time, in ~2 hours, most of which I’ve spend reading the handbook. For reference, my compile times are as follows:

output of genlop -t <package>

sys-kernel/gentoo-kernel-6.1.57 merge time: 15 minutes and 40 seconds. www-client/firefox-115.4.0 merge time: 15 minutes and 26 seconds. app-editors/emacs-29.1-r1 merge time: 52 seconds. x11-wm/qtile-0.22.1-r2 merge time: 6 seconds.

The only time consuming compile times I’ve seen were for firefox & linux kernel, both of which are just 30 min combined, you also have the option to use -bin packages instead. With the exception of those 2 packages mentioned above, I haven’t spend more than 2 minutes compiling a package.

I’ve first considered setting up distcc for my ThinkPad x220, but eventually I decided to let firefox & gentoo-kernel compile while I’m on the gym for my workout.

Note: I’ve only installed ~700 packages on ThinkPad, and ~900 on my desktop, most of that difference is due to installing qemu/virt-manager on my desktop & random fonts. I’m not using a DE, if you are planning to use GNOME or KDE etc. you might have a different experience than me in that regard, since many DE’s are quite large and take a lot of time to compile.

Summary

I’ve been enjoying running Gentoo on all my devices for the past weeks. One of the main advantages of Gentoo is the control it provides for tailoring your system to your liking. This is bundled with one of the best documentation, if not the best, available to learn everything you need to know about using your Linux system.

The community is rather chill & friendly that welcomes new contributions and will help you with any issue you might have.

If you are able to read and follow instructions on how to install & use your system, you will find Gentoo to be a simple, reliable Linux Distribution, with a helpful community. If you want a “just works” experience, stay away from Gentoo, it’s a “Nerd’s Only Allowed” place.

About

I’ve first registered this site using thanosapollo.com, .com is the default when it comes to today’s websites, roughly 50% of websites use it and that’s what most users are familiar with.

.com stands for commercial/for profit, although it’s sometimes also used by blogs and nonprofit sites to capture more visitors. On the other hand, .org is associated with nonprofit organizations, or that generally provide free information and resources.

The context of this post refers to .org not just as a top level domain, but as a freely accessible FOSS site.

Why switch to .org and why we need more .org sites

I’m not planning to use this site for any kind of commercial/for profit purpose, having a .org extension implies that this site purpose is non-commercial. Even though it’s less popular, I find that today’s web landscape needs more .org sites and less .com.

About ~10 years ago, when I was 13 years old, the web seemed to be a sanctuary of freely available information. 10 years later, even useless information is behind a javascript pay-wall or login portal. The web’s increased traffic has been followed with lesser valuable content creation, with today’s users being accustomed to using the ‘web’ only through mobile social media apps, making them tied to a proprietary ecosystem where they don’t even own their profiles on said platforms, their webmaster does.

We need more sites that offer free information for all and less people behind proprietary platforms. I hope in the future we have more people actually owning the sites they share their content. They might make blogs or whatever else they like, as long as less of them end up at the mercy of big tech .com companies.

Even if you are after creating only for-profit content, making your business depend entirely on a 3rd party is not the brightest idea.

Difficulties of changing my site to .org

The only issue with changing my site’s extension was updating my project’s git remotes & package recipes as well email services to the new domain name. Although this is more of an inconvenience rather than an actual difficulty.