In 2023 ChatGPT from OpenAI reached 100 million users faster than other solutions in Web 2.0 era.

Source: Yahoo Finance

And since then many intelligent models from Anthropic, Cohere, IBM, Goole, Amazon, Meta AI, DeepSeek, HuggingFace come up and also many startups entering the arena. It’s interesting times to invest in our skillset.

Platforms like HuggingFace—the GitHub of AI—serving as open hubs where an entire ecosystem of researchers and developers collaborate to share, fine-tune, and deploy AI models across the spectrum from natural language processing to computer vision. The scale is here 1.4 million models already deployed, with new breakthroughs arriving weekly.

In this blog post, I will try to give a overview of the key components of Large Language Models (LLMs) at a high level, focusing on basic concepts, minimal math, and visual explanations to make complex ideas easy to understand.

Why This Actually Matters

Understanding model architecture isn't just academic. Fine-tuning models, interpreting model cards, and selecting the right model for specific tasks like todays popular agentic architectures can imply the difference between breakthrough performance, costly failures and maybe also security vulnerabilities.

These models are reshaping how we work, learn, and create—right now. Whether you're an educator designing curriculum, a researcher, or simply curious about the technology transforming your daily life, invest in these fundamentals (I also put many resources at the end of the blog).

The technology feels like magic, let’s explore together! 🤗

The Road to Generative AI: Key Milestones

But first, lets start with a quick history of Artificial Intelligence. AI is a discipline with a vast history and many applications in the real world. Very inspiring development phase with amazing research and development breakthroughs. While AI encompasses many approaches, this guide focuses specifically on the architecture that's changing everything: Transformers. The true inflection point came in 2017 with the publication of a paper titled: "Attention is all you need." The work by Vaswani and his friends would fundamentally transform AI capabilities and set the stage for today's generative revolution.

AI Language Modeling

Language models are fundamentally about understanding deep connections between words, concepts, and context—similar to how our own brains process language.

Imagine two friends chatting:

Person 1 (speaking):

"Last night, I was in the studio*, working on a* new track*, tweaking the* melody*, and then I realized I needed to* adjust my..."

At this moment, Person 1 own thought process is already being pulled toward a specific word before they even say it. Their mind is influenced by the words they just used—"studio," "track," "melody," and "adjust"—making "keyboard 🎹**"** feel like the most natural next word.

Person 2 (listening):

As Person 1 speaks, Person 2 is in thinking/listening mode, but what Person 2 expects depends on both Person 1’s words and their own mental associations. Person 2’s interpretation is influenced by Person 1’s context 🎹**.**

Just like in LLM’s, similarity helps pull related concepts together—such as how "melody" and "track" reinforce the idea of music—while attention helps focus on the most relevant words, filtering out less important information to determine meaning.

The Secret Sauce of LLMs: Similarity + Attention

This human conversation mirrors how LLMs work:

• Similarity creates connections between related concepts—just as "melody" and "track" naturally point toward music-related completions.

• Attention helps filter out noise and focus on what matters most—determining which earlier words are most important for predicting what comes next.

Next-Word Prediction: The Core Task

Like the example with above, at its heart, a Large Language Model has one fundamental job: "next token prediction."

These sophisticated systems learn patterns from massive datasets to predict the next token in a sequence. When you type "Which move in AlphaGo was surprising?" the model:

1. Processes your prompt

2. Calculates probabilities for every possible next token

3. Selects the most likely continuation (or samples from high-probability options)

4. Repeats until it reaches a natural stopping point

The process continues word by word until the model decides to end the sequence, producing something like: "The most surprising move was 37"

This simple mechanism—predicting one token at a time based on everything that came before—is the foundation for Large Language models, that can now write essays, code, stories, and even simulate conversations.

The complete sequence goes on, until the LLM decides, to bring a special token like |EOS| “End of Sequence” and the answer ends with “The most surprising move was 37” like.

The complete flow illustrated:

The Journey to an LLM artifact

We can imagine these models as a compressed ZIP file of internet data. It contains the so-called million or billion parameter weights (floating-point numbers), which during training are adjusted and learned.

To achieve such behavior, we require high-quality data, substantial computational power, memory, and extensive GPU clusters. Training these models is costly and time-consuming, often taking months. Not many companies can afford the millions of dollars needed to train a model from scratch.

For example, Llama 3 from Meta AI was trained on 24,576 GPU clusters for months, and Meta's Llama 4 is currently being trained on a cluster exceeding 100,000 NVIDIA H100 GPUs. DeepSeek R1 model is trained on a smaller set of GPUs but uses advanced architecture training, which I want to explain in further blog posts, called Reinforcement Learning. This huge computational requirement also raises sustainability concerns, one of the most important topics in training models. A very good session about GPU power consumption is available at the CCC.

Let's take a quick journey through these training steps.

Data preparation

Large Language Models are trained on a massive scale of internet data. I mean by large scale, trillions and billions of tokens. In the upcoming sections I'll explain more about tokens. At the same time, we want large diversity and high-quality documents. One popular dataset is CommonCrawl. Common Crawl, a non-profit organization, has been crawling the web since 2007, and actually contains 2.7 billion web pages. If you are interested in a large scale data pipeline and a cleaned up dataset, look at the FineWeb project from HuggingFace.

steps taken to produce FineWeb dataset for LLM training

I don't want to go into the details of data engineering in this post, as it is about LLM concepts, but remember it's trained on large diversity and high quality of data. To see the full pipeline visit FineWeb. Also worth mentioning you can explore some public datasets on atlas.nomic.ai and the diversity of the topics covered in the domains. Also HuggingFace Dataset is a good source to discover more datasets.

From Base Models to Chat Assistants

Next, we train a model for next token prediction. These models are also called base models, and their names typically end with "Base", like Llama-3.1-405B-Base.

However, these base models do not behave like ChatGPT or instruction-tuned models (e.g., Llama-3.1-405B-Instruct) that we experience through web interfaces.

The base models are just the foundation - they can predict token incredibly well but lack the refined conversational abilities of the instruction-tuned versions that power consumer-facing AI assistants.

For example if we prompt Llama-3.1-405B-Base with:

Prompt: "Which move in AlphaGo was surprising?

we get following response sequence:

“Is it possible to explain it?" The following is a question I posed to the AlphaGo team, as part of an academic project: Which move in AlphaGo was surprising? Is it possible to explain it? AlphaGo's moves are often surprising to human players, as they are based on a deep understanding of the game that is difficult for humans to replicate. One example of a surprising move made by AlphaGo…..”

The base model artifacts are produced during the most costly phase: pre-training.

BUT: This is not what we want from an model. Most of the time we're summarizing papers, translating sections, or generating content based on user questions or prompts.

Instruction Tuning

In order to get an assistant model like GPT, we need to align our model for our downstream task, which is awesome. For example, we can align to question answering, classification, translation, different persona roles that the model can take, topic modeling, clustering etc. The list goes on throughout the NLP journey.

Think of it as following: you are giving a task for factual label checking, and we need to create thousands of instruction pairs. Then taking thousands of this possible pairs we can further fine-tune our base model and get an instruction tuned model. Andrej Karpathy explanations is very good.

These instruction pairs look like this: Factual Explanation

Instruction: Explain how photosynthesis works in simple terms.

Response labeled: Photosynthesis is how plants make their food. They take sunlight, water, and carbon dioxide from the air and convert it into oxygen and glucose (sugar). This happens in tiny structures called chloroplasts, which contain chlorophyll—the green pigment that captures sunlight energy. Plants use the glucose for energy and to build structures like stems and leaves. The oxygen is released into the air for us to breathe.

Beyond Instruction Tuning

These data can be created from humans or synthetic data generation. But the story doesn't end here—we need further improvements. Reinforcement Learning or Reinforcement Learning from Human Feedback like OpenAI approaches makes the alignment better.

Reinforcement Learning

Reinforcement learning is an amazing field of artificial intelligence. We've heard in the news about breakthroughs from DeepSeek's pure RL approach. Let's illustrate RLHF or so-called Reinforcement Learning from Human Feedback simply.

Initially, an instruction-tuned model is trained to follow prompts, but it undergoes further fine-tuning through reinforcement learning. During this phase, models interact with prompts, learn from trial and error, and receive human feedback to align responses with user expectations. This iterative process helps LLMs improve accuracy, relevance, and coherence, making them more effective in real-world applications.

The Reward Model in RLHF

The reward model's job is surprisingly simple: it just assigns a numerical score to any response. For example, when the LLM generates multiple answers to "Explain climate change" the reward model might give a score of 8.7 to a clear, accurate explanation and 3.2 to a confusing or inaccurate one. These scores then guide the learning process—the LLM is adjusted to maximize these reward scores, essentially learning to produce responses that humans would rate highly.

Ok lets go further, until now we understand at a very high level, what is AI Language modeling, what’s the task of an training (next token prediction), how different models created. But let’s see the revolutionized Idea of Attention.

Attention is all you need

In order to decode and process language in computers, we need a notion of:

• Numbers - converting language to numbers also called embedding space

• Similarity

• Attention

Tokenizer: The First Gateway to LLMs

This is the first step whenever we interact with an LLM like ChatGPT, Claude or any LLM API. Imagine this as the LLM's Vocabulary. Every time we send a model a prompt, it first gets tokenized.

Why? Because we need a mapping from text to numerical representations that computers can process and tokenization is the first part on the way 🛣️ 🛣️ Almost all of the model providers also have a pricing model based on consumed and output tokens.

Lets say you send ChatGPT the prompt “What is tokenization why we need this”. The prompt gets broken into colored tokens as shown in the image. Importantly, tokens don't always align with complete words—"token" & "ization" are separated into different tokens.

You can visually explore tokenization processes using tools like the https://tiktokenizer.vercel.app/.

Why use subword and not word by word?

Language is indeed complex and diverse, with new words constantly emerging across various languages. Many languages allows for the creation of new words from existing ones (e.g. sunflower), and some languages have even no spaces like Japanese (e.g. 今日はサーフィンに行きます). So our language models need to be generative and capable of capturing many patterns. Building a vocabulary with millions of words is not effective and even not possible.

Tokenizers are algorithms that capture statistical properties of large text corpora on which LLMs are pre-trained. There are different techniques for tokenization, like BPE (Byte Pair Encoding), WordPiece, SentencePiece. In this post I don't go inside, but assume with tokenizers we get an intelligent vocabulary with subword tokens from our corpus of data.

First numbers: Position IDs to token embedding vectors

Remember tokenizer creates our vocabulary and helps us mapping from text to numerical representations.

In general tokens can be anything from words, image patches, speech segments which has an ordered sequence in the nature. In the above example "What a wonderful world." is mapped to the numbers 4827, 261, 10469, 2375, 13 and so on called the Position IDs. These IDs are encoded in the model's inner architecture (Embedding-Matrix) and maps our tokens to a fixed token embedding vector.

But why Positons IDs are so important?, because language is ordered and we should keep track of order for each token later in processing, for example most phenomena in the nature are ordered most not. Imagine machine translation, words can take another position in a sequence.

From these ID's we get fixed vectors, so called token embedding vectors. These embedding vectors has huge dimension for example in ibm-granite/granite-3.1-8b-instruct LLM has 4096 dimension size.

It's all about similarity?

Ok tokenizer, position ids, and what are these token embedding vectors?

We need this because, with the power of linear algebra we can apply mathematical operations. Let's explore these concepts in two dimensions for visualization :)

Notion of similarity

In this embedding space, we can see how words or concepts are arranged based on their meaning. The angle between vectors tells us how similar they are - smaller angles mean greater similarity. This is measured using cosine similarity, which ranges from -1 (completely opposite) to 1 (identical). For example, the apple and orange vectors have a small angle between them, indicating high similarity, while the phone and fruits have a much larger angle, showing they're less related.

Now we have our embeddings and calculate similarity between the embeddings, are we done?

Unfortunately not. These token embedding vectors are not perfect, and should be learned and adjusted during training, because language is all about context.

The Context Challenge: When "Apple" Isn't Just a Fruit

Imagine these situations, how the token embedding for “apple” should be calculated?

The Problem: Finding the Right Embedding

The challenge is that we cannot assign a perfect place for every token in the latent space. Raw embeddings might capture some relationships, but they are often not well-aligned with real-world structures. To fix this, we apply linear transformations, which allow us to adjust the embedding space to better reflect similarities and relationships.

Linear Transformations

So, what are linear transformations? Think of them as matrix operations applied to vectors. These operations can:

• Stretch the space to emphasize certain dimensions 📏

• Rotate vectors to better align with meaningful directions 🔄

• Shear data to adjust relationships between points 📐

• Combine all these effects to create a better-structured space

Adjusting Embeddings and Choosing the Best Embedding?

Imagine we want to discover the optimal embedding space that captures the true relationships in our data. Let's explore this with a simple example:

• Ahmet is an excellent basketball player 🏀—he is great at jumping, agility, and teamwork.

• Sofia is a strong swimmer 🏊‍♂️—she excels in endurance and breathing control.

Looking at the three embedding spaces below, we can immediately see why Embedding 3 is better. It organizes both athletes in relation to their sports while capturing their shared identity as athletes. During the training the so called the Multi-Head Attention Layer decides which Embedding is the best or combines them.

Transformation Magic

If we decide Embedding 3 should be used then we apply a linear transformation with matrix. The values of the matrix is the learnable parameters. We're performing matrix-vector multiplication, which is calculated using multiple dot products.

This process mirrors how our own brains might reorganize concepts—shifting from thinking about "sports equipment" to thinking about "athletes and their specialties" when the context requires it. The difference is that our AI models must learn these transformations through millions of examples rather than through lived experience.

The beauty of this approach is that as the model encounters more data, these transformation matrices continuously refine, creating increasingly nuanced understanding of the relationships between concepts.

The Magic of Attention: Why Context Changes Everything

Until now we've explored similarity (cosine, dot-product) and how linear transformations can create better embeddings. But we're missing something crucial - Attention, the breakthrough that revolutionized AI language understanding.

Let’s take a example—journalist and microphone.

In an ideal world, these two should have a balanced connection in the embedding space, but in real-world training data, that’s not the case. A journalist strongly pulls "microphone", but "microphone" does not strongly pull "journalist".

Why This Asymmetry Exists?

Because in real-world data, "journalist" often appears with words like interview, report, article, media, and yes, microphone. But "microphone" has a much broader range—it appears with singers, podcasters, radio hosts, studio equipment, speakers, and many other unrelated concepts. So, when we ask:

• "What does journalist relate to?" → Microphone is a strong association because journalists frequently use microphones.

• "What does microphone relate to?" → Journalist is a weak association because a microphone is used by many professions, not just journalists.

Why a Single Linear Transformation Doesn't Work

If we apply only one transformation, we still get a symmetric pull, meaning the model would think that:

• "Microphone" should influence "journalist" just as much as "journalist" influences "microphone."

• This is incorrect because a microphone is just a tool, and many people use it beyond journalists.

The Fix: Two Linear Transformations

To properly capture this, we need two different transformations. Lets introduce Key and Query. Key is which pulls the other token, and Query is which is pulled. We apply different perspectives depending on whether "journalist" or "microphone" is acting as the key or the query.

1. Journalist (Key) – It strongly pulls "microphone" (Query) because it's an important tool for their work.

   

2. Microphone (Key) – It weakly pulls "journalist" because its use is much broader.

   

The Formula

Applying two linear transformations on Keys and Queries and then we take the angle between keys and queries. After that we can calculate the similarity via dot-product (the Attention matrix).

Journalist (Key) – Microphone (Query) we want large cosine in similarity (strong pull).

Microphone (Key) – Journalist (Query) we want small cosine in similarity (weak pull).

Every value of this matrices is adjusted during training time, so we get a clearer embedding.

Understanding the Dot Product in Attention

The dot product is the mathematical operation that powers attention. In simple terms:

1. What it does: Measures how aligned two vectors are with each other.

2. How it works: Multiplies corresponding elements of two vectors and sums the results.

The Value

But last, there is another component called Value. Think like this, the actual audio content captured by the microphone—it carries the real meaning the journalist wants to process. After computing the similarity between queries and keys (dot product of Q and K), these attention scores are used to weight the Values (V). This means that:

• If a key strongly matches a query, its corresponding value is given more importance.

• If a key weakly matches a query, its value contributes less to the final output.

Recap: We are extracting from an token embedding the Query, Key and Values based on this trained matrices, and producing a more contextualized token embedding with same dimension

• 

  Token embeddings transform words into number vectors, creating a mathematical language.

• Linear transformations are the key mathematical operations that create the three different perspectives:

  • Each embedding is multiplied by three different matrices to create Query, Key, and Value representations of the same token

  • This is how one word can have multiple "views" or "roles" in the attention process

• Query perspective (Q matrix transformation): "What am I looking for in other words?"

• Key perspective (K matrix transformation): "What aspect of me might others find relevant?"

• Value perspective (V matrix transformation): "What information should I contribute if matched?"

• Same input, three views: The word "apple" starts as one embedding but is transformed into:

  • A Query vector (searching for relevant information)

  • A Key vector (advertising what it contains)

  • A Value vector (the actual information to be used)

• Dot products between queries and keys measure relationship strength, creating the attention map.

• Context-sensitive understanding: These transformations allow the model to interpret "apple" differently when it appears near "iPhone" versus "orchard."

• Asymmetric relationships are naturally modeled because each token has these three distinct roles.

• Multi-head attention applies multiple sets of these transformations in parallel, capturing different relationship types simultaneously.

Multi-Head-Attention (Linear)

One point, as we saw we need to combine between best embeddings, this is done via Multi-Head-Attention (Linear). Below, from the original paper. Imagine these as an intelligent brain which combines the best token embedding based on context. Suppose many brains which are calculating embeddings and choose or combine and weight them based on context.

Multiple attention mechanisms in parallel: Each "head" learns to focus on different aspects of language.

The Linear transformations:

• • Lower Linear layers: Project input embeddings into different "perspective spaces" - one might focus on syntax, another on semantics, another on entity relationships.

    • Upper Linear layer: Combines these multiple perspectives into a unified representation.

Scaled Dot-Product Attention: Each head calculates its own attention pattern based on its specialized Query, Key, Value projections.

Are we done with predicting the next token?

Until now, we have explored the attention mechanism. To predict the next token, the contextualized token embeddings pass through a multi-layer perceptron neural network (MLP) or a feedforward neural network (FFNN).

Unlike self-attention, which connects and applies attention to tokens, this process handles each token position separately. As the information flows through this sequence, the model refines its understanding of the relationships and meanings within the text. At this layer, the model generalizes the learned concepts. This is also where most of the model’s parameters reside.

Reading a model card

Some model parameters from ibm-granite/granite-3.1-8b-instruct

Embedding Size of 4096 and Number of Layers 40

Number of attention heads 32 and Number of Key/Value heads 8

Feedforward Neural Network

Conclusion

We've journeyed through the inner workings of Large Language Models, uncovering the elegant concepts that enables machines to understand and generate human language. Through our exploration, we learned

• The core training objective is surprisingly simple: predict the next token

• Embeddings

• Attention mechanism

• Multi-head attention

• Transformer architecture core components

Resources

There is a lot to cover for more advanced deep dive I can suggest following resources.

https://www.youtube.com/watch?v=RFdb2rKAqFw

https://www.youtube.com/watch?v=7xTGNNLPyMI

AI Academy which provides very good insights

DeepLearning.AI

Hands-On Large Language Models: Language Understanding and Generation

Praxiseinstieg Large Language Models: Strategien und Best Practices für den Einsatz von ChatGPT und anderen LLMs (available also in english)

Amazon recently launched PartyRock. It's really fun to play with and at the same time also opens up opportunities for everyone to create apps and experiment with LLMs. This includes experimenting with various foundational models, understanding text-based prompting, and learning how to effectively chain prompts.

In a nutshell, it lets you build AI-generated apps in a Playground powered by Amazon Bedrock. Just go to https://partyrock.aws/ and create your own funny apps, based on prompt engineering, and share them with the world.

Background

PartyRock provides you with a Playground, where you can drag and drop widgets like:

• user input

• static text

• AI-powered: text generation, image and chatbot 🚀

You can think of the Playground as a list of functions (Widgets) backed up by Prompts. Every function produces results via prompt engineering, and these results can be concatenated throughout the entire setup via a dynamic variables chain.

Here in the example, the value of the User-Input Widget is included in the Prompt of the second Widget below. See also how the output is populated via variables to the second prompt.

Use Case

Let's say you want to build an app that analyzes your business requirements and conducts automatic EventStorming sessions. Based on the results, it generates the domain objects and a fully working serverless architecture with CDK code. 🙂

Just hit the landing page and describe your idea:

Here we go, you can find the app here:

https://partyrock.aws/u/odemis/TqzflOT9e/EventStormServerless

Play with it

Enter your business requirement in User Input-Widget e.g:

"A logistics company wants to improve its fleet management through a smart system that optimizes routes, tracks vehicle status, and manages deliveries. The system aims to enhance operational efficiency, reduce fuel consumption, and ensure timely deliveries."

The Output:

• Generates your domain events.

• Produces the CDK Code, including components like Lambda, EventBridge, DynamoDB, etc.

The CDK code comments out certain parts, but you can go deeper into specific implementation details in the next step via the Technology Wizard. For instance, if you wish to view details about the implementation of the generated lambdas, simply enter the name, and the output will be displayed in the next Component Widget. 👇🏽

You can also add new widgets, edit an existing widget, and play with the prompt, mode, and temperature settings.

Happy coding 🥳

Here again with a new topic - event-driven architectures 🚀

If you enter the world of microservice-style architectures in the cloud you are confronted sometimes with the terms like:

• serverless architectures

• resilient architectures

• reactive programming

• independent deployments

• message-driven architectures

• ...

the list can be growing. But from my perspective at the heart is the concept of event-driven systems. What it means event-driven and where do we start? First I give you the counterpart of this style of architecture the synchronous microservices and introduce you further into the world of asynchronous events.

Synchronous microservices?

If you start developing apps most of the time we architect our system around the concept of synchronous invocations.

Suppose you have an upstream service "Shopping Cart" and three downstream services "Billing", "Warehouse" and "E-Mail". In a synchronous style of development, the upstream-service calls directly the downstream-services and waits until the result is received.

But wait what's the problem with this style? The problem is in tight coupling which can produce crazy spaghetti code 🤯.

some further drawbacks:

• receiver failure, what if Billing Service breaks?

• throttling of downstream services, what if Analytics Service doesn't respond timely

• scalability issues, the ability to scale up your one service depends on the ability of all dependent services to scale up

• API versioning and maintenance of multiple versions can be very complex due to dependent services => we need some orchestration

Our Solution: Event-driven architecture

Let's first understand the word "Event" here:

"An Event is something that happened in the domain that you care about."

An event in the domain of e-commerce can be an OrderPlaced Event.

It has some important characteristics:

• it tells a fact

• it's immutable

• observable

Event storming is a powerful concept where you model your business processes around events and identify microservices.

But what do we do with these events in order to build architecture?

We asynchronously communicate the events as messages between our microservices. In asynchronous communication, the service which produces the event publishes it in our infrastructure, and other interested services can consume these events.

This brings some advantages compared to synchronous style:

• loosely decoupling => eliminate the impact of changes for services

• independent scalability

• cross-functional teams => without dependency on other teams which are responsible for the service

• independent deployments

• ... many more

But enough theory, we enter some practical AWS services.

What offers AWS?

AWS offers you many solutions for building event-driven architectures. EventBridge is one of the popular services, where we start our event-driven journey.

According to AWS: "Amazon EventBridge is a serverless event bus that helps you receive, filter, transform, route, and deliver events."

What is this Bus in EventBridge? 🚌🚌

They mention here the concept of bus. Simply EventBridge stores all the events on the bus. Your account has one default event bus, which receives all the events from AWS services in your account. Yeah, that's very cool, AWS is built around an event-driven architecture 🚀 When you start your event-driven architecture journey first you create your custom event buses to receive events from your custom applications.

Ok, let's hack into the AWS console, go to the console and enter EventBridge.

• You will create a custom EventBridge

• You will create a new rule in Amazon EventBridge.

• You will see a sample event in JSON

• You will configure this new rule to send it to a Lambda function target

Events in EventBridge?

Ok, EventBridge is an amazing serverless bus where your events in JSON format are stored.
Here bellow is a sample event in JSON format that's EventBridge conform. The red box is the envelope and contains information about which service published the event, the type of event, account, timestamp, region, etc. The blue box contains the actual event payload.

How do we deliver events? 🔔

Our interested services are notified via rules which must be set up in EventBridge. A rule matches incoming events and routes them to targets for processing. A single rule can route to multiple targets, all of which are processed in parallel.

For example, here we catch all events from the service com.aws.orders:

How do targets get called? 🎯🎯

After evaluating the rule the registered targets are called automatically. The targets must be set up after we create the rule. The target service can be a for example Lambda function that writes the order to DynamoDB.

In the end, we have the following architecture:

Real-World example:

What I love about AWS and the community is the amazing blog and of course, the labs provided by the workshops. If you are also a pragmatic programmer, I suggest you try this amazing workshop. In the end, you end up with a fully working event-driven architecture below. Many AWS services react during events flow in the system like StateMachines, API Gateways, etc.

Conclusion

In this first post, I want to give you a high-level overview. In further posts, I plan to go deeper into the landscape of asynchronous event-driven style.

I highly recommend watching the session from Amazon CTO Werner Vogels at re:Invent 2022. He talks about why event-driven architectures enable global scale and why the world is asynchronous in nature 😀 Further he also referred to the Distributed Computing Manifesto, a document from the early days of Amazon.

Today I want to write about maybe the forgotten web framework from Google - Google Web Toolkit or GWT. Attention by forgotten I mean, we don't see news about GWT every day on hackernews but it is used under oldschool Java devs and enterprises 😃

History of GWT

GWT is developed by Google in 2006 when Single Page Applications (SPA) or AJAX-intensive apps become very popular. Google Docs, Google Mails ... all these web-apps are SPAs and must behave like desktop apps in browsers.

Back then it was very challenging to develop maintainable JavaScript software architectures with frameworks like JQuery. On the other side programming languages like Java or C# have a very proven history in backend development for creating maintainable code. We have design patterns to produce effective architectures. The solution from Google in 2006: creating frontend architectures with Java 🚀

Idea of GWT

We develop our web apps in Java ⛏️. If you are already Java dev switching to frontend back was very easy. Google Web Toolkit has a built-in compiler, which compiles your Java code in JavaScript.

The basic idea is like NodeJs web frameworks like Express, we develop our backend and frontend parts in Java - We are Fullstack developers 🚀

For example, this code produces a button in the browser and if you click you receive a nice alert message:

@Override
    public void onModuleLoad() {
        Button button = new Button("Click me");
        button.addClickHandler(clickEvent -> {
            Window.alert("Hello World from Java!");
        });

        RootPanel.get("helloButton").add(button);
    }

UI Libs

In modern web dev, we can pick up some UI components from Bootstrap or Bulma. There are tons of UI libs for public use.

In GWT we have the standard gwt-widget library from Google and very old dated framework like GXT. The disadvantage of this approach is, Its very hard to make it a modern look with CSS and not implement the modern HTML5 approach. Another modern approach is DominoKit, I highly recommend it If you want to go with GWT.

How to start with GWT

If you visit the website of GWT, maybe you see in the getting started sections commands like 😟:

ant devmode

Come on ... I personally don't use ant build, we have in modern Java ecosystem build tools like gradle or maven. Instead, use this site only for documentation.

If you want to start very quickly with GWT, please go to this repo with samples and starters. You need maven and start your IDE 🚀.

Please give this project on Github star, it's actually very awesome to start quickly with GWT.

2021, 2022, ... ?

In June 2012, Google handed control to the steering committee, to make GWT more visible in the open source community.

Ok but we are already in 2021 and you can read on news or social media GWT is dead. They are right, GWT 2 is dead. But it means not that the framework is not more developed, it is heavily developed. The new approach uses a different compiler named J2CL by Google and the community makes GWT APIs J2CL compatible with version GWT 3.0.

The difference between J2Cl and the old compiler from GWT 2.* is that J2Cl is only a transpiler, which transpiles your Java code in Closure style JavaScript.

From a programming perspective it changes nothing, the APIs are ported further and you can develop further your web apps in Java. But the toolchain is slimmer.

Why Java in Frontend ?

We have frameworks like Vue, React or Svelte... 🚀🚀🚀

From my perspective developing web apps in Java must be evaluated before the project starts. The following points are very important to choose GWT.

• you are already an experienced Java dev

• you don't plan to use complex JavaScript frameworks dependency for your app

• BUT some Js Frameworks are ported to GWT 😃 google it like VueGWT but not the full specification of Vue

• you have a minimal CRUD app with simple UI components

If you break the requirements the code can be very challenging over time, there is also a JsInterop Specification from Google where you can bind any JS-Framework like VueJs in GWT, but it becomes very challenging in maintainability over a long time.

And why you must port it to Java ???? If you have an awesome Js-Framework 😃

But if you are an experienced oldschool Java dev and need a small web app with not too many fancy UI requirements go with GWT.

Conclusion

We read news about WASM and polyglot architectures for web apps in languages other than JavaScript like Elm. Maybe in some years also GWT becomes again popular under the top news.

But the lack of documentation, examples and small community makes it very difficult to switch to GWT. There are two awesome Gitter channels vertispan and gwt where GWT experts talk every day about problems and ideas please look if you are interested.

Please give me feedback if you use GWT in your projects

Happy coding 😃

This post is about the following AWS picture:

Ok ... We have here in the cloud parts of the picture the following AWS cloud components:

• Cloudformation - Infrastructure as Code service from AWS to deploy aws components

• S3 - object storage service, you can deploy here big data

• Cloudfront - CDN service from AWS

• Lambda - Serverless on AWS 🚀

• ....

The list can be around 200 services 😀

To deploy these AWS services you have many options. If you quickly test around you can use the AWS console. But if you want more reproducible architecture with CI/CD chain or deployments over stages with many accounts, in Cloud-Native development there are solutions named under the buzzword IaC (Infrastructure as Code).

IaC code creates your infrastructure which is composed of cloud services, like S3. The advantage is we can handle your infrastructure like source code 😀

Entering Cloudformation

Cloudformation is IaC service from AWS which accepts YML or JSON formatted files and deploys the described infrastructure from these files. Yes, Cloudformation is a setup as YML or JSON file 😀

For example, the following snippet describes an S3-Bucket (YML-formatted):

 MyS3Bucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Join
        - '-'
        - - !Ref S3BucketName
          - !Ref 'AWS::Region'

The problem with Cloudformation is, these YML or JSON files can be very complex for big cloud architectures. Refactoring can be a disaster, therefore over the years many IaC frameworks are developed, so we enter IaC Frameworks or abstractions over Cloudformation

• Terraform

• Pulumi

• CDK (from AWS)

• Serverless Framework

• SST

There are much more frameworks, every one with his strength and different paradigm.

All these frameworks produces in AWS as cloud provider, Cloudformation code except Terraform and Pulimi, which creates and deploys your services. Framworks like CDK, Serverless Framework or SST is only abstraction over Cloudformation, to make it easier to develop your infrastructure.

For example following SST-Snippet creates an S3-Bucket named Uploads.

let bucket = new sst.Bucket(this, "Uploads");

You see the difference, SST framework in this case uses another abstraction layer over CDK and has a programming paradigm for creating IaC 😀

Happy Coding 😀

Traveling around is one of my philosophy ...

I want suggest you a place on the Lycian Way in southwest of Turkey where you can stay very peacefully. The little village Çirali near Kemer in Antalya. Smell of flowers, birds flying and the mediterranean sea gives the village his very good vibes.

The village is also very interesting for digital nomads, you can stay in bungalows with garden and seafront view 😀 internet connections is well suited for devs

The village has a beatiful long beach, which is part of a protected area as it’s used by sea turtles to lay their eggs.

You can walk to the ancient ruins of Olympos and Chimaera, which is part of the Lycian Way.

Happy Coding 😀

I plan to write a series of blog posts about AWS container technologies. In this first article i blog about a quick intro and a high level overview of the services. In later posts I go deep dive in the services and show you some examples.

Happy Reading 😃

First Quick History

First the journey begins with Amazon Elastic Compute Cloud or EC2. EC2 are virtual machines where you can host your apps on AWS. You can think there is a machine hosted on Amazon's data centers across the globe and you can rent an environment where you can deploy your app.

The image below illustrates this scenario with 4 applications in one EC2-Machine.

This architecture implies that you must configure and install all your required packages and configurations for each app directly on the EC2 Instance. But there are many long automation processes involved:

• update your tomcat configuration

• need another system-wide package

• scale to 1000 EC2 Instances 😮

• ...

The list goes on, you must every time log in to your EC2 and update or patch these requirements and this is not a good development experience

But there is a solution for automation - DOCKER or containerized applications 😝

Automated Solution Docker

With the rise of Container tech especially Docker, the deployment and development of applications are more repeatable and automated. We can define our environments, packages and so on for each application in a central Dockerfile on our local machine and the deployment of our application environment is automated on each hosted machine on every deployment.

Entering Container Services for AWS

AWS offers two basic services for deploying containerized Applications on AWS

• Amazon Elastic Container Service

• Amazon Fargate

With ECS we have the concept of container technology. AWS defines the following building blocks in ECS

• Cluster

• Task definitions

• Tasks

• Services

Don't worry we go deeper in further posts to the building blocks mentioned. It's important first to understand at a high level what's going on and the philosophy behind them.

Introduce ECS

Bellow diagram illustrates the concepts at high-level architecture. We have further an EC2-Instance but this time we have an ECS-Agent installed on that EC2, which is responsible to manage the Docker-Container and register this as an AWS service. The execution of a Docker container in EC2-Instance is called a Task.

Summarize:

• Containerize the app (create Dockerfile)

• EC2-Instance with running ECS-Agent

• ECS-Agent manages dockerized apps as Tasks and registers it as AWS service

• Run dockerized App in EC2 as Task

** ECS-Agent **

The ECS-Agent registers our machine in a Cluster. This Cluster orchestrates our Tasks and Services.

** What if we need to scale up ?**

In order to handle the increased load we need to run more EC2-Instances with ECS-Agent installed.

AWS helps us to create EC2-Instances automatically with Auto-Scaling Service, but I go deeper with this building block in another post.

For this post, we create another EC2-Instance manually with ECS-Agent installed and deploy our dockerized apps on it. The Agent registers the EC2-Instance automatically at the Cluster Level.

First that all about ECS at a high level, I go deeper in further posts 😊

Introduce Fargate

Image your next application becomes very popular and your EC2-Instances hit heavy load from your users. You have no time to go down and won't scale up to 1000 EC2-Instances, this scenario is very cumbersome and buggy.

** From AWS Docs **

AWS Fargate is a serverless compute engine for containers that work with both Amazon Elastic Container Service (ECS) and Amazon Elastic Kubernetes Service (EKS). Fargate makes it easy for you to focus on building your applications. Fargate removes the need to provision and manage servers, lets you specify and pay for resources per application, and improves security through application isolation by design.

Ok ok, AWS mentions the buzzword Serverless 😂

Yesss this is amazing, Serverless is also explained in the above Quote from Amazon:

Fargate makes it easy for you to focus on building your applications. Fargate removes the need to provision and manage servers,

This is very amazing you don't need to create and manage EC2-Instances, create your dockerized applications, push them to Amazon and run it as Fargate Tasks. If you want to scale up you only increase the number of your running Tasks.

As you can see from the diagram above we have the building blocks from ECS, except Agent and EC2.

I prefer Fargate as AWS Service for building containerized applications on AWS, because I can focus on my business logic rather than infrastructure.

This article was only a high-level of introduction to AWS Container Ecosystem. In further posts, I go deeper with Fargate and the concepts behind the building blocks.

Happy coding and reading 🚀 ! Stay healthy