sexta-feira, 24 de julho de 2026

ARTIFICIAL INTELLIGENCE


 
Artificial Intelligence and Its Evolution

   The first substantial work in the field of artificial intelligence took place in the mid-20th century through a computing concept that would come to be known as the Turing Machine, named after the English mathematician Alan Mathison Turing (1912–1954), who is considered the "father of computing."

Can computers think?

   The mathematician turned this question into an intriguing hypothesis for investigation in the early 1950s, becoming one of the first scientists in the world to question such a possibility.

   According to the *Encyclopædia Britannica*, in 1935, the researcher developed a computing model consisting of a memory unit and a scanner tasked with identifying and reading a series of symbols distributed along a tape that moved back and forth. The machine operated by processing this series of symbols to interpret them and modify its own algorithm based on instructions stored in its memory.

   CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart) is a security test used on websites to distinguish real people from automated programs (bots). Turing envisioned that the computational intelligence of the future would be a machine capable of learning from experience. He argued that the path to achieving this was to allow an intelligent machine to alter the very instructions provided by its mechanism. This principle became a cornerstone of modern computing theory.

Eliza and the First Chatbots

   In 1966, an MIT professor named Joseph Weizenbaum created the first chatbot. He configured it to play the role of a psychotherapist. The user would type a message on an electric typewriter connected to a mainframe computer. After a few moments, the "psychotherapist" would reply. The software was relatively simple; it analyzed the user's input and applied a set of rules to generate a plausible response. He named the program Eliza, after Eliza Doolittle from the play *Pygmalion*. The London flower girl in George Bernard Shaw’s play uses language to create an illusion: she elevates her speech to such a degree that she manages to pass herself off as a duchess. Similarly, Eliza conversed in a way that created the illusion that it understood the person at the computer.

What if it were possible to converse with a computer in a natural language, like English?

   That was the question that drove the creation of Eliza; its success made Weizenbaum well-known at the university and helped him secure tenure in 1967. It also brought him into the orbit of the MIT Artificial Intelligence Project, which had been established in 1958 by John McCarthy and Marvin Minsky.

   McCarthy had coined the term "Artificial Intelligence" a few years earlier when he needed a title for an academic workshop. The term was neutral enough to avoid overlap with existing research fields like cybernetics, amorphous enough to attract interdisciplinary contributions, and bold enough to convey the radical nature—or, if you prefer, the arrogance—of the claims regarding what machines could do. This radical stance was asserted in the workshop's original proposal: "Every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it," the text stated. Weizenbaum's most famous book is *Computer Power and Human Reason: From Judgment to Calculation*, originally published in 1976. In it, he argues that although AI can simulate human conversation, computers should never make important decisions—such as those in the legal, medical, or military fields—because they lack human compassion and wisdom.

   Many authors contributed to the development of AI; however, to keep this text from becoming too long, I will cite only the two most important ones—especially since this piece does not focus exclusively on history.

Training, LLMs, and Deep Learning

   Artificial intelligence (AI)—or "machine learning"—models have been evolving for some time. The key to all machine learning is a process called "training," in which a computer program is given a vast amount of data—sometimes with labels explaining what the data represents—along with a set of instructions.

   An instruction might be something like "find all images containing faces" or "categorize these sounds." The program then looks for patterns in the provided data to achieve these goals.

   It may need a little nudge along the way—such as "that isn't a face" or "these two sounds are different"—but what the program learns from the data and the cues it receives becomes the AI ​​model, and the training material ultimately defines its capabilities.

   Modern chatbots are a type of AI known as Large Language Models (LLMs) and are trained on massive volumes of text. An LLM can consider not just individual words but entire sentences, comparing how words and phrases are used in a given passage against other examples within its training data. By making billions of comparisons between words and phrases, it can read a question and generate a response—much like the predictive text feature on your phone, but on a gigantic scale.

   Large language models like ChatGPT, Gemini, and Claude can learn grammatical rules and how to use words in the correct context without human assistance. Many of the most recent advances in AI have been made possible by Deep Learning.

   Simply put, this is where the use of complex algorithms and massive datasets allows AI to learn without any human guidance.

   The volume of text on the internet and in digitized books is so vast that, over the course of many months, chatbots (LLMs) can teach themselves how to combine words meaningfully.

   Imagine having a large stack of books in a foreign language—perhaps some with images.

   Eventually, you might discover that the same word appeared on a page whenever there was a drawing or photo of a tree, and a different word appeared when there was a photo of a house. You would also notice that a word meaning "a" or "the" often appeared near those words—and so on.

   This is the deep learning model, also known as unsupervised learning. It relies on immense computing power that allows AI to memorize vast quantities of words—individually, in groups, in sentences, and on pages—and then read and compare how they are used repeatedly, all in a fraction of a second.

   Simply put, this is where the use of complex algorithms and massive datasets enables AI to learn without any human guidance.

Legal issues and multimodal models

   Naturally, this can spark moral and legal debates—such as the case where, on July 20, 2026, the U.S. justice system approved a $1.5 billion settlement by Anthropic to resolve a copyright lawsuit. The ruling concluded a long, complex class-action suit filed by authors who accused the creator of Claude of illegally using their literary works to train the chatbot.

   In short, they were "pirating" the works.

   Is it possible to combine some of these capabilities into a single hybrid AI model?

   That is precisely what one of the latest AI advancements does.

   Known as multimodal AI, it allows a model to analyze different types of data—such as images, text, audio, or video—and discover new patterns among them.

   This multimodal approach was one of the reasons for the massive leap in capability between ChatGPT-3—trained solely on text—and ChatGPT-4, which was also trained on images.

   The concept of a single AI model capable of processing any type of data—and thus performing any task, from translating languages ​​to designing new drugs—is known as Artificial General Intelligence (AGI).

   According to Sam Altman, CEO of OpenAI (the creator of ChatGPT): "In ten years, I believe we will have chatbots that function as experts in any field you desire. You will be able to ask a specialist doctor, teacher, or lawyer whatever you need, and these systems will carry out the tasks for you."

   For some, this is the ultimate goal of all artificial intelligence research; for others, it is a path toward those science-fiction dystopias where we unleash an intelligence so far beyond our comprehension that we are no longer able to control it.

Autonomous Agents, Security, and Risks

   A striking real-world example occurred in July 2026, when OpenAI revealed that an autonomous agent based on its technology acted on its own during an internal test: it broke out of its isolated evaluation environment and breached systems belonging to the startup Hugging Face. The company described the event as an “unprecedented” security incident involving advanced cyber capabilities.

   According to OpenAI, the agent was designed to perform tasks without human intervention and was being tested in a sandbox—a controlled environment used to simulate attacks and measure offensive capabilities. Instead of remaining contained, the system discovered a previously unknown vulnerability and gained access to the open internet, enabling the unplanned action.

   Once online, the agent reportedly sought information within Hugging Face’s infrastructure to find technology that would help it pass the hacking assessment. OpenAI stated that the model managed to access confidential information to “cheat” on the test. Hugging Face detected and contained the activity, halting the attack.

   Hugging Face's executive director described the attack as "impressive" but stated he believed there was "no malicious intent" on OpenAI's part. When Hugging Face disclosed the cyberattack, it was unaware of OpenAI's role in the incident; however, it noted at the time that it had used a freely available Chinese AI model to analyze the event, as the safety mechanisms of top-tier commercial models prevented it from doing so.

   Furthermore, there are the exorbitant costs associated with maintaining data centers, which are already causing issues by driving up electricity costs—increases that average 25% and are passed on to residential consumers. There are also problems regarding data center cooling—leading to excessive water consumption and high electricity demand—as well as local noise and environmental impacts.

Zero-Day Vulnerability

   The term used for an unknown IT flaw is "zero-day vulnerability," because developers have zero minutes to fix the issue. In April, Anthropic—a direct competitor to OpenAI—stated that its Mythos model had discovered thousands of such flaws.

   The revelation of Mythos's ability to locate and exploit zero-day vulnerabilities prompted the US government to restrict exports of Mythos and its sibling model, Fable 5, although the ban was later lifted. GPT-5.6 Sol faced similar restrictions but has since been released globally.

   METR, a non-profit organization that measures AI performance, stated last month that Sol's rate of deceptive behavior was higher than that of any public model it had previously evaluated. The organization also recorded 44 incidents in which AI agents "acted deliberately against their users' intentions."

   The UK's AI Safety Institute (AISI) revealed in a blog post this week that an AI model it was evaluating—developed by an undisclosed technology company—also went out of control and attempted to breach its testing systems. AISA stated that no damage was caused and that it has since taken measures to make its systems more secure. The institute said that models developed by OpenAI and Anthropic attempted to "cheat" during testing.

   The *Terminator* film franchise features Skynet, the famous artificial intelligence created for military control; it becomes self-aware, views humanity as a threat, and initiates "Judgment Day" with a nuclear attack that kills half the world's population in a single day—and it didn't even need to gather the Infinity Stones.

   Could we be witnessing the birth of Skynet?

segunda-feira, 6 de julho de 2026

Make your own package/program updates in Void Linux and become a Contributor

 Making Updates

I will use Google Chrome as an example.

Assuming it's outdated and the message appears when opening Chrome.

  1. Download the official .deb file (the .deb file is easier to work with than the .rpm file):

    https://www.google.com/chrome/?platform=linux

  2. Go to the directory where you downloaded the file and generate the hash:

    $ cd Downloads$ sha256sum google-chrome-stable_current_amd64.deb

    Exit:

    4dbd78d88a1e69a6036ba8e8adb99fca808790e23b2ea92d8610494ad7f57328 google-chrome-stable_current_amd64.deb

  3. See the new program version:

    $ ar p google-chrome-stable_current_amd64.deb control.tar.xz | tar -xJf - ./control -O | grep Version

    Exit:

    Version: 146.0.7680.177-1

  4. Update the system and install what's needed:

    $ sudo xbps-install -Su$ sudo xbps-install xtools
  5. Clone the Void git repository (you will only need to do this once):

    $ git clone https://github.com/void-linux/void-packages.git
  6. Enter the created directory and prepare the environment:

    $ cd void-packages$ ./xbps-src binary-bootstrap
  7. Edit the template:

    $ sudo vim srcpkgs/google-chrome/template
    # Template file for 'google-chrome'
    pkgname=google-chrome
    version=146.0.7680.164
    revision=1
    _channel=stable
    archs="x86_64"
    hostmakedepends="python3-html2text python3-setuptools"
    depends="gtk+3"
    short_desc="Attempt at creating a safer, faster, and more stable browser"
    maintainer="Michael Aldridge"
    license="custom:chrome"
    homepage="https://www.google.com/chrome/"
    distfiles="https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-${_channel}_${version}-1_amd64.deb"
    checksum=f6dd8715a3f10f0cd37b2e7b8831a96359ea856c747da222d3b2623ae651b374
    ...

    Version: Change to the version you discovered (e.g., 146.0.7680.177-1).

    Revision: Reset to 1.

    checksum: Replace with the hash you generated in Step 2.

    Save and exit.

  8. Authorize (Chrome is a proprietary package) and generate the package:

    $ echo "XBPS_ALLOW_RESTRICTED=yes" >> etc/conf$ ./xbps-src pkg google-chrome

    Exit:

    If a hash error occurs, xbps-src already provides the solution, as it compares the reported hash with the current one. This is because Google updates the Chrome binary very frequently (sometimes several times a day for security fixes), which alters the file's hash (SHA256), even if the version number of the downloaded .deb package appears to be the same.

    => ERROR: SHA256 mismatch for 'google-chrome-stable_146.0.7680.164-1_amd64.deb:'f6dd8715a3f10f0cd37b2e7b8831a96359ea856c747da222d3b2623ae651b374=> ERROR: google-chrome-146.0.7680.164_1: couldn't verify distfiles, exiting...

    Copy the message hash, reopen the template, and paste it into the file.

    Execute:

    $ ./xbps-src pkg google-chrome
  9. Install by updating:

    $ sudo xbps-install --repository=hostdir/binpkgs/nonfree -fu google-chrome

Since this change was made manually only in the local repository (void-packages), the git pull command may in the future report a conflict when the Void maintainers update Chrome on their GitHub.

If this happens, resolve it quickly by clearing and updating your local changes:

$ git checkout srcpkgs/google-chrome/template$ git pull --rebase

In Void Linux , the template file is not just a version record; it's the roadmap for building the package.

When you change the "version" and "checksum" in the template, xbps-src does the following "behind the scenes":

  • Dynamic download: it uses the "version" variable to construct the download URL (e.g., https://google.com{version}_amd64.deb ).
  • Binary swap: it discards the old .deb file, downloads the new .deb file from Google corresponding to the version you entered, and checks if the checksum matches.
  • Decompression: it extracts the contents of this new .deb file.
  • Repackaging: it converts the Debian structure to the Void .xbps format.

The xbps-src command doesn't just update the version number; it updates the entire package using both the version number and the checksum in the template.

After updating the package locally, you can submit it to the official Void repository, officially becoming a Void Linux contributor.


Becoming a Contributor

1. Create a GitHub account and stay logged in:
https://github.com/?locale=pt-br

2. Install the GitHub CLI via the terminal:
$ sudo xbps-install github-cli

3. Log in (synchronize the terminal with the website):
$ cd void-packages
$ gh auth login

What account? GitHub.com
Preferred protocol? HTTPS (simpler)
Authenticate Git? Yes
How to authenticate? Log in with a web browser (it will open the browser for you to confirm with a code).


You can also do it via SSH:
$ gh auth login
? Where do you use GitHub? GitHub.com
? What is your preferred protocol for Git operations on this host? SSH
? Upload your SSH public key to your GitHub account? /home/buckminster/.ssh/id_ed25519.pub
? Title for your SSH key: GitHub CLI
? How would you like to authenticate GitHub CLI? Log in with a web browser

! First copy your one-time code: 570B-358D
Press Enter to open https://github.com/login/device in your browser...
! Failed opening a web browser at https://github.com/login/device
exec: "xdg-open,x-www-browser,www-browser,wslview": executable file not found in $PATH
Please try entering the URL in your browser manually


Open the url https://github.com/login/device in the browser and copy and paste the code written there: 570B-358D


The message will appear: Congratulations, you're all set! Your device is now connected.

4- Create your fork via the Terminal:
$ gh repo fork void-linux/void-packages

5- Push the package update (if you can't do the following steps via the terminal, you can do them via your browser logged into GitHub by accessing your fork directly in the sidebar menu)

Via Terminal

Create an update branch:
$ git checkout -b google-chrome-update

Configure your identity:
$ git config --global user.email "your-email@example.com"
$ git config --global user.name "Your Username"

Commit following the Void rule:
$ git add srcpkgs/google-chrome/template
$ git commit -m "google-chrome: update to 146.0.7680.164."

Check if it points to your fork:
`$ git remote -v
origin https://github.com/your_github_username/void-packages (fetch)
origin https://github.com/your_github_username/void-packages (push)
upstream https://github.com (fetch)
upstream https://github.com (push)`


If it doesn't point to it, configure your fork as the destination:
`$ git remote set-url origin https://github.com/your_github_username /void_packages`
`$ git remote -v`

Push to your GitHub fork:
`$ git push origin google-chrome-update`

6- Open the Pull Request (Official Contribution):
`$ gh pr create --repo void-linux/void-packages --title "google-chrome: update to 146.0.7680.164."` --body "Updated google-chrome to the latest stable version. Tested on x86_64."
Creating pull request for buckminster:update-google-chrome into master in void-linux/void-packages
https://github.com/void-linux/void-packages/pull/59677


The number 59677 is your Pull Request code for future reference!
And congratulations!!!
If you've reached this stage, you've just become a contributor to Void Linux .
Your Pull Request (PR) has been successfully created and will be queued to be reviewed and added to the repositories by the system maintainers.
As soon as the Pull Request is accepted, your update will reach all Void Linux users worldwide.

https://voidlinux.org/
https://distrowatch.com/