# Create a directory for global packages:
mkdir ~/.npm-global

# Configure npm prefix:
npm config set prefix '~/.npm-global'

# Add the new path to PATH:
export PATH="$HOME/.npm-global/bin:$PATH"

# Confirm that the configuration has been applied:
npm config get prefix
/home/user/.npm-global

# Install the desired package:
npm install -g @volar/typescript
added 5 packages in 1s

There are other ways around this limitation, but working with npm (and other package managers) in Guix can be a bit of a pain. This simple adjustment is often enough to avoid headaches in most cases.

So I made ESB. It's a small and simple bookmark manager that works inside Emacs. It also encrypts bookmarks, and you can sync them in any way you want.

Idea is very basic: bookmarks are your data, so they should stay in your system, not in someone else’s cloud. Want to sync with GitHub? Go ahead. Self-hosted GitLab? Sure. Your own server? Even better.

The nice thing about keeping bookmarks in Emacs is not only workflow. It’s also about owning your stuff and making it flexible. You can grep them, version control them, backup with dotfiles, or write scripts to do whatever you want.

Also, you're free from browser companies. Change browser? Bookmarks are still there. Change OS? Still there. Want to move to different system later? It's JSON, so export is easy.

And if you sync with Git, you get history. Deleted bookmarks by mistake? git revert. Want to check what links you saved last year? git log can show.

But, let’s be honest. This setup is not for everyone. You need to set up GPG, Git repo, and remember to commit. If you just want bookmarks to work and don’t want to think too much, the browser way is easier.

Also, ESB is only in Emacs. If you browse a lot outside Emacs, it’s not so nice. You can still look at the file, but not use the Emacs functions.

GPG can also be tricky, especially when you use many computers with different configs. I try to explain this in the README, but it’s still harder than clicking “sync” in browser, of course.

If you live inside Emacs and care more about control than convenience, I think ESB is good for you. If you keep dotfiles in Git, run your own stuff, and like tools that play nice together, maybe try it.

But if you just want bookmarks that sync and you don’t want to worry about how, then browser is better. That’s fine too, not everyone needs the same thing.

If you’re curious, the code is on GitHub, AGPL license. PRs, issues, or just feedback are all welcome. It works fine for me, but I want to see how others use it too.

GitHub link: https://github.com/0xhenrique/esb

The story takes place in a world where artificial intelligence has evolved to the point where it is difficult to distinguish robots from humans. As expected of any work with this premise, the author uses this basis to raise reflections on humanity, ethics, morality and even religion. However, one of the biggest problems I found with Pluto was the attempt to draw a parallel between robots and slaves. On the surface, it may seem like a valid comparison, but it's not. The reason is simple: robots are not living beings, let alone humans.

Although there is a significant difference between a simple calculator and a robot with advanced artificial intelligence capable of simulating human emotions, that doesn't make it valid to equate robots with slaves. However advanced an AI may become, it will still be ARTIFICIAL. The moment you suggest that these machines should have the same rights as humans, you are actually lowering the meaning of what it means to be human, equating us with mere codes and circuits.

I believe that the two biggest flaws in the narrative are exactly these: the attempt to humanise the robots to the point of comparing them to slaves, and the implication that they possess genuine empathy. I'll explore these issues in more detail below.

I hope I'm not using a Strawman fallacy here, but my impression is that the author is trying to generate empathy for the robots through this analogy. By portraying the conditions in which they lived before the implementation of the International Robot Laws, it is clear that the intention is to move the viewer, evoking feelings similar to those we experience when learning about the horrors of slavery in real history.

However, there is a fundamental difference between the two cases: human emotions are real, while the emotions of robots are only SIMULATIONS. When an enslaved human being is forced to work under degrading conditions, both their body and their mind suffer real damage. Fear, fatigue, illness and death are concrete and REAL consequences. A robot, however advanced, merely simulates these states. Just as we feel empathy for fictional characters in a film, we can be moved by the robots in the story - but that doesn't make them comparable to humans.

This is another point that the author deals with in a paradoxical way. At the same time as he tries to convince the viewer that robots are highly humanised, he himself exposes the limitations of this supposed empathy. The best example of this is Uran. In the anime, her ability to ‘feel’ human feelings is described as impressive. After Atom's death, we see that she has ‘suffered’, something that is perceptible to the people around her. However, this idea is contradicted when Uran realises that the pain of a boy, a victim of bullying, is much deeper than hers.

This scene completely breaks the idea that robots can really feel like humans do. If even one of the world's most advanced machines, programmed to recognise and react to human emotions, shows less grief for losing her brother than a child who has been bullied, how can we equate these robots with human beings? This inconsistency ends up undermining the author's own proposal.

For me, the highlight of Pluto remains the first episode. The story of Sir Duncan, an elderly musician who has lost his sight and starts living with North #2, one of the most advanced robots in the world, is well done. Apart from showing the horrors experienced by North #2 in the war, the episode also explores Duncan's childhood in a more satisfying way than the rest of the series. Even the soundtrack of this episode stands out, being more striking than that of the rest of the anime. I could even say that watching just the second half of the first episode gives you a better and rewarding experience than watching all the following episodes.

The end of the story is different from the rest of the series. Yes, I understand that inside Pluto was Sahad, a ‘good-hearted’ robot, but seeing his shell of hatred defeated with a few words from Atom made it feel like I was watching Naruto, not a work by Urasawa. All the hatred that motivated the destruction of the seven most advanced robots in the world was simply dispelled with a ‘hatred isn't worth it’. And no, this isn't just a problem with the anime adaptation - it's exactly the same in the manga. Even if Sahad was a robot with no bad intentions, Pluto was pure hatred, and seeing him defeated with such a simplistic cliché completely undermined the climax of the story.

I also missed a more memorable soundtrack. There were several moments in the anime when the lack of an emotional music made some scenes less impactful than they could have been. Overall, the music in Pluto seems to serve more as a backdrop than as an element to intensify the emotions.

Pluto starts in a good spot, excellent direction and artwork, but it fails to explore its narrative and the problems presented. The attempt to equate robots with humans fails to sustain the complexity of this discussion. The first episode is exceptional, but overall the plot is very inconsistent. The anime ends in an anticlimactic and simplistic way.

In the end, Pluto raises interesting questions, but fails to answer them reasonably.

I honestly don't remember the first time I heard about Emacs, but I remember the first time I tried to use it I got gatekept by the Elisp magecraft. After that, I spent some days trying to learn some basic concepts of this ancient text editor. Thanks to https://learnxinyminutes.com/docs/elisp/ I was able to write some simple functions to make my Emacs experience smoother. To be honest, I didn't really liked to write Lisp back then, it sucked a lot for me. Even reading simple functions was a hassle since I wasn't used to see through all the parenthesis. At that time, I already knew about the 'Structure and Interpretaion of Computer Programs' book, but didn't read until then. It was only after seeing the MIT class linked below that I got hooked into computer magecraft:

Lecture 1A: Overview and Introduction to Lisp: https://www.youtube.com/watch?v=-J_xL4IGhJA

That was when I finally decided to read the SICP and, consequently, learn Scheme.

And that alone is huge win for Guix. Configuring Nix packages was a pain in the ass. Not because you need to set everything up from scratch (that's not even a problem), but because the language is confusing as hell and the documentation doesn't help. It's not a secret, everywhere you go on the internet you will find people complaining about how the Nix language is hard to grasp, but no because it is complex, just because it lacks proper documentation. You can't be sure to find what you're looking for. All the information is fragmented on the internet, there is not a place where you can just find what you're looking for. At the end of the day you spend more time guessing "where the information is" rather "how to do X". For instance, here's a comparison between the figlet package ported to Nix and the one ported to Guix:

And no, I'm not even talking about how the Nix code is bigger than the Scheme code, that's not really a problem. The thing is, which one is easier to read? Which one is easier to maintain? Which one is more elegant? Which one is more expressive about what it does? The Nix language was a mistake and I think it is the Achilles' heel of the Nix project. I can assure you that most of the people using NixOS right now don't even know how the language works, most of the time tthey just copy and paste code that was already written by some Nix wizard and call it a day. But the moment you need to do something new you're left in the lurch. But I have to admit, most of the Nix wizards are nice people and they will probably help you. The thing is, do you really want to depend so much on the community to get things done?

Guix solves that. It's not like you need to learn a complex language to start with Guix, Scheme is relatively simple and most of the time the docs are everything you need to get up and running. Packaging a program for Guix isn't hard, I plan to make another blog post to delve into that soon.

There are some reasons why some Emacs wizards stick to LISP: metaprogramming, macros, higher-order functions, recursion etc. Not only that, LISP is a crucial part of computer science history. It helps you understand why things are the way they are. It helps you understand mathematical concepts. It helps you understand functional programming. It helps you understand core concepts of programming, hence Scheme is used as the language for the SICP book.

And yes, Nix also supports abstractions, but Guix's use of Scheme provides more powerful and general ways to define those abstractions. Since all the Guix configuration and packaging logic is expressed in Guile Scheme, you can deeply customise and program your system at at level. For instance, you can define custom operating system services, package definitions, or system configuration options entirely in Guile Scheme. You can't really say the same for NixOS. The language itself is more limited to package definitions, which makes it harder to set system-level configurations. If you want to customise deeply at system-level you will probably need external scripting or some other configuration management tools.

Scheme has a long history in theoretical computer science and has been used for decades in academic research and programming language design. Using Scheme to configure your system basically gives your superpowers, it's pretty much like standing on the shoulders of giants. To be honest I don't see a point in learning such a complex language as Nix just to define packages. Scheme gives you so much potential for broader use cases other than package definitions. System configuration, scripting, automation, general programming, you name it. Even if you don't plan to write packages for Guix you still can use Scheme for lots of other tasks, specially if your using the Guix operating system.

Guix places more emphasis on software freedom and adheres to the FSF standards for ethical distros.

Yes, I do use some proprietary software, but that's something I want to change. I would say that the only reason I still use the Linux kernel is because of the lack of free bluetooth drivers for my laptop. That's something I also want to change. I made a mistake buying a bluetooth headphone, specially because I already knew that there were no free bluetooth drivers for me. I hope to abandon Linux and its proprietary binaries as soon as possible. Software freedom might be hard to achieve, but freedom in general isn't easy to achieve.

Assuming you already have Python installed in your machine:

$ git clone git@github.com:all123all/monogatari.git
$ cd monogatari
$ python monogatari.py

If you're using Linux you probably will need to install tk manually:

//Arch based distros
$ sudo pacman -S tk
//For Ubuntu based
$ sudo apt-get install tk

• Basic text editor functionalities (create file, open file, exit etc.)
• Black background and a colorpicker option to choose another color
• [ ] Test routine for the basic functionalities
• [ ] Release a package
• [ ] The close function is being called even when the file isn't modified

• Click the fork button on top right
• Git clone your fork
• Connect with my repo:

$ git remote add all123all git://github.com/all123all/monogatari
$ git remote -v

You are now ready to start to code! Just do as always:

$ git add .
$ git commit -m "fix: something that was fixed"
$ git push

Then you can create a pull request right here on Github. Just go to the Pull Requests tab and select `New pull request` button to do so.

Although it is not really necessary to run this program, having fzf and xclip would be great if you want to integrate with other programs. A pretty useful command to fetch your bookmarks would be:

$ lum -l | fzf | xclip -selection clipboard

While I'm not deploying binary packages to Lum, I can check my bookmarks through Emacs with a very simple function:

(defun pache/my-consult-bookmark ()
  "Select a bookmark using `completing-read` and copy it to the clipboard."
  (interactive)
  (let* ((candidates (split-string (shell-command-to-string "java -jar ~/path/to/lum-1.0.0-SNAPSHOT-standalone.jar -l") "\n" t))
         (selection (completing-read "Select bookmark: " candidates)))
    (when selection
      (kill-new selection)
      (message "Copied to clipboard: %s" selection))))
(global-set-key (kbd "C-c b") 'pache/my-consult-bookmark)

• Lainzine (Lain Magazine): https://lainzine.org/
• About Software Privacy and other topics: https://digdeeper.neocities.org/
• Reminds of Fauux: https://blackwings.neocities.org/
• Fauux: https://fauux.neocities.org/
• Tatsumoto's guide to Nihongo: https://tatsumoto.neocities.org/

• Oh! PC (Jul 01 1990) [Content in Japanese]: https://archive.org/details/oh-pc-issue-127-jul-01-1990/Oh%21%20PC%20Issue%20127%20%28Jul%2001%201990%29/mode/2up
• Comptiq Manazine [Content in Japanese]: https://archive.org/search?query=comptiq
• The Symbol of the Knights of Eastern Calculus: https://web.archive.org/web/20200121124624/http://www.cjas.org/~leng/knights.htm
• MSX Magazine (1985-02) [Content in Japanese]: https://archive.org/details/msx-magazine-1985-02-ascii-jp/mode/2up

• A ~modern~ Javascript approach to SICP: https://sicp.sourceacademy.org/
• A blog by Sam Greydanus: https://greydanus.github.io/
• Xah Lee (he's also one of the minds behind ergoemacs and xah-fly-keys): https://xahlee.info/
• Sasha Chua blog: https://sachachua.com/blog/
• Lunduke Journal: https://lunduke.substack.com/

If you find a broken link or a website that shares things that are clearly illegal, please let me know by email so I can remove it: <hm2030master@proton.me>.

Also, if you don't want me to list your website here, feel free to also contact me via email so I can remove it.