O diálogo ocorre entre Golan Trevize e Janov Pelorat nos primeiros momentos de sua jornada interestelar. Trevize se preocupa com a possibilidade de a nave estar equipada com um hipertransmissor, o que comprometeria a privacidade deles.

Primeiro, Pelorat pergunta:

[…]

— Ah, entendo. Quero dizer, não entendo. O que é um hipertransmissor?

Trevize responde de forma direta:

[…]

— Bom, deixe-me explicar, Janov. Estou em comunicação com Terminus. Ou melhor, posso me comunicar quando quiser, e Terminus pode, reversamente, se comunicar conosco. Eles sabem a localização da nave, pois observaram sua trajetória. Mesmo se não tivessem observado, poderiam nos localizar ao escanear o espaço próximo à procura de massas, o que os alertaria sobre a presença de uma nave ou, talvez, de um meteoroide.

O diálogo avança mais um pouco:

[…]

— Me parece, Golan — afirmou Pelorat —, que o avanço da civilização não é nada além de um exercício na limitação da privacidade.

O diálogo avança mais um pouco e em seguida, uma conclusão inusitada:

[…]

Não haveria nenhum lugar na Galáxia onde poderíamos nos esconder e nenhuma combinação de Saltos pelo hiperespaço possibilitaria nossa evasão dos instrumentos à disposição deles.

— Mas, Golan — disse Pelorat suavemente —, nós queremos a proteção da Fundação, não?

— Sim, Janov, mas apenas quando a requisitarmos. Você disse que o avanço da civilização significava a contínua restrição de nossa privacidade. Bom, não quero algo tão avançado assim. Quero ter a liberdade de me locomover como bem entender, sem ser detectado, a não ser que eu deseje proteção ou precise dela. Portanto, eu me sentiria melhor, muito melhor, se não houvesse um hipertransmissor a bordo.

Open Source Software has been around for over three decades, and by now, we’re all familiar with what it means in terms of licensing, access, and freedom. Open Source Software is defined by a few key principles: transparency, collaboration, community-driven development, and shared ownership. These characteristics ensure that users can inspect, modify, and distribute the code freely, fostering innovation, reducing costs, and promoting trust in software.

It is important to remember that there are Organizations behind Open Source, these organizations ensure that Open Source Software remains ethical, secure, and sustainable, while helping users navigate the complexities of licensing, attribution, and contribution guidelines.

So, how about AI? Like I mention before, if you access HuggingFace you will see, Million of models, but are those models Open Source? What does define an AI model to be Open Source?

An Open Source AI model is defined by principles similar to those of Open Source Software, but with additional considerations specific to AI, such as:

• Training methodology: This includes the algorithms, hyperparameters, frameworks, and optimization techniques used during training.
• Training data provenance: This covers the sources, licenses, curation processes, and ethical considerations (bias, fairness, and data privacy) of the training data.
• Documentation: Comprehensive documentation should accompany the model, including access to source code, pre-trained weights, and step-by-step instructions for reproducibility.
• Ethical and legal compliance: The model must adhere to Open Source licenses like MIT, Apache, and address ethical concerns such as bias audits, data privacy, and transparency in model behavior.
• Community and governance: Clear governance structures, maintainer roles, and collaboration processes (contribution guidelines, version control) should be established to ensure ongoing development and accountability.

In Open Source AI, the source code must be freely accessible and distributed under permissive Open Source Licenses such as MIT, Apache, or similar. Also, these models require full disclosure of the training methodology, the origins and composition of the training data, and ethical considerations.

Sounds great right? Well, despite these definitions and requirements, the reality of Open Source AI today is different. Many models do share access to pre-trained weights, while full source code is often not available. Training data is rarely disclosed, even when models are Open Source. This could be due to a combination of licensing constraints, legal risks (data privacy laws like GDPR), and ethical concerns like protecting sensitive or personal information in the data. Also those models requires Petabytes of data, as you can imagine, sharing such massive datasets is not practical. On more thing to consider is that to training these models isn’t simple. We are talking about tons of GPUs, which are super expensive, hard to come by, and take forever to run. For big companies, this is less of a problem, they have the budget and the infrastructure. But for smaller teams, universities, or Open Source collaborations, this could be challengy.

So, while the idea of Open Source AI sounds great, the reality is that people are stuck balancing transparency with the messy, real world stuff: legal risks, data ethics, and size of the datasets. It’s tricky, but it’s also a chance to rethink how we do AI responsibly without sacrificing progress.

Open Source AI isn’t dead, and it’s definitely not bad. In fact, it’s out there, and it’s doing some seriously cool stuff. You can download models, run them on your local machine or a dedicated server, fine-tune them, or even use them with your own private data (like with RAG). It’s all about customization, and that’s where the magic happens.

Projects like OpenWebAI, Hugging Face, Ollama, and others are making this possible. They’re acting like the ‘bridge’ between the big, fancy AI models (that require mountains of GPUs and cash) and the rest of us. These tools let you pick and choose models that actually fit your needs whether you’re a student, a small team, or a nonprofit.

Check my previous post about Running your local LLM on MacOS using Docker and Ollama.

If you want to know more about Open Source and Open Source AI:

• Linux Foundation – AI & Data Foundation
• Open Source AI Foundation (OSAIF)
• Hugging Face
• Open Source Initiative (OSI)

Thats all for this post, I’m planning to keep exploring posts related to AI, so stay tunned.

First, why run an LLM locally?

• Privacy: Your data remains on your machine, reducing the risk of data leaks.
• Cost: Avoiding cloud costs associated with API calls.
• Speed: Local inference can be faster than making API call (small-scale).

Prerequisites

Everything I’m showing here was tested on MacOS 15.x with a M4 Pro cpu, but it should work on other versions as well.

• Brew : Ensure you have Homebrew installed. If not, you can install it by running the following command in your terminal:

  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  

  • access https://brew.sh for more information.

• Docker: Ensure you have Docker installed and running on your Mac. You can download it from Docker’s official site.

  • Docker-compose

Get started

First of all, by the time I’m writing this, Docker for MacOS does not support GPU acceleration, and because I want to leverage on the GPU capabilities of my M4 chip, I’ll be running Ollama server outside of the Docker container and use Docker only for OpenWebUI, which is a web-based interface for interacting with LLMs.

Install Ollama

What is Ollama? You can think about Ollama as a package manager for LLms, which allows you to run and manage LLMs locally. It provides a simple command-line interface to download, run, and interact with various LLMs.

• Check Ollama’s website for more information.

To install Ollama, you can use Homebrew. Open your terminal and run the following command:

brew install ollama

Once installed, you can verify the installation by running:

ollama --version

This should display the version of Ollama you have installed.

To verify if Ollama is running you can check the status of the service:

brew services info ollama

You should see that the service is running like the output below:

ollama (homebrew.mxcl.ollama)
Running: ✔
Loaded: ✔
Schedulable: ✘
User: ferbass
PID: 75692

if the service is not running you can start it with:

brew services start ollama

Ok, now that you have Ollama installed and running we can download our first model to test. For this example I’ll be using qwen3:4b which is a 4 billion parameter model that should run smoothly on M4 chips.

To download the model, run the following command:

ollama run qwen3:4b

This command will pull and run the Qwen3 model right after downloading it. Alternatively, you can use the ollama pull command to download the model without running it immediately.

After download the model and run it, you should see an input interface on your terminal to interact with the model. Go ahead and try a few prompts to see how it responds. For example, you can ask it:

❯ ollama run qwen3:4b
>>> What is the capital of France?
Thinking...
Okay, the user is asking for the capital of France. Let me start by recalling what I know. France is a country in Europe, and I remember that its capital is Paris. But wait, I should
make sure I'm not confusing it with another city. Let me think... Paris is definitely the capital. I think it's also the largest city in France. But maybe I should double-check.
Sometimes people might confuse other major cities like Lyon or Marseille, but those are not the capitals. The capital is Paris, right? Yes, that's correct. So the answer is Paris. I
should present that clearly.
...done thinking.

The capital of France is **Paris**.

>>>

Cool, now that we have Ollama running and a model downloaded, we can move on to the next step: setting up OpenWebUI.

Install OpenWebUI

OpenWebUI is a self-hosted, open-source chat interface for LLMs. It gives you a web-based experience similar to ChatGPT — but fully local, private, and customizable. It’s designed to work out-of-the-box with backends like Ollama, LM Studio, or OpenAI-compatible APIs, making it perfect for macOS setups running LLMs natively. I’ll not go into details about OpenWebUI in this post, but you can check their GitHub repository for more information.

To run OpenWebUI, we will use Docker. First, ensure you have Docker installed and running on your Mac.

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
    volumes:
      - ${HOME}/open-webui-data:/app/backend/data
    restart: unless-stopped

volumes:
  open-webui-data:

docker-compose up -d

This command will start the OpenWebUI service in detached mode.

If everything goes well, you should see be able to access http://localhost:3000 and interact with OpenWebAI via your web browser using the model you downloaded earlier.

what is next

Now that you have a local LLM running using Ollama and OpenWebUI, I encorage you to explore more models and settings and try to see which one works best for you. You can find more models on the Ollama.

So far on my tests using a MacBook M4 Pro with 48GB of RAM, I was able to run models size up to 8B parameters without any issue.

I encorage you explore different models, settings, and try to play around with Knowledge Base, Tools and Function which I will explore in future posts.

Thanks

That is all. I just wanted to share my feelings and how inspiring RubyKaigi is for me and many other Rubyists

One more thing: I would like to share a book by my friend Guilherme Orlandini Heurich, an Anthropologist who has studied the Ruby community for the past few years and has released the book called CODESPEAK.

Thank you

#rubykaigi #rubykaigi2025 #inspiration

First find the key you want to change the password

$ gpg --list-keys

I particularly like to use --list-keys with --keyid-format LONG parameter, to get the long key id, which is easier to work with.

$ gpg --list-secret-keys --keyid-format LONG
[keyboxd]
---------
sec   rsa4096/87C6D385122B1669 2017-12-04 [SC]
      7D30FFF3FC256153A59AEA698726DF85922B8669
uid                 [ultimate] Fernando Bass (no comments) <xyz@mail.com>
ssb   rsa4096/7A822B866BD5E7D1 2017-12-04 [E]

In this case, the key id is 87C6D385122B1669.

Now lets change the password

$ gpg --edit-key 87C6D385122B1669

This will open the gpg console, where you can change the password

gpg> passwd

If your key is protected, you will be asked to enter the current password, after that a prompt asking to type the new password and confirmation will be displayed.

If everything goes well, you should be redirect to the gpg console, where you can save the changes.

gpg> save

Thats it, after save your changes you can start using your GPG Key with the new password.

Thank you

Well, I used to blog with more frequency in the past (long time), but life being life, I always end up getting busy with something else and the blog ends up being left behind. But I’ll try to change that, I’ll try to post more often here, even if it’s just a small post like this one, I’ll try to post something at least once a week, let’s see how it goes.

Thats it, just want to share this with you guys, see you in the next post.

So here is how you can prevent a package from being upgraded with Homebrew.

First you need to know the version you want to keep, you can do this with:

brew list --versions <package>

The result of this command will show you the stable version for the package and the installed version in your environment.

If the current version is the one you want to keep, you can just pin it with:

brew pin <package>

In some cases you might want to keep a specific version, in this case you can install the version you want with:

brew install <package>@<version>

And then pin it with:

brew pin <package>@<version>

Now if when you run brew upgrade the package will not be upgradedm and if you want to unpin it, you can do it with:

brew unpin <package>

or

brew unpin <package>@<version>

If you don’t know or with to verify if you have any package pinned, you can do it with:

brew list --pinned

This command only list the installed packages you have pinned.

And that’s it, now you know how to prevent a package from being upgraded with Homebrew.

Thank you for reading.

There are many ways to do that, but for me I like to go to the command line and use the scutil command.

sudo scutil --set ComputerName "machine-name"
sudo scutil --set HostName "machine-name"
sudo scutil --set LocalHostName "machine-name"

after that you chan check the name with the following command:

scutil --get ComputerName

Note that I setting the ComputerName, HostName, and LocalHostName to the same value. This is not strictly necessary, but I like to keep things consistent.

This gives: ComputerName: Visible in Finder and AirDrop. HostName: Used by SSH and CLI tools as machine-name. LocalHostName: Resolves as machine-name.local via Bonjour/mDNS.

Thats all, be creative when choosing your machine name!

Thank you

Unless the Developer allows you to choose the mode you want to use, there are no settings on macOS that let you change it for specific Apps. Well, since there is no official solution from Apple to enable/disable DarkMode for specific Apps, there is a small trick we can do to enforce the mode we want to use for specific Apps. To be able to achieve this goal, we are going to use a terminal command on macOS called defaults.

defaults

The defaults command on macOS is powerful. It allows you to modify some hidden user settings on specific Apps or macOS. If you wish to know more about defaults check this guide macOS Defaults.

Identify the bundle id of the Application

The first step is to identify the bundle id of the application we want to enforce the mode. To do that, we need to run the following command in the Terminal.

osascript -e 'id of app "TextEdit"'

After identifying the app, we need to change the key NSRequiresAquaSystemAppearance to enforce the mode we want to use, Yes for LightMode and No for LightMode.

Enforce LightMode

defaults write com.apple.TextEdit NSRequiresAquaSystemAppearance -bool Yes

Enforce DarkMode

defaults write com.apple.TextEdit NSRequiresAquaSystemAppearance -bool No

Use system defaults

If you want to restore the system default for the App, you need to delete the NSRequiresAquaSystemAppearance key with the following command.

defaults delete com.apple.TextEdit NSRequiresAquaSystemAppearance

References

• macOS Defaults
• Edit property lists in Terminal on Mac

That’s all, and I hope this can be useful for someone else as well.

Thank you

This post is not a tutorial but an experience sharing about changing my dev environment. I strongly encourage you to check the official documents if you want to change your setup and face some issues.

Alacritty

I started searching for a new terminal emulator. I wanted something fast, reliable, and with a nice set of features since I spend a lot of time using the terminal during my day. During my search, one of my colleagues introduced me to Alacritty, and I thought it was cool. Alacritty is a GPU-Accelerated terminal emulator with a nice feature set, and since I was thinking about giving tmux another try, I decided to go with it.

I haven’t yet done much on Alacritty, but I was delighted with the default configuration, and with minimal changes, I could get in almost the way I wanted.

My basic configuration includes the NerdFonts, which I was already using with iTerm2, and a set of Alacritty themes that you can find in this repo, you can see what my .alacritty.yml` looks like below.

# ~/.alacritty.yml
# Font and style
font:
  normal:
    family: Hack Nerd Font
    style: Regular
  bold:
    family: Hack Nerd Font
    style: Regular
  italic:
    family: Hack Nerd Font
    style: Italic
  bold_italic:
    family: Hack Nerd Font
    style: Bold Italic
  size: 16
  offset:
    x: 0
    y: 0
  glyph_offset:
    x: 0
    y: 0

# Theme
import:
  - ~/.alacritty-colorscheme/themes/argonaut.yaml

I’m using a theme called argonaut, that’s what my Alacritty looks like at the moment of this post.

Fish

I often see people talking about Fish shell on Twitter, Reddit, etc. I was curious about Fish shell, but I never looked into them in detail, and now since I have decided to refresh my environment and try something new, and to be honest, I didn’t spend any time looking for another alternative.

Why fish? Fish is a fully-equipped command line shell (like bash or zsh) that is smart and user-friendly. Fish supports powerful features like syntax highlighting, autosuggestions, and tab completions that just work, with nothing to learn or configure.
If you want to make your command line more productive, more useful, and more fun, without learning a bunch of arcane syntax and configuration options, then fish might be just what you’re looking for! https://fishshell.com/docs/current/tutorial.html

I’m not going into details about how to install fish and set it as your default shell. Please check the official documentation tutorial to understand all those steps https://fishshell.com/docs/current/tutorial.html.

So far, I’m enjoying Fish shell. Features like Autosuggestions, Tab Completions, and Syntax Highlighting are handy. But of course, there is a learning curve to start using Fish. For example, create an alias or set an environment variable that uses a different syntax.

The more I use Fish more I discover about its features, and I’m very impressed by the number of features and integrations Fish has. I’m not going to share my fish.config file yet on this post, but I plan to share my entire config on my GitHub.

tmux

tmux is an open-source terminal multiplexer for Unix-like operating systems. It allows multiple terminal sessions to be accessed simultaneously in a single window. It is useful for running more than one command-line program at the same time.
Wikipedia https://en.wikipedia.org/wiki/Tmux

I tried tmux a long time ago; for some reason, my experience was slightly frustrating, but I decided to give tmux another try. Since I’m still getting used to tmux, I did change a few configurations to enable the mouse and clear command to be able to clean up the screen and scroll back to the top; maybe I will come up with more configurations in the future, but for now, the default key bidding works fine to me.

That’s what my .tmux.conf looks like now.

# .tmux.conf
# enable mouse integration for "tab" change etc
setw -g mouse on

# Enable terminal clear scrollback / Ctrl + l 
set -g default-terminal xterm-256color

Here is a tmux cheat sheet I found with some basic commands like create and navigate between windows, panes, sessions, etc.