One thing hasn’t changed though: my passion for writing and culture and self-expression, I would even wager to say that I have improved as a writer these past couple of years since I published my book. I just didn’t write as much, I had other obligations and a lot of other projects to get through (that’s not saying I don’t have them now, I’ll always have something to do, I think) but now I found myself looking back at this blog and thinking to myself: why?

“Why?” has been a question I have been asking myself about a lot of things lately. I used to just do things for the sake of doing them (simpler times) but now there is a need within me for greater motivation as I have realized that often our actions carry a lot of responsibilities and consequences that we do not think of. Often, these are irrelevant or immaterial and we should have the ability to look past them, but when one begins to have constraints on one’s time while simultaneously developing passions and enthusiastic furor for many other things in life, one cannot help wonder … “why?”. Why is something worth my time? Why do I always do this and not that? Why have I ended up where I ended up?

These questions are haunting, and yet unlike ghosts they are tangible and their answers, even at the smallest scale, have a profound effect on one’s life. And in trying to resolve this blog, I landed on the question of “Why do I do this blog?” and the answer to me felt incomplete when I actually came up with it. In brief, the answer was:

• For when I feel the need to brag about something.

• For when I feel the need to promote something.

• For when I just want to write out my feelings (this use hasn’t been relevant for quite a while)

In coming up with these answers, I also came up with what was missing, and that wasn’t really motivation or enthusiasm, but investment. I was enthusiastic about ideas, even motivated to execute them, but I hadn’t applied myself well enough, nor had I invested the time and the subtle little tricks to make this publication the best that it can be. I hadn’t taken the responsibility I had for my own expression seriously.

And that finally brings us to this revamp. This is my blog. The blog of me. It’s why my name’s in the new title now. The blog is going to be different now. Though I am not a 100% sure in what way. There will be tech, but there will also be more. But more importantly, it will independently support the thoughts and creative expression of one individual: me.

You see dear reader, I feel a responsibility now to myself to create something that I can be proud of, that I can put up as a platform that shows not just career growth, or success, or serves as some sort of obligatory IT guy career tool, but is a genuine reflection of things I am enthusiastic about and is an independent expression of me, things that I do and see in my life and as many of my interests as I can fit on here.

It’s also going to be pretty damn entertaining.

So expect more from this blog (just as I expect more from myself now), I don’t know how, but I know soon.

And this is perfectly normal. During the numerous talks that I have given over the years (many of the at Google events, btw) I have scarcely had half the room raise their hands when I even asked them if the knew what Gemini was. So first, here’s a little context for you before we get to the meat of this blog.

Background

As with most Google products, Gemini and Antigravity have undergone a lot of transformations over the years, and please do not expect this diagram to be a fully accurate description of all that has happened in the last three years, just my perception and experience of it:

As you can see, it has been a long and winding road, even in the summary. And Antigravity as a concept ( a model and platform specifically designed for coding with all the add-ons that come with it) isn’t even a year old. Antigravity CLI is the successor to Gemini CLI which many people considered the best way to use the Gemini API, and honestly, it was. In my opinion, Antigravity CLI is a great successor and we’ll see why it and CLI tools in general should be used more by the general public (if they will or wont, we’ll see). The use case we will explore is similar to the one I used to make my timeline diagram above nicer, just a few more pieces.

Getting Started

Let’s not dwell on the setup for too long, let’s just list out what you will need to make this work:

• Any computer with a CLI (any sort of terminal whatsoever).

• A Google account (if you don’t have any AI Pro licenses or Google Cloud projects enabled they will train on your data)

You can find the installation instructions (which is literally one line) here

The Start

Here’s the repo (clever name, I know): https://github.com/ankurr0y/antigravity-cli-element-composer

It’s literally just a sample corporation, we’re not overcomplicating this, we’re going to let the AI figure out a lot of this.

In this exercise we will be using the CLI “raw” without asking about any skills, but I would highly recommend for many tasks to have specialized skills and I would also highly recommend this skills repository (very helpful): https://github.com/sickn33/agentic-awesome-skills

But again, we are going to let the CLI do the work now, so lets not even clone the repo, lets let the Antigravity CLI do it for you.

First type in agy in the command line of your choice:

You’ll get something similar to this if you’re configured with your Google account, otherwise do the step in the docs I presented to get there.

Now type the following command:

Clone this repo: https://github.com/ankurr0y/antigravity-cli-element-composer

You’ll begin getting prompts like this:

That’s because 1. it knows how to clone a repo and 2. it will ask you permission every time to run a command instead of running it itself. You can skip this if you just open Antigravity with this setting:

agy --dangerously-skip-permissions

But that’s at your own risk. And how you do it here is not important to the end result since, and here’s the kicker: your results will be completely different from mine, even with the same prompt. Especially on something like this, if its a result you can live with, that’s what you take with AI (and those are the use cases where you should use it).

The next prompt:

Make a presentation about Sample Co in powerpoint, 
use the company logo in the jpeg on every slide. Make the presentation as professional as possible

Now in my case, it wrote a script in Python to read from the doc and put it into a powerpoint. And it worked quite well, takes 10 seconds approximately if you’re using Gemini 3.5 Flash. It even created a transparent version of the company logo to use. But here’s the thing, something was wrong:

Cant have that in a slide. I can easily fix this, but lets let the AI have a crack at it, and in that spirit I uploaded this same screenshot into the folder and told it to improve on its design

Have posted a screenshot of a format mistake at iter1_error.png. Fix this formatting for all slides

So lets see what happened then:

Better than before, but lets give it one more go.

 I have now posted iter2_error.png for the next iteration, its better, but needs a little fixing

And this final iteration I was happy with! You can find it and the rest of the assets produced on the other branch (result) of the repo (the CLI pushed it).

Conclusion

This was perhaps not the most succinct way to describe the Antigravity CLI, nor the full showcase of its abilities (try it out on a bigger codebase or a larger creative project). But it does show off that it is a great tool to solve these minor problems for you. Now, of course you can say, why not just use the Claude or Gemini UIs? Well, those are on the Internet, you can run this locally, and with your repository or even you documents! And you may also say “isn’t iterating kind of time consumin?” to which I would say it consumes less time and significantly less of your energy than would have otherwise been put into the processing of this information. Now, of course, what’s written needs to be double-checked but that’s almost always the case.

I will say, for more critical things, this is not for critical things, this is for uncritical things that should be treated as such, not everything is at the same level of importance, and the more you can shut out the mundane the better (just make sure it is actually mundane). Or as our friends at the Sample Co Solutions company would say:

“Lower your standards. Embrace the boilerplate. Stop striving for the exceptional and sink comfortably into the warm, inviting embrace of the unremarkable.”

Often this is enough, do something cool with the time you save.

The Architecture

So here it is in it’s simplest form:

Quite easy to understand actually, world_agent builds and updates the world, npc_agent engages in dialogue, character_reader_agent reads the characters created by the character_manager_agent and updated by the character_creator_agent. This will create characters and then update them in a JSON document.

Let’s try a narrative

Here is some character creation:

Which shows up as a JSON for the character:

That can, again be updated by the update agent. Now, let’s spin a narrative for Herbert:

And voila, all the details of the character, which can be updated over time.

Conclusion

In conclusion, agents and ADK are great for these dynamic narratives, and they can be used to make narratives that are a bit more non-linear and ever changing than the ones a singular person could make. This is essentially creating a world that is only slightly nudged by you but created entirely in the mind of the agent. Fascinating stuff!

Here is the repository if you would like to check it out: https://github.com/ankurr0y/Self-building-RPG-maker/tree/main

Making these tools has been the biggest challenge for people historically, because even if they do it right once, it used to take a lot of different libraries to put it together, and then, of course, deploy it. Everyone had their own way, but that has been simplified now with ADK.

What’s an ADK?

ADK stands for Agent Development Kit. What is that? It’s a tool to develop agents. It simplifies the process to develop your first agent and has examples on how to develop agents in such a way as to reuse them in developing custom agents of your own. It also has a UI test environment and multiple ways to deploy your agent, including an Agent Egnine, Cloud Run and even Kubernetes. Basically, it can cover all the aspects of building an agent, from ideation to implementation and testing.

Initial setup

The initial setup for an ADK workload, even on your local machine is very simple. The AI part, however, does require that you have access either to Vertex AI or AI Studio. AI Studio, is the free option for development, with the ability to switch over to the paid AI Studio or Vertex AI for larger deployments.

The actual setup is not that difficult, you can do it from any command line, and you can serve it from any port. The quickstart will walk you through the process:

ADK quickstart setup

Agent workflow triggering

We are going to try out three different agent workflow examples, each showing a different way to orchestrate agents and tools.

Sequential

Multiple agents often need to work in a sequence in order to produce a refined result. In this example, we will use three agents in sequence to rewrite a short story based on criticism. And here is the code:

from google.adk.agents import LlmAgent, SequentialAgent

GEMINI_MODEL = "gemini-2.0-flash-001"

#Writer Agent
writer_agent = LlmAgent(
    name="WriterAgent",
    model=GEMINI_MODEL,
    instruction="""You are a story writer.
Based on the user's prompt, write a short story around 1000 words.
Output *only* the text from the story. 
""",
    description="Writes a short story based on user input.",
    output_key="story_text"
)

#Editor Agent
editor_agent = LlmAgent(
    name="EditorAgent",
    model=GEMINI_MODEL,
    instruction="""You are an experienced literary editor with a keen eye for storytelling.
Your task is to provide constructive feedback on the provided short story.

**Story to Review:**
{story_text}

**Review Criteria:**
1.  **Plot and Pacing:** Is the story engaging? Does the plot unfold at a good pace? Are there any plot holes or inconsistencies?
2.  **Character Development:** Are the characters compelling and believable? Are their motivations clear and consistent?
3.  **Prose and Style:** Is the writing clear, vivid, and evocative? Are there issues with grammar, spelling, or punctuation?
4.  **Dialogue:** Does the dialogue sound natural for the characters? Does it effectively reveal character and advance the plot?
5.  **Theme and Tone:** Is there a central theme? Is the tone consistent and effective for the story being told?

**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement, offering specific examples from the text where possible.
If the story is excellent and requires no major changes, simply state: "An excellent story with no major issues found."
Output *only* the review comments or the "no major issues" statement.

""",
    description="Edits the story and provides feedback",
    output_key="review_comments",
)

#Rewriter Agent
rewriter_agent = LlmAgent(
    name="RewriterAgent",
    model=GEMINI_MODEL,
    instruction="""You are a creative writing AI.
Your goal is to improve the given short story based on the provided editorial comments.

**Original Story:**
{story_text}

**Editorial Comments:**
{review_comments}

**Task:**
Carefully apply the suggestions from the comments to rewrite the original story.
If the comments state "An excellent story with no major issues found," return the original story unchanged.
Preserve the core plot and characters while improving the prose, pacing, and dialogue as suggested.

**Output:**
Output *only* the final, rewritten story.
Do not add any other text before or after the story.

""",
    description="Rewritten story based on feedback",
    output_key="rewritten_story",
)

writing_process_agent = SequentialAgent(
    name="WritingProcessAgent",
    sub_agents=[writer_agent, editor_agent, rewriter_agent],
    description="Executes a sequence of writing, editing, and rewriting.",
)

root_agent = writing_process_agent

The code executes in the form of writer→editor→rewriter. And here’s an example of the criticism it produces:

And when you feed that edited story back into the editor agent:

So, it sticks to it’s guns! Excellent. But what happens when you try to execute multiple agents at the same time?

Parallel

This example will show an agent running two other agents (for a topic and against) and then passing that information to another agent in order to produce a summary.

Here is the code for the agent:

from google.adk.agents import LlmAgent, ParallelAgent, SequentialAgent

GEMINI_MODEL = "gemini-2.0-flash-001"

#For Agent
for_agent = LlmAgent(
    name="ForAgent",
    model=GEMINI_MODEL,
    instruction="""You are very in favor of the topic suggested.
Based on the user's prompt, write a paragraph that is in favor of the topic.
Output *only* the text. 
""",
    description="Writes a text in favor of the topic.",
    output_key="for_text"
)

#Against Agent
against_agent = LlmAgent(
    name="AgainstAgent",
    model=GEMINI_MODEL,
    instruction="""You are very against of the topic suggested.
Based on the user's prompt, write a paragraph that is against the topic.
Output *only* the text. 
""",
    description="Writes a text against the topic.",
    output_key="against_text"
)

parallel_argument_agent = ParallelAgent(
     name="ParallelArgumentAgent",
     sub_agents=[for_agent, against_agent],
     description="Runs multiple agents in parallel to gather information."
 )

#Compilation Agent
compilation_agent = LlmAgent(
    name="CompilationAgent",
    model=GEMINI_MODEL,
    instruction="""
    Compile the information from {for_text} and {against_text} and compare the two.
 Produce a neutral conclusion along with a summary of what each text discusses.
""",
    description="Produces a comparison of for and against texts.",
    output_key="compilation",
)

display_agent = SequentialAgent(
    name="DisplayAgent",
    sub_agents=[parallel_argument_agent, compilation_agent],
    description="Produces a final display of comparisons",
)

root_agent = display_agent

And it works quite well. The topic I gave it was tea, and here is the result:

Good work, exactly what you’d want. And since there is no influence in between the two for and against, it creates very good reportage.

Loop

Loop are meant to automate in a way in which you can do one tedious task as many times as you need to as long as its consistent. You know what’s tedious? Writing more code, so we’re going to recycle our sequential code for this one, putting the editor and rewriter in a loop after initial story writing.

from google.adk.agents import LlmAgent, SequentialAgent, LoopAgent

GEMINI_MODEL = "gemini-2.0-flash-001"

#Writer Agent
writer_agent = LlmAgent(
    name="WriterAgent",
    model=GEMINI_MODEL,
    instruction="""You are a story writer.
Based on the user's prompt, write a short story around 1000 words.
Output *only* the text from the story. 
""",
    description="Writes a short story based on user input.",
    output_key="story_text"
)

#Editor Agent
editor_agent = LlmAgent(
    name="EditorAgent",
    model=GEMINI_MODEL,
    instruction="""You are an experienced literary editor with a keen eye for storytelling.
Your task is to provide constructive feedback on the provided short story.

**Story to Review:**
{story_text}

**Review Criteria:**
1.  **Plot and Pacing:** Is the story engaging? Does the plot unfold at a good pace? Are there any plot holes or inconsistencies?
2.  **Character Development:** Are the characters compelling and believable? Are their motivations clear and consistent?
3.  **Prose and Style:** Is the writing clear, vivid, and evocative? Are there issues with grammar, spelling, or punctuation?
4.  **Dialogue:** Does the dialogue sound natural for the characters? Does it effectively reveal character and advance the plot?
5.  **Theme and Tone:** Is there a central theme? Is the tone consistent and effective for the story being told?

**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement, offering specific examples from the text where possible.
If the story is excellent and requires no major changes, simply state: "An excellent story with no major issues found."
Output *only* the review comments or the "no major issues" statement.

""",
    description="Edits the story and provides feedback",
    output_key="review_comments",
)

#Rewriter Agent
rewriter_agent = LlmAgent(
    name="RewriterAgent",
    model=GEMINI_MODEL,
    instruction="""You are a creative writing AI.
Your goal is to improve the given short story based on the provided editorial comments.

**Original Story:**
{story_text}

**Editorial Comments:**
{review_comments}

**Task:**
Carefully apply the suggestions from the comments to rewrite the original story.
If the comments state "An excellent story with no major issues found," return the original story unchanged.
Preserve the core plot and characters while improving the prose, pacing, and dialogue as suggested.

**Output:**
Output *only* the final, rewritten story.
Do not add any other text before or after the story.

""",
    description="Rewritten story based on feedback",
    output_key="story_text",
)

editor_loop_agent = LoopAgent(name="RefinementLoop",
    sub_agents=[
        editor_agent,
        rewriter_agent,
    ],
    max_iterations=5
)


writing_process_agent = SequentialAgent(
    name="WritingProcessAgent",
    sub_agents=[writer_agent, editor_loop_agent],
    description="Executes a sequence of writing, editing, and rewriting.",
)

root_agent = writing_process_agent

You can see the code loop running on the request and response loop for criticizing the story:

For future improvements, an exit condition for the loop is recommended.

In conclusion, lots of fun ways to start your ADK journey. But don’t take my word for it, try it out yourself.

Krävs före starta

• En Google Cloud konto med ett projekt med Vertex AI API: er aktiverade

• En instans av gcloud command line tool (funkar i CloudShell)

• Tillgång till någon typ av Jupyter notebook (Colab, Colab Enterprise, så vidare) med google-cloud-aiplatform installerat

Initiera och importera libraries

Skriv funktioner för addition och multiplikation och beskriv dem för AI-användning

Väldigt enkel, Programming 101 och 102.

Efter, lägg dem till Tool library.

Initiera AI-modell

Ni kan ge det instruktioner så är det nästan till svar att du vill. Och skriva en funktion för extrakt.

Händla prompt

def handle_response(response):
    if response.candidates[0].function_calls:
        function_call = response.candidates[0].function_calls[0]
        print(function_call)
    else:
        print(response.text)
        return

    if function_call.name == "add":
        arguments = dict(function_call.args)
        sum_of = add_two(arguments['a'],arguments['b'])
        response = chat.send_message( Part.from_function_response(
                name="handle_response",
                response={
                    "content": function_call.args,
                },
            ),
        )
        return handle_response(response)

    elif function_call.name == "multiply":
        arguments = dict(function_call.args)
        product_of = multiply_two(arguments['a'],arguments['b'])
        response = chat.send_message( Part.from_function_response(
                name="handle_response",
                response={
                    "content": function_call.args,
                },
            ),
        )
        return handle_response(response)

    else:
        print(function_call)

Det ska hjälpa oss att sortera mellan addition och multiplikation.

Exempelsvar

Det kan fattar kontext.

Det kan fattar gemensam språk.

I don’t think there is some great insight that ties the whole of this year together for me, nor is there some sort of great goal in the future that I can look at and think “This is what I want, its what I will work towards.”, one thing I’ve come to realize in this year is that maybe I’ve never had that. And that maybe I’m better off for it, because while it does convey a distinct lack of focus (something I’ve always struggled with), the opportunities it provides and has already provided have made me look at my life in a different perspective.

I could go on and on about how my perspective, my life and many other things have changed over the course of the year, I could write many texts on the subject, but I’m going to limit myself to a few career highlights and a couple of personal insights.

Book

This was a big thing for me from the middle of 2023 to early 2024. My first book! I was so excited. Still am, still jazzed, but the months and perspective have set in and in my mind, the writing of the book wasn’t just a great career highlight, it was also a great journey of self-discovery, it was a journey that permanently reinforced and set my skills and my confidence in them, and I will always be grateful to it for that.

GDE, DevFests and travel

I became a Google Developer Expert (and a Champion Innovator, but that came with the GDE) in Cloud. This, honestly, has been the opportunity of a lifetime. I have gotten opportunities to travel, to network and most importantly to share my knowledge on public forums and grow my platform and learn from others as well.

This year, according to my rough estimates, I have traveled 53398.29 kilometers by planes and rail (not counting other vehicles, and counting 19000 km of travel between Uppsala and Stockholm over the year since its a 128km round trip) and I can honestly say: I’m tired. It is quite exhausting to travel that much. However, it was incredibly rewarding, so I can’t complain. Here a link to my travels on the map app.

Many other career highs

Its a lot to take in, this last year, like I said, its felt like many years in one. But there are a few things that I am really proud of that I can only express in bullet points without turning this blog into a memoir or something:

• I did a mentorship program in AWS for a cohort of students in Nepal, it was great, met some great people with a bright future in the Nepal IT industry.

• A book that I was the technical reviewer for (on data governance) was also published.

• Online Partner as a company became a Great Place To Work certified company. It was my first full year there, so I’m really happy we accomplished that!

And of course, there were projects that I am proud of, teams that I was happy to be in and friends made along the way, but that is a list that could take a life of its own.

My takeaway

This year has been a ride. Its been the best, most successful year of my life and the year that I finally “made it” in a way. A feeling disappeared over the course of the year, the feeling of inadequacy, the feeling that I hadn’t done anything with my life. Its completely gone. I have truly become successful at most things you are supposed to be successful at in life.

At the same time, I feel excited for newer challenges, challenges that provide the energy and drive to live life. This combined with a better understanding of myself as a person has brought me close to peace, not quiet, but a loud peace, a peace that rings and echoes and keeps you engaged and present. Doesn’t mean there are no difficulties, just that there is always the strength to face them.

My 2025

Oof, thinking about it, I have about 30 days worth of stuff set aside already for the year. And that has sort of been the challenge, having all my activities sorted and scheduled. But what I have learned is that one year is a very long time, with a lot of time to do the things that you want. So, I wont bother worrying about this.

What I will commit to is becoming more well-rounded. I have become successful, well-traveled, settled and educated, but now I need to grow into my own skin in a way. So that is going to be the goal of 2025, becoming more well-rounded, just better at living life. I’ve had a few exciting years the past few, I think a quiet reflective year this year is going to suit me.

<!DOCTYPE html>
<html>
<head>
    <title>Din vänlig lokal AI</title>
    <script>
        async function localFetch() {
            const promptInput = document.getElementById('promptInput').value; 
            const { available, defaultTemperature, defaultTopK, maxTopK } = await ai.assistant.capabilities();
            if (available !== "no") {
                const session = await ai.assistant.create();
                const resultDiv = document.getElementById('result');
                resultDiv.innerHTML = '';
                const result = await session.prompt(promptInput);
                let hasDisplayedResults = false;
                if (!hasDisplayedResults) {
                    resultDiv.innerHTML = result; 
                    hasDisplayedResults = true; 
                } else {
                    resultDiv.innerHTML += result;
                }
            }
        }
        document.addEventListener('DOMContentLoaded', function () {
            const promptInput = document.getElementById('promptInput');
            promptInput.addEventListener('keypress', function (event) {
                if (event.key === 'Enter') {
                    localFetch();
                }
            });
        });
    </script>
</head>
<body>
    <label for="promptInput">Ange din prompt:</label>
    <input type="text" id="promptInput" placeholder="Skriv din prompt här">
    <button onclick="localFetch()">Hämta poesi</button>
    <div id="result"></div>
</body>
</html>

I klassisk och enkel HTML och JavaScript, vad kul. Om du använd det, du kan ringt en lokal API för Gemini Nano vilken du kan använda i Google Chrome. Du måste ladda ned Gemini Nano förste i Chrome (du kan följ den här guide). Men efter, du kan helt enkelt använd en HTML dokument med koden från ovan och ditt resultera ser ut som det:

Och nu du kan följ trenden av “gaslighting AI” också!

Men om en allvarlig anteckning, om du vill skydda dina studenters data och också tillåta de att använda och forska med AI, en lokal, mini-AI är en välj att du kan leta efter i en snabb och enkel väg.

Testing is important, but it is merely one layer in a multi-layered approach that should be applied to applications on scale to ensure that something like Crowdstrike never happens. The layer we’re going to talk about today is feature flags. Now I have gone into even greater detail on the topic in my book (insert shameless plug here), but in this blog we can look at it through the eyes of a service that I initially learned the technique through: AWS Load Balancer.

What is a load balancer?

A load balancer essentially distributes web traffic between multiple different targets based on certain criterion. It could, for example, be the connection protocol (HTTP, HTTPS), location, cookies and many other factors. The motives behind it can be different as well (like with out case of feature flags) but the primary goal is the proper distribution of web traffic.

I discovered load balancer when I was a developer and DevOps guy as just a tool to be used to make sure your servers receive a balanced amount of traffic and that no server is overloaded. But, I discovered all of the other applications as well, including testing ones like A/B testing. However, the use of feature flags was the thing that really caught my eye. It was so simple, yet so ingenious, really.

Feature flags with a load balancer

I’ll just start by stating that this is probably the simplest way to create a feature flag, and probably not the most efficient. But, I wanted to showcase it, because it is a good way to get to know how feature flags operate. Here’s the scenario:

• There are two different forms of an application: one is for secure usage (HTTPS) and another is for non-secure usage (HTTP).

• These applications must redirect to different target groups based on the HTTP and HTTPS criteria.

In the AWS Console, go to AWS Load Balancer and from the Create Load Balancer button dropdown and select Application Load Balancer.

Give the load balancer a name, and keep all the remaining settings the same until Listeners and routing. You’ll need two different target groups to route to. They can be empty.

The default has an HTTP route with an open 80 port which we can configure to have a target group like so:

Then you can add the HTTPS listener and the appropriate target group.

Keep everything else the same, they’re important, but not needed for this little exercise. Click the final button to create the load balancer.

Conclusion

The final load balancer will now route users based on the protocol they use to access the endpoint. You can see a resource map that looks something like this under Resource Map → Overview:

It shows diagrammatically the routing of the resources based on protocols. And that’s what feature flags are. Really, its that simple. But it is quite effective. Try it out.

homeexchange.com and its GuestPoints system

Here’s how it works. You go to the website and you tell someone, “I would like to exchange house keys with you, please.” You agree on the dates and the basic rules and stuff and you’re good to go. There’s ways, of course, to make sure that you are on your best behavior with someone else’s property. There are ratings that you get by the owner of the apartment regarding how well you took care of their apartment. You essentially depend on the respectfulness of strangers, but it turns out that this is a powerful force. Additionally, the temptation of a free vacation home does keep people in check. Really fascinating stuff.

But, there are ways other than a direct exchange by which you can get properties, and this is where the GuestPoints system comes in. Every day that someone stays in your home, you get a certain amount of GuestPoints and at some point, you can exchange your GuestPoints for stays at places instead of exchanging homes. You still have to be on your best behavior because the home owners can reject your offer, but that gives you the ability to rent out your home without taking one in return and vice versa. The points system further rewards good behavior since the better you’re rated, the more likely you are to get a home you want with your points.

But that left me with the question: “What made this so effective?”. And I realized the scenarios where this is effective and when it isn’t. Let’s explore that.

C2C vs B2C or B2B systems for points

In short, points as a primary system works perfectly when it is used on a platform between individual customers (Consumers to Consumers or C2C). It’s basically a more advanced form of cavemen from different tribes bartering for goods. A handshake deal, except now there is a ledger that makes sure it is known if you don’t keep your end of the deal. This works because of the same reason social media works: likes create visibility and other benefits.

However, the reason this does not work with businesses is that businesses require collateral or the exchange of assets. Basically, to get something from a business, you must give them something that they can then use in another trade, like money. An asset can be bought and sold between businesses and consumers over and over again, sometimes even bought with a different type of currency like reward points, but that is the cycle that those assets are in. This system is not possible with home exchange because the currency you are trading with each other is essentially your reputation, and you can’t just let anyone else use that, that never benefits you.

In conclusion. when designing an application where you want people to behave with each other or at least not be mean to each other, use points as a reward, or bans as a punishment like Discord does. For any venture that is larger or more complex, use money.

In many cases, a live updating data source is unnecessary, with a snapshot of the data in a certain state being preferred. For example, if you wanted a chart that had all of the sales data upto the 8th of July, but you still needed to update the sheet for subsequent sales, you’d need to make a separate data operations location for the data upto the 8th. This is where a little data connector called Extract Data comes in handy.

For today’s demonstration we will use this public sheet which contains all of the data from the 2023-24 NFL season (I really like NFL football, go Texans). We will import and refine the dataset and then create a Extract Data from it.

Extact Sheet Data

Go to lookerstudio.google.com and create a new Data source.

You will be presented with a number of data source options. The two relevant ones for this are Google Sheets and Extract Data.

Click on Google Sheets first and in the URL for the Select Connector option add the URL of the Google Sheet from before. You’ll get something like this:

Change nothing else here. On the top right, you’ll see a Connect button, click on it to connect to and read this public sheet’s data. You’ll see data like this:

We have 30 dimensions and most of them will be irrelevant to our diagram in Looker Studio, so we’ll remove them in Extract Data. For now, lets keep everything. In Looker Studio, we’ll find a data source with the name of the sheet that we took the data from.

Use Extract Data

Now, lets create a data source again, this time choosing Extract Data. Your data source will be in a list of selectable data sources. Select it.

For simplicity, add Game Winner, Game Loser, Home Team and Away Team as the Dimensions to be extracted, that is all we’ll use. Click Save and Extract on the right. Then, click Create Report on the top right of your screen.

This will create Looker Studio view with a pre-populated table like so:

Very clear, concise, and useful. This is great for data that needs to remain static, or data that you know will not be updated. This is, of course, the simplest of methods and functions, but you can get as complex with it as your imagination allows. You can use Extract Data on other data sources as well as long as they can be extracted to Looker Studio.

Final draft

But, in short, a lot of the work involved the correction of grammatical errors and spelling errors by copywriters (and with how I write, I leave a few of those behind), finishing up all of the reviews from the technical reviewers, and approving the general layout for the book. After achieving all of this, the only thing left was to wait a few weeks for the release. However, the journey with this book didn’t end there.

Post-publishing

When a book is published, its just that moment, one second it is unpublished and the next it is published. I loved the feeling of having a published book, but now I lived in a world where the book had already been published. So, I had to get to work, promoting the book and asking some of my contacts to review it. That work continues to this day, but the biggest thing it did for me was that it gave me insight into the process of how to take a product that you can call your own and distribute it to people who want it.

After the book was published, I got a lot of messages from people telling me that they had really liked the book and that they were using it for some of their work-related tasks. That gave me a sense of accomplishment that was very unique in terms of feeling (I cannot describe it, I just know I hadn’t felt it before). But it also made me very grateful for the network of people involved in the publication of the book and the network that I had who were willing to review it.

The overall reception for the book itself has been great. It has been so good, that I have now started writing another one! It will take us a while, this one will be a longer publication, but I am excited. And that is why I am leaving you with this one concluding thought: Write. Seriously, writing helps with a lot of things, not just professionally, but personally, emotionally, its a great outlet and a great way to keep yourself focused. I recommend it.

I decided to read through the book with an open mind: the mind of someone who hadn’t ever seriously considered the topic of security in AWS or was a novice in the field and wanted to improve themselves in this regard. And I must say, for someone like that, this book is a perfect escalation from the most basic of security concepts into advanced security strategies with explanations on how to implement them included.

The book itself is divided into three sections, the first of which deals with AWS’ security model, security services and other basic concepts, setting the foundation for security-based learning. The next section deals with deploying actual workloads in AWS that follow these practices and the book has quite a few examples on how to implement everything you learn in a pragmatic approach that can be copied over into any workload the reader may be thinking about implementing. The final section deals with the maintenance, update and automation of security practices and features which provides faster threat response times and easier threat detection. An excellent layout with great content.

I whole-heartedly recommend this book. It is an excellent read for people who want to have a guide for their AWS Security journey. I believe that if you really want to learn about security in AWS, this book would be a good investment.

Introduction

If you are a software developer or, at least, someone who likes to write code, you can more than likely find the way to install and use BigQuery in your programming language right here. I’m not bogging you down with these details, this is going to be a short blog. All you need to run a BigQuery API (as I will in Python) is the query that you are about to run and a few lines of code.

Code

Let’s reuse the code that we used for the “Select All” query from the very first blog. Simply put that query in the query slot and you’ll receive the exact same result.

from google.cloud import bigquery

client = bigquery.Client()

query = """
    SELECT * FROM `bigquery-public-data.google_trends.top_terms` LIMIT 1000
"""
rows = client.query_and_wait(query) .

print("The query data:")
for row in rows:
    print(row)

And that’s what you get. You may manipulate the data in any way you like. This can be useful for things like custom machine learning algorithms and training said algorithms (though you may find there are easier ways to do this in BigQuery itself).

Conclusion

SDKs are useful for a lot of things. Not just in BigQuery, but with most services. The use case for them in BigQuery in particular depends on your creativity. Big, useful concepts like IaC were born from people using this kind of thinking. So, to conclude, I would like to encourage you to be creative and start from a blank canvas. More pearls of wisdom next time.

So, the first draft, that all-important initial completion of your book. That feeling of, “Okay, I said that I’m gonna do this thing and I did the thing”. Now getting to this point when you have all the things that you want to write already planned out and ready should be a piece of cake, right? Well, that is just not the case.

Like I have said before, it has been a difficult journey writing this book. Perhaps difficult is not the word, challenging is a better description. The challenge that I faced was that I was doing all of this while moving to a new country, finding a new job, going through all my grad school stuff and essentially starting a new chapter in my life (I cover some of it in the book). But these weren’t the only challenges. We’re going to take a close look at the process of writing each chapter and how I had to manage the whole writing process and juggle my entire life at the same time.

The chapter-by-chapter process

Here’s how writing a chapter works when you’re writing a technical book:

• Submit initial chapter draft.

• Have it looked through by the editor. They will judge the flow of the chapter and try to make it better (this was really helpful).

• Submit the review corrections, if there is something that hasn’t been addressed, it will come back to you and you keep doing this until all the comments have been addressed.

• The draft is then submitted for technical review where a couple of your peers will look through it and give their opinions in a questionnaire.

• You then get all this information and make corrections where necessary.

• Then a final edit by copy editing people.

• Then a final print version is created with graphics and all the bells and whistles.

So that’s how we do that. And you’ll notice that I have used bullet points here. That’s an effective technique for technical books in terms of dividing information. Pro tip. But this is the technical aspect of my techno-philosophical book. So you may be wondering about the human aspect, the aspect of me. Well that’s what I’m going to tell you.

(My editor encouraged these little paragraph ending sentences, as he said they helped transition topics very well. He was right, it made the writing flow incredibly well, made me a better writer.)

The author’s journey

This book project has been on the same journey as me. It came from Nepal to Sweden with me and I have written it through the vast changes in my life that occured during my time writing it. For a while, it was the most consistent thing in my life. And mentality-wise, having that consistent thread when you are essentially starting a new life was very important to me in my initial months here in Sweden. In a way the book helped me settle down. It was an interesting topic to be brought up in conversation as well, which helped break a lot of ice.

I wrote much of the book indoors during the harsh Swedish winter when temperatures could get as low as -30 degrees Celsius. I think the journey of writing the book itself and all of the challenges that came about, all of the changes I had to make on the original vision, all of the things that I had to change in collaboration, helped make me a better author and a more determined person. In doing so, I made a great many connections and I re-enforced what I believed and what I wanted to share with the world.

Conclusion

We’re in the final stretch folks. I haven’t gone into the technical details of the book, because if you want those: read the book. But I hope this blog has helped you understand the technique and the human side behind the book writing process. The final part of this blog series will focus on the final stretch of the writing process and everything that came out of it.

The crux of the CLI commands for BigQuery is the BigQuery command line tool bq which is used to execute BogQuery commands from the command line. Another big piece of this is the Cloud Shell environment in GCP which gives you a terminal with the command line tools pre-installed in the GCP UI. So let’s dive into the tool and a few simple operations we can do with it.

The bq CLI tool

The bq command line tool is part of the gcloud set of command line tools. Why is it not the same starting command as the rest of Google Cloud? No clue. But it makes the specific documentation for BigQuery easy to look for. You can find the reference page here.

Installing the tool is a matter of finding a way to install gcloud on your favorite command line. But, the Cloud Shell in GCP comes pre-installed with these tools and pre-configured with the project that you are using. Quite convenient. So that is where we are going to start.

Basic Commands

We’ll take a look at a few basic commands to get you started. Not much else, just a few commands.

Read all datasets

The following command reads and lists out the BigQuery datasets:

bq ls

And there is the BigQuery dataset we created in the last blog. Now, lets create one for this blog.

Create a dataset

Now, we will use the CLI tool to create a new dataset:

bq --location=US mk -d \
    --description "From the command line." \
    bigbigsmallsmallqueryquery

Yes, I know my naming convention is silly, but it entertains me. And you get this:

Now for the final basic act, we’re going to import some CSV data into the dataset.

Import data

This will import data from a file into a BigQuery table of your choice in a dataset. For example:

 bq insert bigbigsmallsmallqueryquery.<TABLE_NAME> <FILE_NAME>.csv

This will create a table of whatever you name it with whatever the name of the CSV you just inserted in there is. But make sure, its an actual CSV.

Conclusion

The CLI tool is pretty neat. And you can pretty much do all of the stuff you want in BigQuery, so if you would like to deep dive into it yourself, I’d say the documentation is quite thorough. The next blog will involve the use of SDKs for the same function.

But, getting a little more serious (and I mean a little), the experience of writing a book has been quite interesting for me. It has helped me grow as a person and has fulfilled a great ambition that I held in my life. It has taught me how to manage my time, how to adapt to situations, how to better receive feedback and many other things. It has been as much a journey of learning as it has been of sharing my own knowledge.

But share my knowledge I did, and in doing so I discovered the world and something about myself as well. I was challenged creatively, temporally and mentally at times. But the end product is something I can be proud of.

But before I get to the end, I must go to the beginning. I will - in this blog - show you the start of my journey into the world of authorship and give you some insight on how we got to this point.

How do you know what to write and how to write it?

Short answer is: I didn’t. I knew I had a lot of knowledge, I knew I had a lot of things to say, I also knew that I wanted to write. That’s all I knew. That’s all I had planned. If anyone tells you otherwise about endeavors such as this, that they had it all planned out from the beginning to the end: they are lying. That is not how this works.

It works like this: you have a vague idea of what you want to do and then you adapt yourself to the rest. That’s what happened with this book. My publisher, Packt, and I discussed several book ideas before we landed on one that worked for both of us. And honestly, it was for the best. A lot of my initial book ideas probably wouldn’t have resulted in as good a product as we got.

I contacted my publisher through a different book that they had published which had a link on it for where to go to apply to be an author. In fact, here it is: authors.packtpub.com , go ahead, give it your best shot. They contacted me a few days later and that’s where we began.

What it means to write a book

What it means is that it’s a lot of work. That’s even before the writing starts. Before you write a technical book, you need to have a gameplan on what you will be writing. It may not full reflect the final product that you produce, but it needs to be something you can follow in your writing. Then, of course, you have your team which includes: the project manager, the editor, the technical reviewers, proofreaders and the marketing team. All of them were integral in getting the book to where it is now.

It’s a team effort and it was great working in that team. But that required respect and an understanding from everyone of the deadlines for the book and the agreed contract for the book. Like I said, its a lot of effort. But this was only the beginning.

Getting started

I had a tough time ironing out the first chapter and what it had to say about the overall book, but that was probably the most fun I had had writing something up to that point. It was something that was completely mine and also something that would be reviewed and seen by professionals and serious people in general. So naturally, it is full of jokes and insider references.

But that first chapter set the tone in how I would work on the book along with everyone on the project and it helped us get into the groove regarding how we wanted to proceed with Python in DevOps. It still wasn’t smooth sailing from there though, there are always obstacles, but we will discuss them and how they made the book better later.

Conclusion

It is said that during an opening in chess, you have to be a robot. Do the right things that you have done thousands of times before in order to put yourself in the position to win. And that does apply to writing as well. Figuring out your team, setting the tone, all of this helps. But that doesn’t stop the challenges from coming and come they did. I will discuss the middle in the next installment of this blog.

I’m going to do a three article mini-series within this article series to describe the methods of interaction with BigQuery. Namely, the three primary ways one performs actions on BigQuery: UI (User Interface), CLI (Command Line Interface) and SDKs (Software Development Kits). We’ll start with the UI in this article.

The User Interface for any cloud is probably the part of the cloud that has the least thought put into it (barring some exceptions). They’re all meant to be bare bones, simple, to the point, some might even say ugly. That is because most of the work in the cloud is done under the surface, through API calls to servers and such. But that doesn’t mean that the UI is useless, nor does it mean that it should be ignored. Especially in a data service like BigQuery, where the visualization of data can play such a significant role.

The BigQuery console

The console is meant to replicate similar UI consoles that you would have in a database software like SQL Workbench. It brings familiarity with people who have used such consoles in the past. Let’s start with the most basic operation, which would be creating a dataset ( a task that is probably the easiest in this interface).

Creating a dataset

Hit those three dots and click the button to create the dataset. Give it a recognizable name and create your empty dataset.

You will then see the details of the dataset along with permissions, the option to create a table, and the option to copy and delete the dataset if needed. It’s overwhelming, I know. That’s why this blog series is going to be massive.

Let us now create a table. There are literally a thousand different iterations on how you can do it. I will do it with a fairly simple use case: the CSV import. It is a favorite of data scientists.

And there is another massive block of information. I’ve simplified it and used a mock CSV that I had along with an auto-detect for schemas (useful if you’re not a control freak). We then get the details of the table, I’ve put it on the preview tab to show how it displays the data:

And … that’s it. That’s it for creating a simple table for now. But when we get back to the UI, there will be more. But for now, this is the first step. This is a little abrupt, but, again, think of this as just a drop in the ocean.

But, putting all that aside, let’s have a more concrete picture of what BigQuery is. BigQuery is a top of the line data warehousing and querying service which is queried and functions using an SQL-based language. You can query and import just about any form of structured or sem-structured data into BogQuery that you would want. You can do it with practically every service in the Google ecosystem and most services in data hungry ecosystems like Microsoft, Oracle, AWS and all other platforms that hold data.

BigQuery can act as a centralized repository system for your data, a storage system for archival data that may need to quickly be queried and even a way to create machine learning models from your data. And all of that will come with time, but for now we will attempt the most basic of BigQuery operations: reading data.

Before we begin, you should have a Google Cloud account with a project created with it. You should also have the BigQuery API enabled on that project. All of that is free, it just needs a card to activate.

A simple walk to a SELECT * call

First off, SELECT * is usually a bad idea. That’s not what you’re supposed to do, you just do it because you’re lazy. That being said, I am a bit lethargic. But I will give the steps for a simple, sustainable SELECT * call just to take a look at it.

The first question would be: how do you get to the console? You can use the panel to the left that has BigQuery on it. But, if you’re in the landing page of a project, just look right in front of you:

They push it as one of their Big 4 services on Google Cloud, if you will. So, when you click on the button that says BigQuery, you get to the console:

Let’s let the console hold our hand for now. Let’s use that Google Trends Demo Query that is so prominently displayed and click OPEN THIS QUERY. Which will open a tab with this query:

-- This query shows a list of the daily top Google Search terms.
SELECT
   refresh_date AS Day,
   term AS Top_Term,
       -- These search terms are in the top 25 in the US each day.
   rank,
FROM `bigquery-public-data.google_trends.top_terms`
WHERE
   rank = 1
       -- Choose only the top term each day.
   AND refresh_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 2 WEEK)
       -- Filter to the last 2 weeks.
GROUP BY Day, Top_Term, rank
ORDER BY Day DESC
   -- Show the days in reverse chronological order.

A great query, with all the spice and mustard you could ask for. Also descriptive comments. If you want to write a query, this one is a great example. But I did promise you a SELECT * didn’t I?

In the explorer bar of the table, hit the three dots and select the Query option.

Let’s now see what that query is:

And if you can’t see that:

SELECT FROM `bigquery-public-data.google_trends.top_terms` WHERE refresh_date = "2024-03-26" LIMIT 1000

Just take out the WHERE and bring in the * and we get:

Beautiful, that’s what we wanted. And that LIMIT keeps it in check. Awesome, right?

What’s Next?

This was just the beginning. As you saw with all those fancy buttons and tabs, there is a thousand things to do in BigQuery and we will attempt to do most of them in this blog series. UI, CLI, API, FBI, whatever way you want to we will figure this out. With that being said, explore some stuff yourself, it is incredibly fascinating in its depth.

API calls

This is how most API calls happen, you call an API that you want information from. This happens across networks and within a program or operating system too. “You” can be you, the user or whatever scripts have been written in whatever program. This is the same concept from the lowest to the highest levels of scripting.

However, at the highest level, a new concept has emerged based on the event of the API being called itself.

APIs on APIs on APIs (Webhooks)

Let us consider what an event is in this context. An event is an API being called or triggered. When that occurs, something happens behind the API that logs that such a call has occurred and what exactly has been called. That log can also trigger an event, which can then be used to trigger another API if it can reach that API. And that’s pretty much how it works.

And diagrammatically here, you can already see an advantage of webhooks. If you are collecting data or events from multiple sources, you can set up multiple webhooks on one API and handle them that way. The other advantage is, as I mentioned, the reverse flow. If you need something to call your API instead of you having to call that API you can easily achieve this with webhooks.

Small example case

We’re now going to look at the webhook for the project management app ClickUp. The API call to use the webhook looks like this:

{

"endpoint": "https://yourdomain.com/webhook",

"events": [

"taskCreated",

"taskUpdated",….

],

"space_id": 1234,

"folder_id": 5678,

"list_id": 9876,

"task_id": "abc1234"

}

The endpoint is the API that the webhook will call, and the events are the events that will trigger the webhook to call that event and the other IDs specify locations. You need the API key for ClickUp to make this call, but that is easily found and the documentation (found here) will give you instructions on how to do it in a number of languages (Notion and Jira work similarly as well, I believe). Then you need to setup your API to handle the incoming event and you will have configured a proper webhook.

Workflows

Well, a typical Google Workflow (as in the default example) comes about like this:

This one will pretty much just extract some keywords from Wikipedia and bring them out. When you deploy this workflow and execute it - which you can do from the console to test it - you’ll get something like this:

But that’s again a closed loop, to interact with it, you need to trigger the Workflow. I was going to put down a list of triggers, but that would ruin the SEO of this article with its length. So, look it up yourself, but remember to have nothing else planned for the day.

Trigger Workflow with Pub/Sub

Do this. I’m not putting anything else in this blog. I’m cutting through everything and I’ll just tell you this is the right choice for 99% of Workflow triggers. That’s not saying it should be the only way, I’m saying for a lot of things it is the only way. Here’s the other things I tried:

• SDKs: Parameters are only available in NodeJS and Java versions (very random) and the documentation is a little wonky. As in the code there doesn’t work unless you deploy it from the command line from the sample repositories.

• API endpoints: This one takes a lot of effort. You need OAuth2 authorization on an application and that doesn’t always work when your application is an internal solution or a solution that can’t use these authorizations.

What can you do? Pub/Sub, it’s simple and pushed by every cloud provider, you can attach your Pub/Sub as a trigger to execute a workflow whenever it needs to be used. And you can trigger the Pub/Sub pretty much with any sort of API call/SDK/SMS/phone call/Instagram post you want.

Just edit your workflow and add EventArc as a trigger (also remember to have appropriate service account permissions everywhere):

Now, create the trigger using the publishing of a message to a Pub/Sub topic:

Notice the creatie trigger name there. It will create a topic for you if you haven’t done so yourself. After that, whenever you publish a message into that topic, it will trigger the workflow. Adjust both according to the JSON data and you’ll do just fine.