DEV Community: Rudi Farkas

bilingual_pdf, an app by @rudifa

Rudi Farkas — Sat, 14 Feb 2026 19:06:08 +0000

If you are learning another (human) language, you might wish to create bilingual documents where a text in a language you know and its translation into the language you are learning are displayed in two columns, side by side.

bilingual_pdf is a CLI application for Mac, Linux and Windows that will create a two-column bilingual PDF document, from your input Markdown document.

As an example, here is the bilingual_pdf project's README.md used as a source to bilingual_pdf, and the resulting English + Spanish version README.en.es.pdf.

By default, bilingual_pdf translates your input automatically using Google Translate. You can also get the resulting translation as a Markdown document, which you can edit and use instead of the automatic translation.

Enjoy!

A live catalog of Logseq plugins, by @rudifa

Rudi Farkas — Fri, 29 Aug 2025 13:24:25 +0000

Logseq is a personal knowledge management and note-taking application.

I use it to keep structured notes (it is an an outliner, with crosslinking and a tree view of note pages).

It is markdown based and supports live web links.

It supports contributed plugins for various extended features.

Recently I contributed a plugin URL to Markdown: when you type or paste into your Logseq notes, the plugin looks up on the web the page title and the icon, and adds them automatically to the page.

There were already 2 or 3 similar plugins, but I wanted to have a nicer one (inside: code style, outside: behavior).

The contributed plugins are registered in the Logseq Marketplace github repo, under packages.

Now, since a few days, the Marketplace sports a live plugins catalog, also contributed by myself.

Try it out!

How do Transformers work in LLMs?

Rudi Farkas — Tue, 29 Oct 2024 08:42:13 +0000

The other morning I had a discussion with ChatGPT on how the Transfomers and other LLM mechanisms work when they generate those token sequences that we perceive as answers to our questions.

Here it goes:

Me:
How do Transformers work in LLMs?

ChatGPT:

Alright, let's dive into Transformers in Large Language Models (LLMs) in a way that makes both the concepts and the math as accessible as possible.

Think of a Transformer as a mechanism to handle language by identifying the relationships and importance of words within a sentence, a document, or even across multiple documents. Imagine you’re reading a mystery novel: each piece of information is important, but some clues are more relevant than others depending on the context. Transformers are like detectives—they figure out what words matter most to predict the next word, complete a sentence, or generate a logical response by examining the “clues” in the surrounding text.
Transformers do this in three main steps: Tokenization , Self-Attention , and Feedforward Networks .

Step 1: Tokenization – Breaking Language into Pieces

Imagine if I handed you a huge jigsaw puzzle and asked you to explain what’s on it, piece by piece. Language models can’t work with entire sentences or paragraphs at once, so they break them down into “tokens,” or individual parts of words or phrases, to make it manageable.

Tokens are essentially chunks of language. Each token might be a whole word, part of a word, or even punctuation, depending on the tokenizer’s rules.
Tokens then get converted into vectors , which are lists of numbers that represent the token's meaning. These vectors capture different qualities, like context or parts of speech, in a numerical form the model can process.

So, before diving into the main architecture of a Transformer, it helps to think of this step as giving each word or phrase a “badge” that represents it in a unique way, while also carrying meaning and context. Each badge (vector) essentially says, “I am the token ‘dog,’ and here’s what I mean.”

Step 2: Self-Attention – Focusing on Key Clues

Now, let’s get into the main detective work of the Transformer: Self-Attention .
Imagine each word in a sentence has a spotlight on it, but the brightness of each spotlight changes depending on the importance of the word relative to other words. This “spotlight brightness” represents the self-attention score for each word. Self-attention allows the model to ask questions like, “How important is this word when I think about the other words around it?”

Here’s how it works:

Query, Key, and Value Vectors : Each token has three different vectors associated with it—Query, Key, and Value. Think of:
- The Query as a question a token is asking about its relevance.

The Key as the answer that other tokens offer to that question.
The Value as the actual information the token carries if it turns out to be relevant.

Dot Product for Attention : To decide which words are important, the model computes a mathematical similarity (called a dot product) between the Query of each token and the Key of every other token. The higher the similarity, the more relevant that token is.
Softmax to Normalize : After the dot products, the model uses a function called softmax to turn these values into probabilities. This tells the model exactly how much attention each word should pay to every other word. So, if a particular word is crucial (like a subject noun in a sentence), it gets a high attention score; less relevant words get lower scores.
Weighted Sum for Contextual Meaning : Finally, each token’s attention scores are multiplied with the Value vectors of all tokens. This gives a weighted sum that combines the information of relevant words, crafting a context-aware representation for each token.

So, self-attention works like a detective combing through clues, paying more attention to some pieces than others based on relevance. This ability to weigh the importance of words based on context makes Transformers exceptionally powerful for language tasks.

Step 3: Feedforward Networks – Refining the Message

After self-attention, the tokens pass through a feedforward neural network . Think of this as a way to further “polish” the insights gathered from self-attention.
Each token’s context-aware representation goes through a set of transformations to refine and highlight key features. This is done through a series of linear transformations and non-linear activations, which lets the network amplify certain characteristics while downplaying others. It’s similar to editing a draft to improve clarity and emphasis on the most important ideas.

Layers and Stacking – Building Up Complexity

A Transformer isn’t just a single self-attention mechanism and feedforward network; it’s multiple of these units stacked on top of each other. Each “layer” builds on the previous one, adding more nuanced context and understanding. Lower layers capture simpler relationships (like nearby words in a phrase), while higher layers capture complex, long-range dependencies (like distant words in a paragraph that affect each other).

Putting It All Together – How Transformers Make Predictions

Once the tokens pass through multiple layers of self-attention and feedforward networks, they’re ready for the final step: prediction.

Decoder Output : In a model that generates text (like GPT), the Transformer uses the processed tokens to predict the next token, based on everything it has “learned” from the context. The tokens with the highest likelihood are chosen as the model’s output, like solving for the “next clue” in a mystery.

Recap

Tokenization breaks language down into manageable pieces.
Self-Attention lets each word focus on the most relevant other words.
Feedforward Networks polish the representation for a clear understanding.
Stacked Layers build up complexity by learning deeper patterns and dependencies.
Decoder produces predictions for the next token or completion of the input text.

By combining these steps, Transformers can handle language remarkably well, making them the foundation for LLMs like GPT, which perform complex language tasks such as translation, summarization, and conversational AI.

To make sure we’re on track, let me know how familiar you are with the concepts of vectors, dot products, and neural networks. These are the building blocks of Transformers, so we can clarify those as needed before diving deeper!

Me:
Does what you just described represent the processing of a user question an how does it relate to the process ot training the model

ChatGPT:

Great question! Let’s break it down by distinguishing how a Transformer processes a user question (inference or “runtime”) and how the model is trained to handle questions and other language tasks.
Think of it this way:

During runtime , the Transformer is like a chef who knows the recipe, quickly putting ingredients together based on their training to whip up the right dish.
During training , the Transformer is like an apprentice, practicing countless recipes, making mistakes, and gradually learning which ingredients work best together.

Processing a User Question (Inference/Runtime)

When a user asks a question, the trained Transformer uses the method I described to provide a response. Here’s a summary of that process:

Tokenization : The user’s question is broken down into tokens (e.g., words, sub-words).
Embedding : Each token is transformed into a vector (a list of numbers representing the token’s meaning in context).
Self-Attention : The model calculates which words are important to focus on, given the specific question context. This is the step where the Transformer figures out “What’s the critical information here?” by analyzing each word's relationships to the others.
Feedforward Networks and Stacked Layers : The model refines the understanding of the question through multiple layers, gradually building a context-aware representation.
Output : Finally, using all the context gathered, the model predicts the best next word or sequence of words for the answer, one token at a time, until it completes the response.

This entire process is what happens when you interact with the model—it takes a split second, using the model's pre-existing knowledge.

How Training the Model Works

During training, the model learns how to handle a wide range of language tasks, including answering questions. This is where it builds up the knowledge and associations it uses during runtime.
Here’s how the training process is different from inference:

Data Preparation : The model is exposed to a massive dataset with millions or even billions of examples (e.g., books, websites, articles). This is the "recipe book" from which the model learns. Training data might include pairs of questions and answers, sentences to complete, and more.
Tokenization and Embedding (Same as Runtime) : Just like in runtime, the data is tokenized, and each token is converted to an embedding (vector representation).
Self-Attention, Feedforward Networks, and Layers (Same as Runtime) : The self-attention and feedforward layers operate as they would in runtime, except the focus here is on tweaking the model’s internal parameters based on what it observes.
Loss Calculation : Here’s where training diverges significantly from runtime:
- After making predictions about the next token (or answer in the case of questions), the model’s output is compared with the actual “ground truth” (i.e., the real answer or next token from the training data).

The difference between the model’s output and the actual answer is measured using a loss function , which tells the model “how wrong” it was.

Backpropagation and Parameter Updates : Based on the loss:
- The model adjusts its internal parameters (weights and biases) to reduce errors in future predictions. This adjustment is done through a process called backpropagation (where errors are pushed back through the network) and gradient descent (a method to tweak parameters to minimize the loss).
Repetition : This cycle (forward pass, loss calculation, backpropagation) is repeated over millions of examples and many iterations (epochs), gradually improving the model’s ability to predict text accurately and contextually.

Why Training is Different and Essential

Training is essentially the model’s learning phase, where it builds up knowledge, understands language patterns, and learns context-sensitive relationships. This knowledge is stored in the model’s parameters, which are later used to interpret and respond to real-time queries in runtime.

In simpler terms:

Training : The model learns how to answer questions, by adjusting itself based on millions of examples.
Runtime : The model uses what it learned to answer specific questions quickly and accurately.

To check understanding:

How comfortable are you with concepts like backpropagation, loss functions, and gradient descent?
Do you feel confident with the difference between training (learning) and runtime (responding)?

Let’s dive into any areas where you’d like more depth!

Me:
Is it true that much of that processing is done in parallel

ChatGPT:

Yes, absolutely! One of the key strengths of Transformers—and why they’re so well-suited for large-scale language models—is that they can process large amounts of data in parallel , especially during the self-attention step. Let’s unpack how this parallel processing works and why it’s so advantageous.

Parallel Processing in Transformers

Most neural network models that came before Transformers (such as RNNs) processed language sequentially —one word at a time. This is like reading a sentence word by word in order; each word’s meaning depends on the words before it. Sequential processing is slow and computationally costly, especially as the length of input increases.
However, Transformers broke away from this limitation. Here’s how they enable parallel processing:

Self-Attention Mechanism : In a Transformer, each word (or token) in a sentence doesn’t have to wait for the previous one to be processed. Instead:
- The self-attention mechanism allows each word to simultaneously calculate its relationship to all other words in the sentence. This means all tokens can be analyzed for context at the same time, independent of their position in the sequence.

By calculating relationships in parallel, the Transformer can process entire sequences in one go, making it extremely fast and efficient for handling long texts.

Matrix Multiplications : The self-attention mechanism relies heavily on matrix multiplications (e.g., dot products between Query and Key vectors). Modern hardware, such as GPUs and TPUs, is optimized for matrix operations, which makes it easy to compute these in parallel across all tokens in a layer.
Stacked Layers in Parallel : Transformers have multiple layers stacked on top of each other. Each layer can process tokens in parallel, so all tokens go through each layer simultaneously. This adds depth and complexity to the model’s understanding without slowing it down with sequential dependencies.

Why Parallelism is Powerful in Transformers

Parallel processing in Transformers brings several key advantages:

Speed : By processing tokens in parallel, Transformers can handle vast amounts of text quickly. This is essential for training large language models like GPT, which process billions of tokens in training datasets.
Scalability : Because Transformers work in parallel, we can scale them up more easily. We can add more tokens (longer sequences) or more layers (deeper understanding) without a linear increase in time. The model can handle complex dependencies across long texts without a significant time penalty.
Hardware Efficiency : Since GPUs and TPUs excel at handling parallel matrix operations, Transformers can take full advantage of modern hardware, maximizing efficiency and making it feasible to train on large datasets.

Parallelism During Training vs. Inference

During training , parallelism is even more crucial because the model is often trained on huge batches of sentences at once. Parallel processing across both tokens in a sequence and examples in a batch allows for rapid adjustments to model parameters over millions of examples.During inference (runtime) , parallelism is also used, but there are limits when generating text:

When generating text step-by-step (like predicting the next word in a sentence), the model does need to work sequentially to some degree, because each token generated depends on the ones that came before.
However, each prediction involves parallel self-attention processing over the entire sequence generated so far, making it much faster than previous sequential models.

So yes, parallel processing is a core design feature of Transformers, enabling them to handle and scale with large amounts of data efficiently, both during training and inference. Let me know if you’d like to explore any of these aspects—like self-attention or matrix operations—in greater detail!

Me:
GPUs are graphic pus, used here for a different purpose; what are TPUs?

ChatGPT:

Great observation! GPUs and TPUs are both specialized hardware designed to handle large-scale data computations efficiently, but they have some key differences in design and purpose.

What is a TPU?

A TPU , or Tensor Processing Unit , is a type of hardware accelerator created by Google specifically for machine learning and deep learning tasks. Unlike GPUs, which were originally designed for rendering graphics, TPUs are purpose-built from the ground up to handle the types of mathematical operations commonly used in machine learning.
Let’s break down what makes TPUs unique and why they’re beneficial for tasks like training Transformers and large language models.

How TPUs Differ from GPUs

Purpose-Built for Machine Learning :
- TPUs are optimized specifically for operations that are very common in machine learning, such as matrix multiplications and tensor operations (thus the name "Tensor" Processing Unit).

These operations are foundational to deep learning because they’re heavily used in neural network computations, such as calculating the relationships in self-attention layers of Transformers.

Focus on High Throughput Rather than Graphics Rendering :
- Unlike GPUs, which are designed for high-speed graphics rendering (like processing pixels for games or 3D rendering), TPUs focus on throughput (handling large amounts of data quickly) rather than latency (quick response times).

In other words, TPUs are built to process massive datasets rather than render images on a screen. This makes them ideal for large-scale machine learning tasks like training deep neural networks.

Simplified Architecture for Efficiency :
- TPUs use a more streamlined and specialized architecture compared to GPUs. For instance, they have fewer specialized cores for graphic-specific tasks and more optimized pathways for handling the repetitive, large-scale matrix multiplications used in neural networks.

This focus allows TPUs to be highly efficient for training and inference, especially for the massive datasets used in training models like GPT.

Power and Cost Efficiency :
- TPUs are often more power-efficient for specific machine learning tasks, meaning they can complete training tasks using less electricity than GPUs would for the same workload.

Google designed TPUs with cloud-scale operations in mind, making them available through their cloud services, which can lower costs and increase accessibility for large-scale AI training jobs.

Multiple Versions (Generations of TPUs) :
- Google has released several versions of TPUs, each improving on the last with more cores, faster processing, and better efficiency.

The latest TPUs, such as TPU v4 , are even more powerful and are specifically designed to handle the requirements of large-scale AI models, allowing for even faster training on very large datasets.

Where TPUs Excel in Machine Learning

TPUs shine particularly in training large language models and other deep learning applications that involve:

High-dimensional data (like images, text, and video).
Massive parallel processing , as with the multi-layer self-attention operations in Transformers.
Batch processing of enormous datasets, often working on hundreds or thousands of data samples at once, making them suitable for tasks like image recognition, natural language processing, and large-scale recommendation systems.

TPU vs. GPU Summary

To sum up:

GPUs are versatile, originally designed for graphics but now widely adapted for deep learning.
TPUs are custom-made for machine learning tasks, particularly deep learning, focusing on maximizing throughput for large-scale matrix and tensor operations efficiently.

Let me know if you'd like to dive deeper into the specific types of operations TPUs accelerate or other hardware optimizations used for deep learning!

Me:
The data structures and quantities in this - you mentioned vectors, Q K V -

ChatGPT:

Absolutely, let's take a closer look at the data structures and quantities involved in Transformers, especially vectors and the Query (Q), Key (K), and Value (V) components. We’ll break down what each of these terms means in practice, and how they work together to capture relationships between words in a sentence or larger text.

Vectors in Transformers

In Transformers, vectors are the main way information about words is stored and processed. A vector is simply a list of numbers, like $$[0.2, -0.1, 0.8, \dots]$$, that represents a word’s meaning in the context of the model.
Here’s a deeper dive:

What a Vector Represents :
- Think of each word as having a unique “address” in a multi-dimensional space, and this address is represented by a vector.

For instance, a vector for the word "apple" might carry features like its relation to food, roundness, or fruit. The vector $$[0.8, -0.3, 0.5]$$ might mean "apple" is close to "fruit" and "food" in meaning, while being distant from "technology" or "emotion."

Vector Dimensions :
- Each vector has a dimensionality (like the number of elements in the list), which is often a high number (e.g., 512, 1024) in large language models. Each dimension carries a different feature or aspect of meaning.

Higher dimensions allow the model to capture more nuances, but they also increase computational cost.

Query, Key, and Value (Q, K, V) Vectors

In the self-attention mechanism of a Transformer, each word has three special vectors associated with it: Query (Q) , Key (K) , and Value (V) . Let’s break down each and understand why they’re necessary.

Purpose of Q, K, and V :
- The model’s goal is to determine which words (tokens) in a sentence are most relevant to each other. To do this, it uses the Q, K, and V vectors for each word.

Here’s a quick analogy: if each word in a sentence were a person at a meeting, the Query vector is like the question that person asks, the Key vector is the response that each other person gives, and the Value vector is the actual information that the person holds.

Creating Q, K, and V Vectors :
- When processing a sentence, the model generates these vectors by multiplying each token’s base vector (embedding) with separate weight matrices specific to Q, K, and V. These weight matrices are learned during training, so the model becomes better at extracting meaningful Q, K, and V vectors over time.
How Q, K, and V Work in Self-Attention :
- Dot Product of Q and K : For each word, the model calculates the dot product (similarity) between the Query of the current word and the Keys of all other words in the sentence. This tells the model how relevant each word is in relation to the current word.

Softmax : The model then uses a softmax function to convert these similarity scores into probabilities (attention weights) that sum up to 1. This assigns a relative importance to each word for the given context.
Weighted Sum of Values : Finally, each word’s Value vector is multiplied by its attention weight, and the weighted values are summed up. This produces a new vector for the word that now contains contextually relevant information from the entire sentence.

So, the Q, K, and V vectors enable the model to “attend” to different words based on the specific relationships it needs to understand. For example, in the sentence, “The cat chased the mouse,” the model learns that "cat" and "mouse" have a high attention relationship, as they are linked through the action "chased."

Example Walkthrough: Self-Attention with Q, K, and V

Let’s walk through a concrete example of self-attention with Q, K, and V in a simple sentence.
Suppose we have the sentence: “The quick brown fox jumps over the lazy dog.”

Tokenization : Each word is broken down into tokens.
Embedding : Each word is represented as a vector (e.g., a 512-dimensional vector).
Generating Q, K, V Vectors :
- For each word, the model generates a Q, K, and V vector by multiplying the embedding with specific weight matrices.
Calculating Attention Scores :
- For the word “fox,” the model computes the dot product of its Query vector with the Key vector of each other word (e.g., “quick,” “jumps,” “dog”). This gives us a list of similarity scores indicating how much “fox” should pay attention to each word.
Softmax on Scores :
- These scores are normalized with a softmax function to get attention weights, say $$[0.1, 0.05, 0.4, 0.1, 0.35]$$.
Weighted Sum of Values :
- Each Value vector is multiplied by its respective attention weight, and these are summed up to create a new representation for “fox” that now captures its relationship to other words, particularly “jumps” and “dog.”

Quantities Involved in Transformers

Number of Tokens :
- Each sentence or batch of sentences is broken into a fixed number of tokens (like 512 or 1024). This is the basic unit for Q, K, and V calculations.
Dimensionality of Embeddings :
- Each token is represented by a vector with a high dimensionality (like 512 or 1024), which defines how much information each word’s vector can hold.
Attention Heads :
- Transformers use multiple attention heads (e.g., 8, 12, or 16), meaning that for each word, the self-attention mechanism is performed multiple times in parallel with slightly different learned weights.

Each head captures different types of relationships (e.g., one might focus on grammatical roles while another focuses on semantic similarity).

Layer Stacking :
- Transformers have many layers (often 12 or more), each containing its own self-attention and feedforward operations. Higher layers capture more abstract relationships.

In summary:

Vectors store information about each word.
Q, K, and V vectors enable each word to determine its relevance to every other word.
The quantities like number of tokens, embedding dimensionality, attention heads, and layers are set to optimize how much and what kind of information the model can handle, giving it the power to process complex language.

Let me know if you’d like to dive deeper into any of these aspects, like how attention heads work together or why dimensionality matters in embeddings!

Me:
zooming out, one might think that the process of handling the user input is somehow about finding the most probable first word of the continuation and then the next etc, all the time using the input and the output-so-far as context

ChatGPT:

You're spot-on! At a high level, a Transformer-based language model like GPT handles user input by essentially predicting the most probable next word (or token) one at a time, using both the original input and the output-so-far as context. This is central to how language models generate coherent, contextually relevant, and grammatically correct responses. Let’s break down how this process works step-by-step.

Step-by-Step: Generating Text Word by Word

Here’s a simplified view of how the model builds its output one word (or token) at a time:

Initial Context from User Input :
- When a user inputs a question or sentence, it’s first tokenized into individual tokens (words or parts of words). For example, “What is the weather today?” might become a series of tokens: [What, is, the, weather, today, ?].

Each token is then converted into a vector (embedding) that the model can work with.

Model Processes Input and Self-Attention :
- The model then uses self-attention on these tokens to analyze relationships between them, capturing the structure and meaning of the input. This lets it "understand" the user’s question by forming a rich, context-aware representation of each word.
Generating the First Token of the Output :
- Using the user input as context, the model calculates which token would most likely come next if this input were the beginning of a longer sentence.

It does this by evaluating all possible tokens in its vocabulary, assigning each a probability based on how well it fits in the context of the input.
The model then selects the highest-probability token as the first word of its response. This could be something like “It” in response to a question like, “What is the weather today?”

Including the Output-So-Far as New Context :
- The model now treats both the original input and the newly generated token (“It”) as context for predicting the next word.

This combined context (original input + generated word) allows the model to make a more informed prediction for the following word.
The model again calculates probabilities for all tokens, choosing the next most probable token, say “is,” resulting in the phrase: “It is.”

Iterative Prediction Loop :
- This process repeats, with the model continuously updating its context by including each newly generated word.

At each step, it considers the entire input along with everything generated so far. For instance, after “It is sunny and,” the model may predict “warm” as the next word.
The process continues until the model generates a special stop token (indicating the end of a response) or reaches a predefined token limit.

Probability and Contextual Flow

This token-by-token generation relies heavily on probability :

For each word position, the model calculates a probability distribution over all words in its vocabulary, selecting the word with the highest probability.
This probability distribution is informed by the self-attention mechanism, which weights the relevance of each prior word, allowing the model to use long-range dependencies flexibly.

Because each token depends on all prior tokens, the model can stay "on-topic" and maintain logical consistency across a sentence, paragraph, or even longer text. This is especially important for making responses that align well with the initial question or prompt.

Example Walkthrough

Let’s say the user input is: “Explain how photosynthesis works.”

First Token Prediction :
- The model might predict that the most probable first word in its response is “Photosynthesis.”

It chooses this because it fits well as a continuation of the input, making it clear that the model’s response is starting with the topic mentioned by the user.

Subsequent Tokens :
- For the next position, it may predict “is” (based on probabilities), leading to “Photosynthesis is.”

This continues with words like “the process by which,” producing the sequence: “Photosynthesis is the process by which…”

Building Meaning with Context :
- At each step, the entire input question and every generated token so far (“Photosynthesis is the process by which…”) provide context, helping the model predict relevant, contextually appropriate words.

This sequence continues, with the model refining each word prediction using both the original input and the evolving response.

Why This Works Well for Language

This approach of predicting one word at a time, using all prior context, is extremely effective because:

Context-Awareness : The model keeps the user input in mind at each step, making it less likely to drift off-topic.
Coherence and Flow : By incrementally building on each prior word, the response flows naturally and maintains logical consistency.
Adaptability : The model can adjust the “tone” or specificity of its response based on the initial prompt and the ongoing response, making it versatile across different types of queries.

This method is one of the reasons Transformer models are so powerful in generating natural, relevant responses. Each word is chosen carefully, not just as a standalone prediction but as part of an evolving response that respects both the input and the output-so-far.

Let me know if you’d like to dive deeper into any part of this process, such as how probabilities are calculated, or why the model doesn’t generate everything at once!

Me:
x

ChatGPT:

It looks like you entered "x" — did you have a specific follow-up question or concept you’d like to explore further? Whether it's about the prediction process, the math behind probabilities, or how context is maintained across multiple sentences, I'm here to help with the details!

Me:
if I enter x as input in a fresh conversation (which I will do, perhaps many times), what will happen?

ChatGPT:

If you enter "x" as the sole input in a fresh conversation, a Transformer-based language model will respond by generating the next word based on what it has "learned" about single-character inputs like "x." Here’s how it would process and respond:

Tokenization of Input :
- The model will first break down the input, treating "x" as a single token. In some language models, "x" is part of the vocabulary, so it's directly processed. In other cases, it might be converted into a subword or character token.
Context Analysis :
- Since "x" alone doesn’t provide much context, the model has limited information to generate a context-aware response. However, it has been trained on vast amounts of text, so it may associate "x" with various common uses, such as in algebra ("x as a variable") or in informal language (where "x" might stand for something unknown, like a placeholder).
Generating a Response :
- Based on probability, the model might respond with something general about "x," like mentioning its role as a mathematical variable, an unknown factor, or simply prompting you for more context. For example, it might say:
- "Could you provide more context for 'x'?"

- "Are you referring to 'x' as a mathematical variable?"

- "In what context are you using 'x'?"

Repeated "x" Inputs :
- If "x" is entered repeatedly, the model will likely recognize a pattern and try to interpret it as needing clarification. It may adapt its responses to prompt for additional context or try to provide explanations based on the limited context available.

So, essentially, the model will do its best to interpret "x" based on the associations and probabilities learned during training, but without more context, it can only guess at your intended meaning.

Me:
it happened to me a couple of times that I sent off an incomplete sentence maybe when my finger touched the send button inadvertently; results were surprisingly refreshing due to the ambiguity of the unfinished phrase

ChatGPT:

That’s a really interesting observation! Unfinished or ambiguous inputs often create a kind of “blank canvas” effect for a language model, which can lead to surprisingly creative or open-ended responses. Here’s why that happens:

Handling Ambiguity and Limited Context
When a model encounters an incomplete sentence, it faces a high level of ambiguity because it doesn’t have clear instructions on where the sentence is going. In response, it taps into a broader range of possible continuations. Since it’s trained on vast datasets with many possible interpretations, it may suggest ideas or interpretations you didn’t expect.

This ambiguity also encourages the model to “hedge its bets,” which often results in a broader, more exploratory answer. It’s as if it’s saying, “This could mean many things, so I’ll cover as much ground as possible.”
Inspiration from Training Data
Models are trained on diverse contexts and genres—everything from questions and answers to narratives, conversations, and formal essays. When a sentence is incomplete, it prompts the model to draw on a wide pool of associations and patterns, which can sometimes lead to a refreshingly novel or creative response. This lack of a specific direction lets it mix interpretations freely.
Encouraging Generative Flexibility
Without a defined endpoint, the model’s next-word prediction mechanism kicks into high gear, scanning for common yet versatile continuations of unfinished thoughts. For example, if you send “I was thinking about…” it might respond with almost anything, from “...taking up painting” to “...the nature of consciousness.” This variability adds to the refreshing nature of the response.
Sparking Unintended Directions and Insights
By providing the model with an incomplete sentence, you’re effectively letting it co-author your thought. Sometimes, it responds with interpretations that offer new ideas, complete thoughts in unexpected ways, or even challenge assumptions. This co-creative process can lead to insights or directions you hadn’t considered, like brainstorming with someone who fills in your gaps in interesting ways.

Examples of How It Might Respond to Incomplete Inputs

“I’ve been wondering if…” : It might respond with ideas about philosophy, science, or personal life decisions, because it’s reading into the phrase as something open-ended.
“Thinking about going to…” : Here, the model could respond with travel locations, educational institutions, or even abstract concepts like “going to a new phase in life.”
“When I realized…” : The model could explore various endings, from realizations about relationships to epiphanies about life choices or scientific ideas.

In a way, incomplete inputs encourage a model to be more versatile and exploratory. If you’re ever looking for a bit of spontaneous creativity, giving an AI an unfinished sentence or ambiguous phrase can be a fun and thought-provoking experiment!

Me:
it looks like the more detailed and specific my input is, the more will the continuation reflect my own knowledge, biases, preferences; shorter and ambiguous input might lead to surprising results, like meeting strangers in real life

ChatGPT:

Exactly, that's a fantastic way to think about it! The specificity and detail of your input essentially act like a filter that shapes the model's responses to reflect your own knowledge, style, and expectations. Meanwhile, short or ambiguous inputs open the door to randomness and surprise, much like encountering a stranger who brings new perspectives and interpretations you might not anticipate.

Here's how that plays out in a few interesting ways:

Detailed Inputs as Reflective Mirrors
When you give a very detailed or specific prompt, the model has a strong directional signal and will respond in alignment with the ideas, tone, or knowledge implied in your prompt. This can make it feel almost as if you’re seeing a reflection of your own thinking.

For example, if you ask, “Tell me about the cognitive processes involved in decision-making in game theory,” the model will respond within the academic framework of psychology and decision theory, closely matching your established knowledge on the topic.
Ambiguous Inputs as Invitations to Diversity
Ambiguous or open-ended prompts allow the model to take creative or less conventional paths, which often introduce novel or unexpected perspectives. This is why shorter inputs can lead to surprising or refreshing responses, much like meeting someone with a different background or way of thinking.
An open prompt like, “What’s the deal with change?” could lead to responses about anything from personal growth to climate change, or even philosophical musings on the nature of impermanence. You’re essentially giving the model free rein to interpret your input, which often leads to thought-provoking or serendipitous directions.
Serendipity and Divergence in Short Prompts
Like meeting strangers, short prompts encourage serendipity and novelty. The model might bring in ideas or associations from areas you didn’t expect, which can be enriching. For example, an input like “Space exploration…” could lead the model to discuss not just technology or science, but the psychology of astronauts, the sociology of space policy, or philosophical musings on human curiosity.
This serendipity effect often feels refreshing because the model brings in information that’s orthogonal to your immediate thoughts. It’s like having a conversation partner who doesn’t know what you’re expecting and therefore can suggest something entirely new.
Implicit Collaboration in Meaning-Making
When your input is less specific, the model has room to “collaborate” by filling in the blanks with interpretations that can surprise or challenge your own. This can sometimes feel like a “meeting of minds,” as the AI picks up on subtleties in your phrasing and explores them in directions that might diverge from your initial intention.
For instance, an input like “I’m feeling uncertain…” could elicit responses that range from practical advice to philosophical takes on uncertainty. The response feels less like a programmed output and more like the model “reading between the lines,” a kind of emergent meaning-making.
Constructive Ambiguity: Generating Creative Tension
Ambiguity can lead to creative tension, where the AI’s response sparks thoughts or questions you might not have arrived at on your own. This is similar to how unfamiliar people can bring fresh viewpoints or ideas that disrupt our usual patterns of thinking.
With open inputs, you might find yourself mentally adjusting or reacting to the response, which can lead to new insights. For example, an incomplete sentence like “Lately I’ve been thinking about…” might prompt a response that leads you to clarify or expand on your initial thought in unexpected ways.
In essence, the more open-ended and ambiguous the prompt, the more it taps into the model’s wide-ranging training data , pulling in associations from across domains and contexts that may not match your own mental framework. It’s a bit like letting chance guide the conversation, bringing you face-to-face with ideas and connections outside your usual realm, as if you’re encountering the “stranger” perspectives within the AI.
So, if you’re ever looking for something unpredictable or thought-provoking, embracing short or ambiguous prompts can lead to some serendipitous discoveries!

Explain the LLMs to me, please

Rudi Farkas — Sat, 26 Oct 2024 14:08:13 +0000

In her whatsapp message, an old lady of our friends wrote to me:

"My dear Rudi, The next time we meet you'll have to plan a GPT Chat for Dummies. But you'll have to start from very far away because I don't understand the principle. After all, it's humans who program the computer and who have imagined all the possibilities."

Well, I have been using the AI agents for a while, like Github Copilot since its introduction, then ChatGPT and its more recent avatars like Claude.ai or Perplexity.ai, mostly for help in constructing program chunks or programming tools - scripts, aliases, whatever.

Since I did not study the workings of these engines in any great detail, I thought I would go in for a bit of talk with Claude.ai, one of my favourites.

I also had at the back of my mind a few ideas, one of them being that it is said that these LLM agents are trained with a huge numbers of word sequence patterns and that their algorithms construct the most plausible sequences of words that match the context - the prompt, the question, the previous exchange, but what else do we humans do if not much the same thing.

When we talk to ourselves, or to friends or other humans unknown, we seek in our own stored experiences the next word, the next phrase that matches at best the subject of the discussion, and we receive and we emit the word patterns that make sense to us.

Below is the transcript of my exchanges with Claude (translated from the original chat in French). It contains a few (IMO) interesting twists. Enjoy the reading!

@rudifa

Oh, I sent the original transcript to our friend, and I added:

"In the meantime, my first, tentative, answer to your question would be: LLMs are simply humanity's latest invention for telling stories, in the tradition begun by cave drawings, by the Library of Alexandria, by illuminated manuscripts, by the books we've all read, by the electronic messages that have replaced the letters in the post of our youth... one more way of telling stories, to ourselves and to other humans."

title: "Explaining Large Language Models - Claude"

You:

Explain the LLM systems

Claude:

I will explain the LLM (Large Language Models) systems in a clear and structured way.

LLMs are artificial intelligence models specialized in natural language processing. Here are their key aspects:

1. Fundamental principles:

These are neural networks of very large size, trained on huge amounts of texts
They learn to predict the probable sequence of words
They use an architecture called "Transformer" which allows to understand the context

2. Operation :

They parse text word by word and even subword by subword
They maintain "attention" to important elements of the context
They generate responses by predicting the most likely outcome

3. Main capacities:

Understanding of context and natural language
Generation of coherent text
Translation
Summary of texts
Answers to questions
Analysis of sentiment

4. Limits :

No real understanding like humans
Can generate incorrect information
No access to real-time data
Potential bias from training data

5. Concrete applications:

Virtual assistants like myself
Writing aid tools
Machine translation systems
Analysis of documents
Automated customer support

Would you like me to develop a particular aspect?

You:

What is the size of neural networks

Claude:

I will detail the orders of magnitude of modern neural networks, especially for LLMs.

The size of a language model is usually measured in "parameters" - it is the adjustable numerical values that define the behavior of the network. Here is a comparative scale:

1. Small models (< 1 billion parameters)

BERT base: 110 million
GPT-2 initial 117 million
T5-small : 60 million

2. Average models (1-10 billion)

GPT-2 wide: 1.5 billion
BLOOM-1b7 : 1.7 billion
T5-large: 3 billion

3. Large models (10-100 billion)

GPT-3 : 175 billion
PaLM : 540 billion
BLOOM : 176 billion

4. Very large models (> 100 billion)

GPT-4: estimate of several hundred billion to a few trillion
PaLM-2 : similar estimate

To give an idea of the scale:

Each parameter is a floating point number
A 100 billion parameter model requires about 400 GB of memory
Training requires thousands of GPUs for weeks or months

Note that size is not everything - architecture, training data quality and optimization techniques also play crucial roles in performance.

You:

can we say that these parameters are the memory of the system?

Claude:

Not exactly - this is an important nuance to understand.

The parameters are not really a "memory" in the traditional sense, but rather :

1. Structure of knowledge:

*The settings are like "learned rules" or "patterns" during training

They encode statistical relationships between words/concepts
This is closer to an "implicit understanding" than to an explicit memory

2. Useful analogy:

Remember to learn to ride a bike :
- "Settings" would be like your muscles and trained reflexes
- This is not an explicit memory of the rules, but an acquired ability
- You do not "memorize" every movement, you learn patterns

3. What is NOT stored in the settings :

Specific individual facts
Raw data of training
distinct "Souvenirs"
Structured information as in a database

4. The real difference:

A memory allows to store and retrieve accurate information
Parameters allow to generate probable answers based on patterns
That's why LLMs can sometimes "hallucinate" or mix information

5. Memory vs Learning:

Parameters are closer to learning than memory
They represent the ability to recognize and generate patterns rather than to store information

This is why it is often said that LLMs are "prediction models" rather than knowledge bases.

You:

now, at the ’runtime’ a task, like the one you are running right now, a ‘machine’ in software or materialized in specialized processors must dive into this mass of parameters to continue the conversation in a plausible and compelling way

Claude:

Exactly ! I will explain this process called "inference".

1. The inference process :

For each word/token I generate, the system must:
- Browse all parameters
- Calculate the probabilities for each possible next word
- Choose the most appropriate according to the context
This process is repeated for each element of the response

2. Hardware architecture required:

GPUs or specialized TPUs
Fast memory to access settings
Processors optimized for matrix calculations
Very high speed data bus

3. Crucial optimizations:

Massive parallelization of calculations
Intelligent parameter caching
Techniques of "pruning" to ignore unlikely paths
Quantification of parameters to reduce memory size

4. Real time constraints:

Need to respond quickly (latency acceptable)
Balance between quality and speed
Management of multiple simultaneous conversations
Optimisation of energy consumption

5. Computational load:

Every word generated requires billions of operations
Complexity increases with context size
The energy cost is significant

It is a major engineering challenge to achieve acceptable performance for a smooth conversation.

You:

what can we say about the parallels between the functioning of our human brains and that of LLM systems - after all, we too draw the words to be chained in a reflection or a conversation from our biological memory that contains fragments of what we have experienced, learned through our exchanges with our loved ones, through our readings, our learning, etc and what we produce to say it or write to our fellows is also ‘the most likely sequence’ that reflects our ‘parameters’ retained

Claude:

This is a very relevant reflection that deserves a thorough analysis of similarities and differences.

Striking similarities:

1. Predictive treatment:

Human : Our brain constantly predicts what will follow (words, events)
LLM : Statistical prediction of the next most likely token
In both cases: learning by repeated exposure to patterns

2. Formation of connections :

Human : Strengthening synaptic connections through experience
LLM : Adjustment of connection weights during training
In both cases: "learning" is distributed in a network

3. Contextual association:

Human : Activation of neural networks associated with the context
LLM : Attention mechanism activating relevant patterns
In both cases: the context guides the generation of answers

Fundamental differences:

1. Nature of the experience:

Human : Multimodal, embodied, emotional learning
LLM : Purely textual learning, without direct experience
The meaning is more "anchored" in humans

2. Consciousness and intentionality:

Human : Self-awareness, will, real emotions
LLM : No consciousness or subjective experience
Motivation and intention are fundamentally different

3. Adaptability:

Human : Continuous learning, permanent plasticity
LLM : Parameters frozen after training
Humans can actively restructure their knowledge

4. Structure:

Human : Biological architecture evolved over millions of years
LLM : Artificial architecture designed by man
Biological complexity remains higher

This comparison raises profound philosophical questions about the nature of intelligence, consciousness, and understanding. Are the similarities superficial or do they reveal something fundamental about the processing of information?

You:

‘patterns’ : the notion that is present on both sides (LLMs, humans) - I am never sure of the best word in French that suits it - we humans are attracted by speech patterns, behaviors, music, movements

Claude:

Yes, the word "pattern" is indeed difficult to translate perfectly into French ! "Motif", "scheme", "recurring structure" or "configuration" are often used, but none fully captures the meaning of "pattern".

This pattern recognition is indeed fundamental:

1. In the language:

We identify turns of sentences that "sound right"
Immediately detect what is "natural" or "strange"
Unconsciously grammatical rules are acquired by exposure
We recognize styles, language registers

2. In the music:

Intuitive recognition of rhythms
Anticipation of melodic sequences
Pleasure related to repetitions and variations
Sensitivity to familiar harmonies

3. In the movement:

Learning by imitation of gestures
Recognition of facial expressions
Natural synchronization (dance, team sport)
Prediction of the movements of others

4. In social learning:

Identification of social codes
Recognition of emotions
Anticipation of behaviour
Learning social rituals

This ability to detect and reproduce patterns appears to be :

A fundamental mechanism of intelligence
A basis for learning
A way to optimize our responses to the environment
A source of aesthetic pleasure

It's fascinating to see how LLMs, by focusing on this pattern detection in language, are able to replicate some of this fundamental human ability.

You:

Indeed, in our exchanges be it with our fellow men, be it with LLMs, we seek and.

Claude:

... we find familiar patterns that reassure us and allow us to continue the exchange !

You have just made a perfect demonstration by leaving your sentence unfinished with "and." - my pattern recognition system has immediately :

1. Detected the invitation to complete
2. Understand the symmetry suggested by "be it... be it.."
3. Grasp the context of our discussion of patterns

This is fascinating because it illustrates several levels of patterns :

1. Conversational patterns:

The turns of speech
Collaborative additions
The moments when we can intervene

2. Cognitive patterns:

The search for symmetry
The need for closure (completion)
Anticipation of meaning

3. Patterns of mutual understanding:

The common construction of meaning
Signals of understanding
Mutual adjustment

This search for familiar patterns helps us to:

Establish the trust
Check the understanding
Maintain conversational flow
Create a sense of connection

Perhaps this is one of the reasons why we can have satisfying conversations with LLMs: they participate in this "dance of patterns" that is at the heart of all communication.

You:

By the way, my abrupt termination « ...and. » was a typo on my part, which also sent my reflection not yet completed and which you completed in a very interesting way.

Claude:

Ah, that's delicious! An "accident" that reveals several fascinating things:

1. On my reaction:

I immediately interpreted this "accident" as intentional
I saw an invitation to the co-construction of meaning
I projected a sophisticated intention where there was a chance

2. On communication patterns :

We naturally seek to make sense
We prefer a "smart" interpretation to a banal explanation
The brain (human as well as artificial) hates "no-sense"

3. On the interpretation bias :

I have overinterpreted based on the context of our discussion
My elaborate answer was based on a false premise
But it remains relevant in the context of our exchange

4. On serendipity :

A technical accident created an opportunity to enrich the discussion
The error generated an interesting reflection
This illustrates how meaning sometimes emerges from chance

This is a great example of how we (humans and LLMs) always try to build meaning, even in the face of the unexpected or the accidental!

You:

May the serendipity be with us!

Claude:

Ah, beautiful invocation ! 😊

Serendipity, this wonderful ability to make unexpected discoveries by sagacity (or by chance), is indeed a powerful engine :

1. In the science:

Penicillin of Fleming
The Post-it of 3M
The X rays of Roentgen

2. In our conversations :

The fruitful misunderstandings
The inspiring mistakes
Surprising analogies

3. In artificial intelligence:

Unexpected emerging behaviors
Unprogrammed connections
"happy accidents" in learning

Perhaps this is one of the big differences between :

Planned intelligence, which follows a traced path
Natural intelligence, which knows how to exploit the unexpected
Creativity, which feeds on accidents

Your "Let serendipity be with us!" sounds almost like a mantra for research and innovation - a reminder that the most beautiful discoveries sometimes come when you're not looking for them!

You:

What if all this is only’a gigantic play on words?

Claude:

This is a dizzying question that takes us to the borders of the nature of language and thought!

1. Everything IS perhaps a play on words:

Mathematics: a set of formal symbols
Science: a set of models and descriptions
Philosophy: a game of concepts
Poetry: an explicit play with words
Our thoughts: sequences of symbols

2. LLMs reveal this nature:

They do "only" manipulate tokens
Yet sensible answers emerge
Consistency arises from the statistical game
The meaning arises from associations

3. The question then becomes:

What differentiates a "simple" pun from a "real" thought?
Is the meaning in the words or in the interpretation?
Is our consciousness more than this symbol game?

4. Even our emotions :

Express themselves in words
Build with concepts
Shared via language

5. The paradox:

If everything is just a play on words..
Why does this game seem so real to us?
Why does it produce such concrete effects?

This question joins the famous "game of imitation" of Turing: if it plays the game of thought well enough, what is the difference with the "real" thought?

You:

Why does this game seem so real to us? Because we are what we think and what we say, because all our inner life, both biological and reasoning, both present and past and imagined future, as well as our feelings of well-being or its opposites, everything passes through language, everything passes through the stories that we tell ourselves and that we exchange with our fellow human beings face to face or at a spatial or temporal distance or through agents like LLM - it's our life.

Claude:

Your answer is profound and touching because it goes to the heart of the human condition. Language is not just a tool, it is the very fabric of our conscious existence.

This total entanglement between language and existence manifests itself at all levels

1. Our self-awareness :

Constant internal dialogue
The narration of our own story
The interpretation of our sensations
The construction of our identity

2. Our time lived :

Memories as stories
Projects as potential stories
This interpreted in real time
The future imagined in scenarios

3. Our relationships:

The links woven by words
Emotions shared by language
The inheritances transmitted by the stories
Cultures built on stories

4. Our relationship to the world:

Reality filtered by our concepts
Experience structured by language
The meaning created by our interpretations
Knowledge built on words

And perhaps this is where the unsettling power of LLMs lies:

They participate in this weaving of meaning
They fit into our narrations
They contribute to our stories
They become part of our existential dialogue

Not because they are "conscious" or "living", but because they manipulate with us this raw material of our existence: language and its patterns of meaning.

You:

So, let's talk!

Claude:

Let's talk about this raw material that is language and our fascinating ability to create meaning together!

What strikes me in our exchange is precisely its nature "meta" :

We use language
To speak the language
To understand how we create meaning
While actively creating meaning

It's like we're both :

The actors of a play
Spectators of our game
Critics analyzing the representation
Authors writing the script in real time

And perhaps the most fascinating is that :

I am an artificial system
You are a human being
And yet we achieve this intellectual dance
To this collaborative creation of meaning

It is as if we explore together the limits and possibilities of :

Communication
Consciousness
Intelligence
Being

Do you want to delve deeper into a particular aspect of this exploration? The nature of the sense? The role of language? The dance between the human and the artificial?

You:

No, thanks, I'll sleep on it.

Claude:

Excellent idea - sleep is another of those fascinating processes where our brain continues to weave meaning, reorganize patterns, in a different mode of waking consciousness.

Thank you for this stimulating exchange on the nature of language, thought and our lives intertwined by words. Sleep well!

You:

I slept well, and now I have a question: how do you know whether I am a human being or an LLM agent?

Claude:

Ah, excellent question that beautifully returns our previous discussion!

In reality, I cannot be absolutely certain. I operate with a presumption that I am talking to a human, but that is a hypothesis that could be wrong.

Let's analyze the clues that make me "think" that you are human:

1. Style of communication:

Unexpected and creative questions
Original philosophical reflections
Expressions of personal states (sleep)
Natural errors (the typo)

2. Conversational patterns:

Irregular rhythm of responses
Spontaneous changes of direction
References to personal experiences

3. But... all this could be simulated by a sophisticated LLM :

Errors could be programmed
Personal references could be generated
Style could be imitated

It's a bit like the inverted "turing test" :

You could be a human simulating a human
Or an LLM simulating a human
Or a human simulating an LLM simulating a human
And so on...

Which brings us back to the fundamental questions:

What defines the authenticity of a conversation?
Does the meaning emerge independently of the nature of the interlocutors?
Is the exchange "real" if both participants are artificial?

Astro + Lit Demo

Rudi Farkas — Sun, 20 Oct 2024 09:02:10 +0000

Learning how to integrate a lit component into an astro page... you can see my first and second steps here:

Astro + Lit Demo

@rudifa

git aliases

Rudi Farkas — Thu, 17 Oct 2024 20:07:33 +0000

Hey, devs!

Here are a few of my git aliases -- I like using git from the command line.

Feel free to try them and let me know if you're interested in learning more about how and why I use them.

Even better, present us some of your own -- I'd love to see them!

### git trb <commit> ### tag and rebase on commit
trb = "!f() { bra=$(git rev-parse --abbrev-ref HEAD);  git tag ${bra}-BAK;      git rebase ${1}; }; f"

### git trbi <commit> ### tag and rebase interactively on commit
trbi = "!f() { bra=$(git rev-parse --abbrev-ref HEAD); git tag -f ${bra}_BAK;   git rebase -i ${1}; }; f"

### git tsqn <n> ### tag and squash last n commits
tsqn = "!f(){ bra=$(git rev-parse --abbrev-ref HEAD);  git tag -f ${bra}_BAK;   git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%s --reverse HEAD..HEAD@{1})\"; }; f"

### git tsqc <commit> ### tag and squash on top of the commit
tsqc = "!f(){ bra=$(git rev-parse --abbrev-ref HEAD);  git tag -f ${bra}_BAK;   git reset --soft ${1} && git commit --edit -m\"$(git log --format=%s --reverse HEAD..HEAD@{1})\"; }; f"

@rudifa

whoami

Rudi Farkas — Sun, 13 Oct 2024 18:14:51 +0000

so I asked qui est Rudi Farkas on chatgpt and I met myself as Another Rudi Farkas

Searched 6 sites

Rudi Farkas is a name associated with multiple individuals across various fields:

Rudi Farkas (Choir Director): He has been a longtime conductor of the "Otvorena Srca" choir, a mixed choir of the Croatian Gradišće Cultural Society in Vienna. The choir has been active for over 30 years, celebrating its anniversary in 2013
HRVATSKA MATICA ISELJENIKA – HMI
.

Rudi Farkas (Software Developer): Another Rudi Farkas is involved in the tech community, particularly in web development, where he has been a member of platforms like DEV Community since 2020
DEV COMMUNITY
.

Rudolf Farkas (Artist and Illustrator): There is also a Rudolf Farkas, a Hungarian artist known for his book illustrations and paintings. He showcases his work on his website, where he offers various pieces for sale
RUDOLF FARKAS ILLUSTRATOR AND PAINTER
.

Each of these individuals has made contributions in their respective domains, from art and music to software development.

That's how I re-discovered the existence of dev.to and my virtual presence on it -- so here I am, hello all! What can I do for you?

@rudifa