Now, yes, you can find the needed information and knowledge on the internet, but more in form of books, articles, documentation, forums, comment sections, and direct messages with knowledgeable people, all having one thing in common-reading. (Podcasts and videos can also be helpful, but for sustained long-term knowledge, I think that reading and spending time on the topic is king) Still, you have to be very selective and filter on what you read, but that comes with experience, which is essentially just patience, one of the things our generation is missing the most.

I am going to share a story on how reading saved me precious time.

Currently, I am building a web app for personal finance management-FEiN(https://fein.finance/), tailored to my needs. Doing the management in Google Sheets, I saw that it comes with challenges, one of them being that the whole system is dependent on strings, and if the format of the strings is missed, there will be errors and data missing, so I decided to make a UX-friendly app that will minimize my mistakes and please my love for unique design.

Consequently, I started upskilling myself by renewing my knowledge of NextJS.

I have previously used older versions of it to build apps (https://python.mk/, https://summer23.best.org.mk/), which used the Pages Router. I wanted to learn the "new" App Router, so I completed the NextJS' Foundations course on App Router, ending up with a certificate and a scaffolding for a financial app. Upon starting the course, I needed to generate the template using the CLI command:

npx create-next-app@latest nextjs-dashboard --example "https://github.com/vercel/next-learn/tree/main/dashboard/starter-example" --use-pnpm

and this is an important step, will get to it later on why. (hint: @latest)

I did this before the infamous CVEs that React and Next had, so when they got vocal I did what everyone else did, changed the version of the Next to an explicit one that had the CVEs fixed and continued developing it.

I had already made a Figma design prototype for the app and started implementing it in my app after the course ended. The first things served on my menu were accounts, authentication, and security, and I implemented them with great care, paying attention to every minutia.

I am keen on writing organic code, but am not opposed to getting your code from AI if you go over it thoroughly, rigorously, and exhaustively, and understand it deeply, so you can modify it and maintain it in the future, as an essential rule of software engineering. So, less vibe in vibe coding, and more scrupulousness(doing things right because it is right) and punctiliousness(implying an extreme/rigid focus on the smallest details).

Turned to AI for one of the things I didn't know how to do, authentication middleware or authorization logic that runs checks on user sessions or tokens before allowing access to certain routes. This ensures a seamless user experience by not requiring a user to log in again or view the login form when they already have an active, valid session.

It did its job, giving me an extension to my middleware file(proxy.ts)-matching what to redirect to /dashboard route if the user is logged in and requests /login or /register route, also hardening other non-authenticating routes the same way.

But, it didn't work...

I rechecked it twice: to see if something was wrong in the code or if I had other files overwriting this one, as such a bug can materialize, but it wasn't that. And the AI of my choice kept repeating the same code when asked to fix it because it wasn't working...

Thereupon, I fell back to what I do when something is not working-digging deep for every single detail about it by either reading documentation, forums, or articles about it, not skipping a single word.

I opened the documentation for NextJS and was met with the UI on left that had two drop-down menus: one for usage of App Router/Pages Router and the other one for the version of NextJS, put it in my brain's RAM and proceeded to search the documentation for "middleware", pressed enter and was redirected to the documentation's page for "Proxy", exactly what I had, right?

I read it whole, I saw that the AI gave me the correct file and content, but came back to the very top that said:

Good to know: Starting with Next.js 16, Middleware is now called Proxy to better reflect its purpose. The functionality remains the same.

I immediately thought back to the explicitly changed version of the scaffolding because of the CVEs and remembered that I don't use the @latest one(v16.1.6) anymore, but rather a slightly older one, v15.5.9.

Then I switched the version of the documentation to v15 and again wrote "middleware" in the search, pressed enter, and there it was, the file name called middleware.ts instead of proxy.ts. Then I went to the v16 documentation and searched for proxy.ts, and on my screen popped this note:

Note: The middleware file convention is deprecated and has been renamed to proxy. See Migration to Proxy for more details.

Rushed to my IDE, renamed proxy.ts to middleware.ts without changing the content and...

It worked!

I thought to myself that this is a big win for me, having solved this thing so fast instead of falling into debugging hell, and credited my reading skills, instead of using AI or trying a hundred things in practice, for the quickness of the fix.

I was unsure whether to write such a blog post since I am an embedded software engineer; this is not my expertise, and the audience would be waaay more experienced in these technologies.

Doubted if this would seem like a small thing to you, but then I asked colleagues who work on the web daily, and they said it's totally a scenario of their daily work. That gave me enthusiasm to do it, so thanks to Teo, you are reading this, and that matters...

The jam started on January 30th and ran for 48 hours straight. That is two days of building from scratch, running on coffee, stubbornness, and real willpower. The kind of weekend where we run mainly on coffee, and every quick fix slowly becomes a two-hour setback. There were noticeably more participants this time, but Base42 came prepared. The space was bigger, the setup was better, and the overall atmosphere felt more focused. People were obviously not there to kill time. Most teams got straight to work and stayed locked in.

As you can probably guess from the title, this year's theme was "masks." Compared to last year's "bubbles," it felt heavier and more layered, pushing everyone to think twice before jumping into their first idea. Once the brainstorming started rolling, though, it was full steam ahead. MGI's posts also made it clear that this year's Global Game Jam was massive. One of the biggest in the world, with an absurd number of prototypes made in just 48 hours.

Masquerade Exorcist - Vasilaki Totsili

Maybe the boldest move this year came from going solo.

Vasilaki, our embedded software engineer, switched to solo mode and built a game called  Masquerade Exorcist. At one point, he worked nearly 18 hours straight without stopping, fully immersed in development.

Masquerade Exorcist drops you into a cursed mannequin masquerade where demons blend in, and one wrong move ends the run. Using a rapid-fire MaskBow, you must read micro-twitch tells, correctly tag enemies, and avoid killing innocents before they hit the stage. Miss a demon or grief an ally, and the screen bleeds to black: game over, show's dead.

Check out the game:

Over the 48 hours, the game was built almost entirely in Unreal Engine C++. Vasilaki handled everything: enemy logic, combat mechanics, level events, audiovisual feedback, difficulty balancing, and a final cinematic, delivering a polished game by Sunday.

Best Game at the Global Game Jam 2026 - Tomislav Ingjatov & CBT

Across the space, another team was building something much louder.

Tomislav Ignjatov and his team CBT, consisting of three developers, two artists, and one game designer, won Best Game at Global Game Jam 2026 in Skopje with S.A.M. Spirit, Animal, Machine. Built completely during the jam, the game stood out for its tight combat design, clear mechanics, and multiplayer execution. The award came with a 300-euro prize, enough for one proper kafana night for the whole team.

Some pics from the winning team:

Another one with the prize and the art itself:

S.A.M. is a server-based online arena battler for Windows and macOS where masks define your abilities. Players choose between Animal, Spirit, and Machine masks, each following a rock-paper-scissors logic. Animals counter Spirits, Spirits counter Machines, and Machines counter Animals. Combat revolves around throwing your mask to strip or damage opponents, creating fast-paced matches that reward timing and positioning.

Developed in Godot, with assets created in Aseprite and Blender, the game delivers short but competitive sessions built around skill and smart decision-making. You can learn more and play the game here: https://lorddeathunter.itch.io/sam

Rising Star Award to our team Lab Rats

Some teams were stepping into their first Game Jam, while others treated it like a tradition.
Dimitrij Krstev, Teodor Angeleski, and Aleksandar Filipovski from Team Lab Rats won the Rising Star Award at Global Game Jam 2026.

More pics, screenshots and details follow:

For everyone except Teodor, this was their first game jam, making the recognition an important milestone for the team. They built their game Masked Descent using Godot and Aseprite, learning and solving technical challenges live during the event.

Masked Descent is a roguelike dungeon crawler featuring procedurally generated levels and a mask-swapping combat system, melee combos, ranged attacks, and stealth-based mobility. Boss fights appear every five floors, with powerups shaping each run and encouraging different playstyles. The game blends fast decision-making with classic dungeon progression and pixel-art visuals.

Gjorgji Dimeski - Multiple Projects, Won Audience's Hearts

Gjorgji Dimeski participated in Global Game Jam 2026 with two projects.

His solo project, Bits, or "Wordle for Hackers," was built in just three hours using SvelteKit with Discord integration. It's a logic puzzle based on binary operations, where players manipulate inputs to match the Goal Pattern shown at the bottom.

The game is available here:
https://bits.dimeski.net/

The game has been gaining popularity among tech enthusiasts, and many are playing it on Discord. Gjorgji continues to improve the game and regularly shares updates and new iterations on his LinkedIn.

MikroShpajz - Gjorgji Dimeski again with the team

At the same time, he collaborated with the team Mikro Shpajz (7 members) on “Maskakar,” developed in Godot. You can see the game here:
https://www.youtube.com/watch?v=ZzRXUK2YT-4

Once again, Gjorgji won the audience's hearts, as he has consistently done. This marks his fourth consecutive year participating in Global Game Jam.

Team Elon Mask,  Not That Elon!

Pixel Perfect for Best Art

No, not that Elon. Just Elon Mask, and honestly, the name already sets expectations.

Andrej Slavejkov, Andrej Mickov, Nikola Dinevski, Martin Dinev, Ilija Boshkov, all software engineers from CodeChem, featuring Goran Petrushevski, an embedded software engineer also from CodeChem, and their team member Gagi (Viktor), teamed up under this slightly suspiciously familiar name and built Mask of Life using Unity, while Gagi handled the art on a tablet. Six developers coding, one artist carrying, and they won Pixel Perfect for Best Art. They openly admitted it: the award wasn’t just about the programmers.

They went all in. Full 48-hour focus (realistically 30 effective hours, but who's counting). Everyone treated it like work, not just a jam.

Mask of Life is a 2D storytelling platformer set in a shattered monochrome world. You play as the Colorless One, restoring color and meaning by collecting powerful masks. The more masks you reclaim, the more the world comes alive. Clean mechanics, strong atmosphere, and apparently, some great music, as multiple people pointed out.

Play it here: https://maskoflife.codechem.dev/

Gameplay: https://www.youtube.com/watch?v=kxePk7Rc6GQ

Soundtrack highlight: https://www.youtube.com/watch?v=jWYrm_XZSOM

Now some visuals, which are ridiculously good, considering the fact that they were drawn on a tablet in what looks like a paint app:

Also included: A snapshot from the jam, when a colleague from CBT went to see what the team Elon Musk was building, or the other way around...

Sarmakedonci – Isotope Games

They didn't just participate in the Global Game Jam, but also sponsored it. In a gaming industry like ours, that kind of support genuinely means everything, and so does it to Isotope Games.

The name Sarmakedonci wasn't random. It comes from the main character of their game, Astral Match, so the team name was actually very on-brand.

Matej, Martin, Filip, Manuel, Boris, Ekaterina, and Nikola created a rhythm-based theatre game built around masks and emotions. You perform on stage, matching masks to target emotions, keeping musical notes in tune, and managing the audience's happiness. If the crowd turns on you, tomatoes start flying, and you get one last chaotic mini game to save the show.

It's hypercasual, fun, and one of the most conceptual and finished games at the jam. Everything was built during the event in Unity, with all visuals originally drawn by Nikola and animations handled by Martin Stoilov.

Compared to last year, this one simply felt more complete and more enjoyable.

Stefan Ivanovski, part of The Unfortunate 7" - Dalewood's Masquerade

Epic Coding Award  🏆

We were called “The Unfortunate 7.” There were six of us. We don't talk about the seventh.

We built a VR horror-puzzle game for the Meta Quest 3 using Unity and C#. The 3D modelling was done in Blender and Maya, music production with FL Studio, and UI/story mockups with Figma. You play as an invited guest to a masquerade party, and quickly find out that not all is as it seems. The goal is to escape this cursed mansion with powers gained through pieces of a cursed mask.

It was our first time working together, but we clicked fast. Strong 3D work, quick iteration, solid level design, and original music came together naturally. As a programmer, it’s always impressive to see the unbounded creativity of artists and how they turn rough ideas into something fun, quickly.

The vibe at the Skopje Game Jam was great as always. The organization was amazing, we had constant support, and developed our game in a welcoming atmosphere.  It was especially nice to see more kid and teen teams this year.

We started Friday night, pushed through Saturday, and finished Sunday at the ceremony. I had to sit out the final day because I was sick, but I had full faith in the team to carry it through.

Final Thoughts

Forty-eight hours is short until you try building a game inside it. This year felt bigger and more serious, with more teams, more young participants. Knowing that everything you see was built from scratch in those two days changes how you look at these games.

The theme was “Masks,” but by Sunday night, nobody was hiding much. You could see the lack of sleep, the stress before submission, the relief when something finally worked. Across all the games, there was real effort. Different engines, different styles, different ideas, but everything was built from scratch in those two days.

Some teams took home awards, some won the audience, and some simply proved they could finish, but that counts too. We say every year that next time we will rest more.

We won't!

See you at the next jam.

Of course, there are various solutions for this - right in your terminal:

• jq for JSON formatting and processing

• qrencode for generating QR codes

• uuidgen(Unix) and New-Guid (Windows) for all your UUID needs

And you can always just google what you need and use some web app instead. I did that too, who am I to judge? But this is all too fractured and inconsistent.

I personally use some of these tools myself. And I’ve noticed a common trend among my colleagues: many default to web-based tools, even though terminal apps are often faster and easier once you get the hang of them. I sometimes recommend some specific CLI tool, but it rarely sticks. And with CLI tools there’s also the issue of compatibility across platforms, you can use one tool on your Linux system, but when you switch to Windows you need to suppress that muscle memory and write another command in PowerShell instead. It’s just too frustrating and fragmented.

Wouldn’t it just be easier to have a single tool, that you could install once on your system, would work across different platforms? No need to remember and install different tools, or search for alternatives for your Windows machine. Imagine it all centralized: jack json, jack qr, jack uuid generate, jack jwt - all just working, in a single package, across platforms.

That’s why I decided to make a sort of Swiss Army Knife tool for developers that’s portable and accessible. Initially, I actually named it factotum - a word for a general handyman. Then, my friend Nikola Dinevski came over and suggested jack - as in, jack of all trades. I thought that it was perfect! It’s exactly what it is, a multi-tool for all trades - but a master of none. What’s often omitted from that saying though, is that it’s oftentimes better than a master of one! Besides, jack is a pretty memorable name and easy to type in your terminal.

Jack removes the friction from remembering all those different tools, you just type in jack and find the tool you need, on all your systems! No need to install multiple tools, or lookup something online. It’s easy and intuitive to use, with no fancy and complicated options that you may find in more specific tools which, let’s be honest, you’ll only ever need a fraction of the time. It’s composable, simple, and helps with most of your day-to-day tools needs.

The intention is not to replace all the other tools I mentioned, of course they’ll have their use-cases. I don’t expect jack to have feature parity with dedicated tools. No, the aim is to have jack as the easy default tool you go to when you need something so you don’t have to juggle multiple tools.

Jack is made with Kotlin. Why? Because I want to be unique! No, but really - I wanted to try out the language for something else than backend services. It’s cross-platform, and is overall very nice to work with. Additionally, I had recently read about clikt, a CLI library for Kotlin, and I wanted to take it for a spin.

I’d love for you to contribute! If you have a feature in mind you can always submit a PR or open an issue if you want me to put it on the to-do list. You can find the repository at https://github.com/dimeskigj/jack-cli.

Jack has a lot more features, and you can try them out for yourself!

On Linux/MacOS, you can install jack with:

curl -fsSL https://raw.githubusercontent.com/dimeskigj/jack-cli/main/scripts/install.sh | bash

If you’re on Windows, use PowerShell instead:

iwr https://raw.githubusercontent.com/dimeskigj/jack-cli/main/scripts/install.ps1 -useb | iex

Let me know what you think! I would be glad if you find jack useful.

While science accurately argues that humans are among the most complex forms in the universe, given that the universe and its vast system are even more complex, we tend to find joy in very simple things. The human brain contains more than 89 billion neurons, each connected to around 7,000 other neurons, sending between 10 and 100 signals every second. Yet, we humans are mostly stuck, searching for the meaning of everything. So all those signals might be tangled somewhere along the way. 🙃

Interstellar

The meaning of everything, and life in general, is not something that we'll answer here, but the thought does visit us often. Maybe the best thing in life is waiting. The anticipation behind it, the quiet hope it carries, and the time leading up to this blog post being written might be an example of that.

The Pursuit of Happyness

You experience different feelings and situations with the people you spend most of your time with. Family is one part of it, but another grows quietly at work. It's often the people with whom you share your routines, the morning coffee, the balcony talk, the wins, the frustrations, the silent glances that say I know something’s wrong with you, and the moments of laughter that make your long days a bit lighter.

The Usual Suspects

Now look around…yup, those are the people you spend most of your waking hours with. The ones who’ve seen you celebrate a bug fix like it's a world record, survive another sprint, and stare at your screen in quiet confusion before the third coffee kicks in, wondering how something that worked yesterday suddenly doesn't today. They've heard your “just one more thing to finish” speech more times than you'd like to admit, and they’re probably the reason you laugh at least once a day, even when a deadline refuses to play nice.

About Time

After 9 months of calls, commits, and quick lunch breaks this year that never lasted long enough, it was time to hit pause. We decided to replace Discord messages for honest conversations and code reviews with something else, and that’s how our team building began.

Cloudy With a Chance of Meatballs

Skopje sat under heavy clouds that morning. Two buses stood outside our office, surrounded by suitcases, backpacks, and people still negotiating with their eyelids to stay open. 😴 For a moment, it looked like a big group heading off on a vacation. In a way, we were not to rest, but to reconnect. It marked the start of our team building.

These are the moments to remind us to slow down, listen, care more, share a little deeper, and to dare a little more too, because somewhere between the bus ride and the beach, we kept coming back to those values. They were the quiet thread running through everything.

The Road

This year, our team had doubled, but “surprisingly,” somehow our chaos hadn’t. 😆 There were fewer forgotten passports, fewer “wait, did I take my charger?” moments, and everything moved smoothly than expected. We were headed to Olympic Beach in Greece, and despite the terribly cloudy weather, it seemed nothing could get in our way!

The Grand Budapest Hotel

The three-hour trip went by in a blink of an eye because there were games like Guess the Song and Two Truths and a Lie, along with some casual music, all accompanied by Nikolaj's dancing like he was warming up for a world tour. No one complained, as we couldn't, it was too funny.

The Arrival

Once you enter Greece, the first thing your eyes land on is the sea. It stretches out like it owns the whole horizon. When we arrived, we checked into the hotel and instantly switched into our special mode. We inspected everything: the dining area, the pool, the rooms… even the most minor details that normal people would never bother with.😆🙈

After the official opening, where Costa (Zelenskyy's doppelganger) said a few words, and the Simbiotika crew handed out the bracelets, that’s where our team building officially began, with us going straight to the beach.

You’ll probably ask why Zelenskyy, well, check this out:

The Opening Act

Not sure who thought of the name, but it completely resonates with us, so congrats, you did it once again… now let's go through the festival activities!

The Lord of the Rings: The Two Towers

We were divided into teams, and our task was to build sandcastles using specific elements and following the rules Simbiotika gave us. For instance, some of the castles should have included gates, decorations, bridges, and so on. It was great to see how the teams are divided, how competitive everyone is (not that we don't know this), and how we understood the assignment from our team leads by getting specific roles.

The end of the game was great, seeing all those medieval castles made from sand, a few sticks, stones, and other materials that looked like they were built straight from James of Saint George. The first three, including the winning team, really stood out. Their castles seemed so impressive, you'd think they were hiding an architect somewhere. 👀 The second thing that stood out was the names of the teams: Komunalci, Barbie and Ken, The Pyrates from Gevgelija, A Yellow Van, Loto 7, and so on…

Pirates of the Caribbean

As the day faded and the night stepped in, it continued with a pirate party at the bar near the swimming pool. Everyone was supposed to dress like a pirate, and we had some pirate games, some sips here and there, and a lot of fun. To be honest, there were some pretty awesome costumes! Not sure how, but "rrrrrrrrrr!" came out as a pirate voice from the night, and it stayed longer than expected! Once again, all participants in these games were very competitive!

When the pirate things ended, the music kept playing, and the dance floor got really crowded. As usual, the bar closed, and the party continued at the beach under the wide, dark sky.

Edge of Tomorrow

The second day of our team building started right after the tasty breakfast we had at the hotel. We are still trying to figure out if the food was actually that good or if we were just very hungry. After that, the games began, and the whole afternoon was busy from the start.

The first game was connected to memory and running, which is a cruel combination before the coffee fully kicks in. Again, we really nailed the team names, like “Kravari”, “Perfex”, “Mamurni”, and so on. Only we would choose names that sound like they came from a late-night group chat.

Bird Box

Then we had some games with our eyes closed, like Blind Train, an activity with a rope stretcher, some associations, a world scramble, and slowly we reached the final and most challenging game. Blind Train deserves a special mention because it was so funny. Half of us were walking in the wrong direction, the other half were also confused about what to do, and the rest of the teams were laughing so hard they forgot they were supposed to play too.

Warrior

Catch the Dragon’s Tail is a game that teaches teamwork, communication, coordination, and peaceful conflict resolution. At least, that is what the description promises. In reality, we turned the hotel’s backyard into something that looked suspiciously like a battlefield where nobody remembered the “peaceful” part.

Players form a line, with the first player as the head and the last as the tail. The head must chase the tail while the rest of the line tries to stay connected. The players who act as tails wear a scarf that they must protect, and the heads try to steal it. It sounds simple until the competitiveness shows up and everyone suddenly moves like the scarf contains ancient treasure.

Sometimes we forget how competitive we can get, and it becomes a little scary. After a long session of cautious running, suspicious strategies, dramatic slides, and at least one move nobody has been able to explain since, one of the teams finally declared their win.

The Secret Life of Walter Mitty

After lunch and an hour of free time, we continued with a set of workshops organized by our colleagues and by Simbiotika. It felt like the moment in a movie when everyone suddenly discovers their secret superpower.

We had a color fabrics workshop by Bojana Arizankovska, where half of us realized we barely know the difference between some colors. A caricature drawing workshop by Nikola Kostovski, where some faces were stretched, some were exaggerated, and some of us wondered if that is really how we look.

An origami workshop by Teodora Stoilovska and Todor Jovanovski, which proved that folding paper is much harder than our childhood made it seem. Salsa Cubana by Aleksandar Mirchovski, where hips tried their best and coordination politely stepped aside.

Then came Vandalism 101 by Mario Stojchevski, the basics of lettering in graffiti, types of graffiti, and history. It was the only time we were legally encouraged to learn how to make things look like vandalism.

And last but not least, Basics of Photography by Luka Krstikj. This one happened right after the team building at Base42 because it got dark, and we ran out of time. The irony of doing a photography workshop without light was not lost on anyone.

Ocean’s Eleven

Simbiotika also added their own workshops: Sip and Paint, Stress Management and Mindfulness, Communication and Active Listening, and Bushcraft Survival Skills. Truly something for every version of us, from artistic to stressed to secretly preparing for a life in the woods.

After all of these activities, we realized that we have a lot of knowledge to share, and that there is always something extra besides our everyday job that makes us feel good. We also saw how rarely we give ourselves time to learn something different.

Most importantly, we discovered that our colleagues are great at what they do, sometimes in ways we never expected.

Saturday Night Fever

If you thought that the workshops were where the night ended, you are totally wrong. We all had disco outfits, and suddenly the bar and the floor became like a Pulp Fiction dance scene. There were sparkles everywhere, some new dance moves where Nikolaj again took the spot, and Sheva made the night even better by being the DJ and adding some character to the party.

The Morning After

Even though our eyes were fighting a battle that morning, we packed everything, went downstairs, and checked out. Then we closed the team-building by reflecting on the good and the things we need to improve. Yes, we are very self-aware of that.

First, we shared some personal opinions and aspects of our approach to caring in this company, and although we shine in this value, there’s always room to improve ourselves. Then someone said that we definitely need initiative to share and dare, so we can intensify these values.

The King’s Speech

After some time and reflection on all these values, we shared certificates among ourselves and with our team, who had practically organized the whole team building “For the People,” which was applauded by everyone. It was time to say goodbye and to get back to our country, so we did.

Inside Out

You’ve probably been reading for 7 -10 minutes right now, but here’s the conclusion and what we learned from this team building…

Listen to your colleagues, listen to them to the very end, try to be patient, do not jump to conclusions about some reaction. Don’t be impulsive; our moods shift like the skies above us. A serene morning can become a stormy night, and vice versa. Remember that our thoughts aren’t just thoughts. They are sometimes shaped by hunger, by grief, by sleep deprivation, by hormones, by something totally random, like losing in Dragon’s Tail or realizing breakfast is over.

Try to understand and value someone else's opinion. You don’t have to be right sometimes, and even if you do, if you see how someone is passionate about something and they have spent their time doing it, support them, be with them. This is sharing, not sharing a burger or a coffee, although that’s also nice. Whether it is for career growth, a game in a team building, or something more personal, take the initiative and be there for the people.

The Little Things

We tend to forget these moments and how fragile we, the human beings, are. We forget so much that things become unforgettable. Again, as at the very beginning of this blog post, joy can be simple, and we may all need less than we imagine.

The Social Network

In a way, that’s the whole point for us at CodeChem. Not just writing good code and delivering projects, but making sure the people behind all of that stay connected, grounded, and actually enjoy working together. Team building made it obvious, and now the job is to keep that same energy once we get back at our desks.

Maybe I Do

Maybe that’s all we really need going forward: a little more awareness, a little more patience, and the reminder that good work always starts with good people.

A Beautiful Day in the Neighborhood

Special thanks to Simbiotika, who organized our team building for the second year in a row and knows how to handle us, even though we are a lot.

Also, special thanks to Krume, our photographer, for making these amazing photos, for his charisma, and for his positive attitude. If you need photos like these, you can always contact him here: https://krumetakesphotos.com/. Plus, he is a great human and brings the fun!

Now that we come to the end of this blog post, I hope you all noticed:

Post-Credits Hint 🎥

If you recognized the section titles:

Yes, they’re all real movies. If you haven’t watched some of them yet, well… you just got a pretty solid watchlist. 😄🍿

🎬 ROLLING CREDITS: CODECHEM EDITION

CAST

Gen Z Engineers ....................... Agents of Chaos & Memes

Millennial Engineers .................. Masters of “One More Commit”

Gen X Engineers ....................... The Actual “Responsible Adults”

Designers ............................. Pixel Sorcerers & Color Psychics

QA Specialists ........................ Certified Breakers of Everything

Project Managers ...................... Professional Crisis Containment

DevOps ................................ Cloud Whisperers & Deployment Wizards

Marketing & Recruitment & Finance............The Only Reason We Function

SPECIAL CAMEOS

Nikolaj ................................ Chief Dance Officer

Sheva .................................. DJ & Energy Distributor

Costa “Zelenskyy”...................... Ceremony Opener

Simbiotika Crew ........................ Bracelet Keepers / Team Building Organizers

Hotel Staff ............................ Witnesses of Our Collective Behavior

Blind Train Participants ............... Temporarily Disoriented Adventurers

Dragon’s Tail Survivors ................ Unofficial Stunt Performers

LOCATIONS

Skopje Office .......................... Where Deadlines Are Born

Two Buses .............................. Where Bonding Became Mandatory

Olympic Beach, Greece .................. Where We Rebooted Ourselves

Hotel Backyard ......................... Battlefield #1 (RIP to the grass)

Pool Bar ............................... Battlefield #2 (RIP to our dignity)

Beach at Midnight ...................... Battlefield #3 (RIP to everyone’s shoes)

Base42 ................................ Photography Class with Luka

Till our next one,

<3, CodeChem

In this blog post, I’m highlighting three problems I’ve had the opportunity to work on. I found their solutions both endearing and instructive, especially for a wider audience such as Computer Science or Software Engineering students. Feel free to try solving them if you haven’t already. The first one is a great warm-up for Advent of Code (and Open Day 😉).

1. Groups in Groups

Problem Statement:

One system allows a specific user group to be part of another group. If Group A is a subgroup of Group B, then Group B cannot be a subgroup of Group A—not even indirectly (e.g., A → B, B → C, C → A). The task is to display the parent relationship of a selected group.

Solution:

You may have seen similar structures in a filesystem GUI or encountered recursion in OS lab exercises involving file system entries. This problem, like many others, can be solved using one of the most versatile algorithms: Depth First Search (DFS).

How do we apply DFS here? One key observation is that there must be at least one group that isn’t a subgroup. Why? Let’s use an intuitive explanation (powered by GPT) alongside formal proofs:

No Two Boxes Can Contain Each Other at the Same Time

Think of a group as a box. Some boxes can contain other boxes.

Rule: No two boxes can contain each other at the same time.

Now ask yourself: Is it possible that every box is inside another box?

• Pick any box.

• That box is inside another box. That box is inside yet another. Keep going.

• You can’t ever return to the first box you picked (the rule forbids two boxes containing each other).

• But there are only finitely many boxes.

So eventually, you must reach a box that is not inside any other box.

That box is the “top-level box”—the one that belongs to nothing.

Starting from these top-level groups, we run the DFS and track which nodes are being visited. Suppose we have paths like:

[[1, 2, 3], [1, 2, 4], [1, 3], [5, 3]]

Filter out all paths that don’t include the selected group. Sort by ID and then by length:

[[1, 3], [1, 2, 3], [5, 3]]

Print the first path. For the second path, remove the matching prefix and print from there. Repeat until the end. Boom! We’ve solved it (and documented the solution 😄).

2. Big-Endian to Double SQL Migration

Scenario:

Imagine you have a relational table named vector containing arrays of N positive double numbers stored as big-endian hexadecimal representations, along with a column type (e.g. position). For your favorite 3D position vectors, you need to store additional data beyond (x, y, z), and the dependencies require creating a separate entity. The constraint: solve it using SQL* (MySQL in my case). Any SQL nerds?

Example:

Solution:

This might not be the cleanest solution, but I chose this challenge because IEEE 754 representations are essential knowledge for computer architecture classes, SQL, and data migration stress. Hopefully, this blog sheds light on the question many engineers ask: “Where would I need this knowledge?”

Start by selecting all rows where type = 'position':

SELECT value FROM vector WHERE type = 'position';

Next, split the concatenated value (each double is 8 bytes = 64 bits):

SUBSTRING(value, 1, 8)
SUBSTRING(value, 9, 8)
SUBSTRING(value, 17, 8)

Create a function to convert each CHAR(16) hex value (16 hex digits = 64 bits):

CREATE FUNCTION convert_big_endian_to_double(big_endian_hex CHAR(16)) RETURNS DOUBLE

Convert the hex to binary:

SET binary_representation = LPAD(CONV(big_endian_hex, 16, 2), 64, '0');

Then decode using IEEE 754:

How do we convert? https://en.wikipedia.org/wiki/Double-precision_floating-point_format

DECLARE result DOUBLE;  
SELECT 
    POW(-1, CONV(SUBSTRING(binary_representation, 1, 1), 2, 10))  -- sign bit 
    POW(2, CONV(SUBSTRING(binary_representation, 2, 11), 2, 10) - 1023)  -- exponent 
    (1 + CONV(SUBSTRING(binary_representation, 13, 52), 2, 10) / POW(2, 52)) -- significand 
INTO result;

And that’s it! You can return the result from the function; however, keep in mind edge cases such as zero, infinity, etc.

3. Finding MAC Addresses of Disabled Network Adapters on Windows 7

Problem:

This is a bug fix, not a feature request. Not strictly tied to uni classes, but I chose it because it’s an unusual, non-trivial problem that requires deep troubleshooting across shells, WMI, and the registry.

How do you figure out the MAC addresses of all (including disabled) physical network adapters on Windows 7?

Solution:

It sounds trivial, but it’s not. Disabled physical adapters don’t expose their MAC addresses via standard WMI queries, and Get-NetAdapter isn’t available on Windows 7. If you’ve used WMI queries before, and the user has a disabled network interface, you won’t get the MAC address.

You might be able to resolve this with some Windows 7 upgrades (if you have hardware control). Otherwise, the only solution I could propose is to ask the customer to enable the interfaces or upgrade. ¯\(ツ)/¯

(My Ethernet 2 was intentionally disabled)

Final words

Knowledge-sharing is one of the foundations of community progress and personal growth for those who share it. I’m grateful to CodeChem and its clients for fostering a culture of knowledge sharing and accessibility. I hope this blog post serves as my contribution to that spirit. If you find this blog post useful, certainly do let me know, and I will share more!

I have always wondered what is the most crucial thing for creating effective, endurable, and scalable software systems, following the stories of how some companies have core software written in languages ​​that were “popular” in the 70s of the last century or experiences such as rewriting WinForms 90s Desktop software to adapt to the modern Cloud/Web/Mobile world.

A few months ago, I attended a tech conference in Skopje, WhatTheStack. One of the presentations reminded me of an interesting concept in computer science: State Machines.

At this event, it was presented how UI components can be modeled using Finite State Machines and the selling point for me to try the XState library was the visual editor and my belief that such CASE (Computer Aided Software Engineering) tools can significantly simplify the definition of certain business and system processes in the form of a diagram drawing/wiring that is quite understandable even for non-IT people.

So I decided to try to develop my ATM system to describe all its UI interactions and states using XState! #LearnByDoing

What is a state chart?

State diagrams (or charts) provide an abstract description of a system's behavior. The content described in a state chart is a deterministic finite state machine (FSM), a conceptual model that is defined by the state in which the system currently is, and the events that cause a transition from the current state to another (or the same) known state from the finite number of states.

ATM: System breakdown

Note: To maintain the conciseness of the presentation and the reader's concentration, I highly recommend cloning and starting the project by yourself, available at the link provided at the very end of this post. The project is a React web application and a Node Express (server.js) application.

Creating an initial state

Every ATM will ask you to insert your credit/debit/crypto card, so the initial state of my ATM state machine is: Insert Card. After successfully “inserting” a card, we are presented with a menu where we need to authenticate. This is how the definition of the initial state looks in code:

"Insert Card": {
    on: {
        CardInserted: "Unauthorized Menu"
    }
} // creating a new state with the visual editor is even simpler

In the interest of my time, while developing the application, I didn’t go into some details (such as whether the correct card was inserted).

Interaction with the main application

During the lifecycle of an actor (in this case, an ATM FSM instance), the outside World (in this case, the frontend application itself) can find out the current state of the instance or send an event message with the send function.

 {state.matches('Insert Card') && <InsertCard onClick={() => send({ type: "CardInserted" })} />}

Therefore, while we are on the InsertCard screen, some external actor (in this case, onClick) will send an event of type “CardInserted” and will “trigger” the machine to make a transition to the Unauthorized Menu. As simple as that!

What about data?

Each instance also has its global memory, defined as Context, where we can store data needed during the machine’s lifecycle.

In my case, the PIN is stored as userId in the Context of the ATM. Although this is unnecessary, my goal was to create an updateUserId event that triggers a transition within the same state when updating the PIN, which will, at some point, be used as input when calling another type of actor to authorize ourselves – Promise actor.

The Promise actor

Using fromPromise we’ve defined our authorization actor, which essentially makes a POST request to the server and validates the user (the PIN/userId). What is interesting about Promise actors is that they have exactly two outcomes, done and error, which would direct the user to the Authorized Menu or Incorrect Pin (simplification) screen, respectively.

Reusability

What enhances the reusability is using another machine as a child actor in our machine. For example, the ATM uses a countdown machine to transition out from some screens where the user receives an informational message (Thank you for using our services).

In this machine, we have a countdown event that after 1 second transitions to the same state and that event has a guard (it can be executed if the remaining count seconds != 0). A similar guard is countingFinished – we can’t finish if the remaining count seconds != 0. XState allows us to call an action upon each entrance of a specific state, and notifyParent is such an example, upon each entrance in the counting state, notify the parent (ATM instance) about how many seconds are left!

ATM: Visualised

To better visualise how all this would look to the outside world, that is, from the point of view of the ATM user, my colleague Andrej Dojchinovski stepped in and helped design the user interface of our imaginary ATM. In the following section, he’ll share the thoughts and reasoning behind the designs in a few words.

Guides and Constraints

Let’s start by clarifying that the goal was never to invent a new type of ATM, but rather to create a smooth, familiar user flow, guided by UX and UI best practices, with the main objective of simulating the functionalities provided by the state machines working in the background. We decided that our fictional ATM would include a touchscreen, a physical numeric keypad, a card slot, and a cash slot.

UI Design

Since the ATM is purely fictional and unaffiliated with any existing bank, I had the creative freedom over its branding and visuals. Assuming it might be used outdoors in daylight, I gave the interface a bright, neutral background to allow for better contrast and text readability. I used a semantic approach for the colour palette, organising it into three groups:

• Teal and mint green for primary, desired actions and success messages

• Dark desaturated teal for secondary actions and neutral text

• Raspberry pink for cancelling actions and error states

To ensure visual consistency and harmony, I applied shades from these same color groups to all graphic elements and illustrations throughout the designs.

Content, Layout, Actions

The overall digital interface includes two distinct types of screens:

1. Screens that prompt physical interaction with the ATM (e.g., inserting or removing a card, entering a PIN, or depositing/collecting cash)

2. Screens that require touchscreen interaction, where the user selects from multiple on-screen options

In addition to differing in expected user input, these two types also vary in content and layout.

The first type is characterised by a clear written instruction accompanied by an image as a visual cue indicating the expected physical action.

Here we see the initial state screen prompting the user to insert their card to start using the ATM, followed by the second screen requiring authentication with a PIN.

The second type presents the user with a set of choices, prompting them to proceed by tapping one of the displayed options. Users can end the session at any point (except during background processes such as checking a balance or counting cash).

After a successful authentication, the user is presented with the main menu, with the option to withdraw cash, deposit cash, and check the card balance. If they choose to withdraw cash, they are given several pre-filled amounts based on commonly requested values, and the option to input a different amount.

To prevent system errors and avoid unnecessary background processes, some actions are disabled until additional steps are completed. Animated screens provide real-time feedback during background operations, reassuring the user that the system is working. When errors occur, users are shown an explanatory message along with suggested steps to resolve the issue.

All of these use cases can be seen in the example below.

Once the user has performed all desired actions and necessary steps, the final screen displays an informational message confirming that the session has ended successfully. This screen is implemented with a countdown timer and automatically transitions back to the ATM's initial state after a short delay.

Prototype

To see all of this in action, check out the full prototype via the following link:

Figma Prototype

[Hint: Whenever an external action is required (such as inserting a card), simply click anywhere on the screen to proceed in the prototype.]

Final Words

Of course, many other functionalities weren’t even mentioned in this blog post, so I encourage you to try modeling the behavior of some system that comes to your mind.

I believe developing software as a state machine will guarantee its longevity, easier integration into different media, reliable system upgrades, and easier testing/observance of the possible state paths within the system (btw, writing tests for FSM is also fun!).

Finally, thank you for making it this far! Below you can find the GitHub link to the project itself, and if you have any comments and/or suggestions, I encourage you to contact me at gjorgi.krenkov@codechem.com

Till my next blog post,

Best,

Gjorgi Krenkov

Project: https://github.com/gjorgi-krenkov/atm-fsm

There’s only one way to find out…

Read on to see who built what, who popped under pressure, and who walked away with the title of Best Game and some other awards. 🎮🫧

Jammin’, I Want to Game Jam It With You

Game jams are the ultimate playground for game developers—an opportunity to test skills, experiment with absurd ideas, and consume alarming amounts of energy drinks. This year, the event was once again hosted by MGI at Base42, the second year in a row on this location, where engineers, artists, and just game enthusiasts gathered to embrace 48 hours of creative madness.

CodeChem Representation: 5 Teams, 2 Major Awards!

This year, CodeChem had engineers and a game designer in 5 different teams battling against time, sleep deprivation, and their own ambitions. And guess what? Two of those teams took home top awards! Now, let’s take a closer look at what our colleagues built and who walked away victorious!

🏆 Best Game Award: "Hydroplane"

Not sure If I’m supposed to say meet Tomislav, because I said this in the previous blog post for Game Jam, but let’s structure it this way: We’re gonna start with Tomislav Ignjatov, an ML engineer at CodeChem, our colleague and a Game Jam veteran who has never skipped a year (we stopped counting). Together with his crew, he created Hydroplane, a multiplayer game that protects the ocean floor from toxic and explosive barrels.

The Fish-Fueled Cleanup That Won Best Game 🎮

One player controls a geyser that shoots bubbles to trap fish, while the other takes command of a yellow submarine that collects the fish and catapults them at barrels to destroy them; because what better way to clean up the ocean than with fish-powered demolition? Built using Godot Engine and Aseprite, the game earned them the Best Game Award, and they hope to launch it on Steam soon. The only thing Tomislav would change? The food. Also, despite constant interruptions from Nikola Dinevski of another team, he still came out on top. Or, as he puts it: "I came, I saw, I conquered."

🔥 Best Hybrid-Casual Game: "Overboiled" Brainstormed at the CodeChem Balcony

Now, moving on to the next team…yes, we have a team now: Nikola Dinevski, Matey Cardula, Petar Atanasovski, Nikola Kostovski, and Gjorgji Nechovski. All of them are our engineers, except for Nikola Kostovski, the creative hero and our game designer. And oh, do we have a story to tell about this one?

If you’ve been around CodeChem long enough, you already know that a lot of ideas are born on our balcony, usually accompanied by a cup of coffee, some deep tech debates, and at least one person zoning out completely. This time, while sipping his coffee, Nikola Kostovski had a moment of pure inspiration. He stared into his cup and thought, What if we made a game about overboiled milk? Yes, really. Based on the Macedonian idiomatic phrase "Изгоре лончето, претече млекото," which translates to "A watched pot never boils, but an unwatched one overflows," Nikola figured, why not turn a common kitchen disaster into a fast-paced game? And thus**, Overboiled** was born.

💡 Brainstorming, Banter, and Enough Caffeine

While having a meet about this blog post, Nikola was on his philosophical game development journey, and the other Nikola (Dinevski from Bitola) was passionately explaining the difference between hybrid and hyper-casual games. The rest of us? We were just nodding along while internally wondering how much caffeine he had consumed at that point.

So, What is Overboiled?

To answer your question, it is a fast-paced, strategic bubble-popping game where players must prevent a boiling container of milk, coffee, or beer from overflowing. Simple enough, right?

Well, there’s a twist. You can’t just tap bubbles when they reach the surface. Instead, you have to wait for three or more of the same color to match up before they burst automatically, giving you combo bonuses and gold. And, because chaos is mandatory in a game jam, the heat keeps increasing, sending bubbles flying up faster and faster until you feel like your screen is personally judging your reflexes.

🛠️ Power-Ups, Customization, and Pure Bubble Panic

Thankfully, players aren’t left completely helpless. Power-ups like Cool-Off, Pop All, and Lid let you regain some control (at least for a few precious seconds before panic sets in again). And, as if boiling virtual coffee wasn’t fun enough, you can customize your container, switch up the liquids, and unlock new power-ups, all while trying to stay sane in the chaos.

🎨 Art, Sound, and The Wild Methods of Game Jammers

Now, let’s talk about the art. Nikola Kostovski’s work was so good that some people thought it was AI-generated. Nope, just raw talent and a ridiculous amount of attention to detail. Then there’s the music, which deserves a special mention because Nikola Dinevski literally woke up, grabbed random household objects, and started recording sound effects himself. That’s the level of dedication (or desperation?) we’re dealing with here.

While Nikola Kostovski was on the creative front, the rest of the team Nikola Dinevski, Gjorgji Nechovski, Matey, and Petar went full Unity mode, tackling all the development, gameplay logic, and physics madness. They started by setting things up on one computer, but once tasks were divided, they switched to two machines and went full-speed ahead. And yes, some additional video editing skills were needed along the way, but somehow, in the middle of the jam-fueled insanity, they pulled it all together with slick transitions and audio.

🏆 The Aftermath: Award-Winning & Caffeine-Induced Regrets

48 hours later, Overboied took home the Best Hybrid-Casual Game Award. And it was totally deserved. Will they be back next year? Absolutely. Are they still recovering from dangerous amounts of caffeine and energy drinks? Also yes. But hey, that’s just part of the Game Jam experience. 🔥🫧

🌍 A Multiplayer Web Game: "Bubble Pop"

🕹️ Solo Mode Activated!

Next on our list is Gjorgji Dimeski, who decided to go fully solo this year. As he boldly declared during our meeting, "I might not win any awards this year, but I definitely won everyone’s hearts instead." And honestly? He wasn’t wrong.

Taking the lone wolf approach, Gjorgji developed Bubble Pop, a multiplayer bubble-popping game that can be played by anyone, anytime. No teammates, no distractions, just him, his code, and a mission. The game runs entirely on web technologies, built with Angular, and can be played online at Bubble Pop.

Sleep-deprived, Not

Unlike the caffeine-fueled chaos happening around him, Gjorgji actually went home to sleep instead of pulling a 48-hour all-nighter like the rest of the Game Jam warriors (legend). But despite his well-rested approach, he still had an amazing time, especially appreciating the fact that Base42 had heating—something past Game Jams seriously lacked.

His only complaint? The fast food situation could use an upgrade next year. Fair enough, Gjorgji. Fair enough. 🍕😂

💥 Bubble Blaster: A Kitchen Cleaning FPS (Yes, Really)

🦠 Clean the Kitchen… With a Bubble Gun?

Next up, we have Teodor Angeleski and his crew, who took a wild approach to the Game Jam theme and turned kitchen cleaning into a full-blown FPS.

Yes, you read that right. In Bubble Blaster, players take on the role of a sentient cleaning detergent whose life mission is to eliminate bacteria and flies using—what else?—a bubble blaster. But that’s not all. Because, apparently, kitchen appliances are way too far out of reach for an average bottle of dish soap, players also get a grappling hook to swing to higher places (which, for normal humans, would be waist height).

👨‍💻 A Crash Course in 3D Game Development

To bring this soapy warfare to life, the team used Godot Engine & Blender, diving headfirst into 3D game development for the first time and somehow pulling it off in just 48 hours. If that’s not dedication, I don’t know what is.

🦒 Teodor’s Secret Superpower: Tallness & Humility

Now, if you don’t know Teodor, let me paint you a picture. Imagine a guy who’s tall enough to reach the top shelf without a ladder yet humble enough to never mention it. Meanwhile, his game characters are out here grappling-hooking their way around a kitchen like it's a Marvel movie.

🏆 Achievement Unlocked: FPS, Bubbles & Brilliance

Despite sleep deprivation, Blender struggles, and a very intense battle against bacteria, the team successfully created a 3D multiplayer shooter from scratch in just two days. Not bad for a weekend project, huh?

Would they do it again? Absolutely. Would they sleep next time? Probably not. But hey, that’s Game Jam life. 💥🫧🎮

We’ve slowly come to an end… just kidding, there’s mooooooore.

🎮 Bubbles’ Adventure: The Couch Kings

Last but not least, we have Vasilaki Tocili, the only one from our embedded engineers in the jam, teaming up with his sister to create Bubbles’ Adventure, a hybrid-casual mini-game collection inspired by Bubbles from The Powerpuff Girls. And if there’s one thing we learned from their journey, it’s that a fancy setup alone doesn’t make a great game, but pairing it with strong determination definitely helps.

🛋️ The Setup: The Ultimate Couch Command Center

From the moment the jam started, Vasilaki and his sister claimed the best couch at Base42—and never left it. Seriously, they built an entire PC + laptop fortress right there. For 38 out of 48 hours, they coded, designed, brainstormed, and probably questioned their life choices, all while refusing to move from their carefully chosen spot.

🎮 What’s Bubbles’ Adventure All About?

The game is a collection of mini-games, each an adventure on its own. Before every game, players enter a lobby with unskippable ads, except you’re not locked in place. You can walk around, interact, and goof off while waiting for the next challenge to begin. Suspense, chaos, and monetization are all in one place.

Once the game starts, players take control of Bubbles, but with a twist…all characters are Bubbles, just stylized in their own way with custom outfits and accessories. And, of course, power-ups are available to spice things up.

One mini-game involves quick reflexes as bombs disguised in a similar color as the bubbles try to trick you. Another challenge features slippery and bouncy platforms-bubbles, where falling means getting yeeted into the void and sent back to the lobby.

🛠️ The Tech & The Grind

Vasilaki handled all the programming and setup using Unity Engine, while his sister took care of the art, inventory, character designs, and the in-game shop. Aside from Unity, they also used Roblox Studio for inventory and shop mechanics. Did he work hard? Oh yes. Did he sleep? Not really. Did he eat? Probably, but only within arm’s reach of the couch. He was also the last person to submit a game—just like last year. But hey, traditions are traditions.

The Ultimate Couch Potatoes

At the end of the jam, Vasilaki and his sister didn’t walk away with an award, but they did leave with the undisputed title of Ultimate Couch Champions. While others paced, stressed, and powered through their games in questionable ergonomic positions, these two secured the comfiest spot in Base42 and refused to move for nearly two days.

It was his sister’s first Game Jam, and what better way to experience it than by coding, designing, and strategizing, all from the couch fortress they built? They had a blast and are already planning to return next year, hopefully with an even more optimized couch-to-coding ratio. What’s next? More caffeine, more coding, and, of course, claiming the best couch again. 🛋️🎮🔥

Final Thoughts: Would We Do It Again? ABSOLUTELY.

48 hours. Too much caffeine. Questionable life choices. But was it worth it? 100%. From balcony brainstorms to 3 AM debugging chaos, this Game Jam was nothing short of legendary, wrapped up with four judges from four different companies, one of whom was our colleague Filip. While he may be locked in an endless rivalry with gravity, if there’s one thing he loves, it’s being involved in game-related events.

Hopefully, next year, we’ll be back with better food, fewer energy-drink-induced hallucinations, and even crazier game ideas. Until then, keep coding, keep dreaming, and never underestimate the power of bubbles! 🫧🎮🔥

This blog post summarizes the comparison of the performance of parallel PDF document rendering across three AWS architectures: Virtual Machine (EC2) with Docker and Nginx, Kubernetes (EKS), and Function-as-a-Service (FaaS) using AWS Lambda. The goal is to evaluate scalability, cost-effectiveness, and complexity when rendering PDFs with Puppeteer under different cloud-based setups. I’ve written more details on the subject, which you can check out here.

Introduction

Cloud computing has dramatically transformed application development and deployment, particularly compute-intensive workloads. Document generation, a common task across industries like finance and reporting, is an ideal scenario for evaluating the performance of different cloud architectures.

In this comparison, I evaluate the performance of rendering PDFs using Puppeteer across three different AWS services:

• EC2 (Docker and Nginx)

• EKS (Kubernetes)

• Lambda (FaaS)

Performance is measured in terms of request time, render time and total processing time for request batches of various sizes. The insights from this comparison can help developers choose the right cloud architecture for their specific use case.

Architecture

Local Container (Docker)

For this setup, I developed a Node.js application with an Express endpoint to handle PDF rendering. The application was containerized using Docker and tested on a local machine, serving as a baseline for standalone deployments.

EC2 (Docker and Nginx)

In the EC2 setup, I provisioned an EC2 instance, installed Docker and Nginx, and deployed the application container. Nginx served as a reverse proxy, handling HTTP requests and forwarding them to the Docker container, ensuring efficient resource usage for parallel processing.

EKS (Kubernetes)

For Kubernetes, I used Amazon Elastic Kubernetes Service (EKS) with a 3-node cluster. The Docker container was pushed to Amazon Elastic Container Registry (ECR) and deployed through Kubernetes. A NodePort service exposed the application to external traffic, allowing for testing under different load conditions.

Lambda (FaaS)

The serverless approach utilized AWS Lambda to handle PDF rendering as a function. The Lambda function was triggered through an API Gateway, enabling dynamic scaling without the need to manage the underlying infrastructure.

Testing Code Structure

I implemented a Node.js script that sent parallel HTTP POST requests to each service, passing EJS templates and JSON data as payloads. The testing was conducted for batch sizes of 1, 10, 30, 50, and 100 documents. Each service was evaluated based on average response time, render time, and total processing time.

Performance and Results Analysis

Average Times Per Document

The table below summarizes the average response and generation times in seconds per document for 100 parallel requests.

Total Processing Times for Batches

The following table shows the total processing times in seconds for varying batch sizes across the different architectures, with a graph representing the data.

Cost Analysis of Document Rendering Services

When comparing the costs of document rendering across different AWS services, it’s crucial to understand execution times and the associated charges. Based on the results of rendering 100 documents (as detailed in Table II), here’s a breakdown of cost estimates for each service:

1. AWS Lambda

Lambda functions charge based on execution time and allocated memory. With 2048 MB memory, the cost is $0.0000000333 per millisecond. For 100 documents, with an average of 14.06 seconds (14,060 ms), the cost comes to approximately $0.00047. While this may seem highly cost-effective, Lambda’s pricing is best suited for short, on-demand tasks rather than long-running or high-frequency jobs.

2. Amazon EC2

Using a t4g.small EC2 instance costs $0.0168 per hour, and the execution time for processing 100 documents was 68.23 seconds (0.01896 hours). This results in a cost of approximately $0.00032 for rendering 100 documents. However, it’s important to note that EC2 instances remain active and incur costs even when not processing documents, making the actual cost much higher for continuous or low-usage workloads.

3. Amazon EKS (Kubernetes)

The EKS setup used c6g.large nodes, which cost $0.02628 per hour per node. With a 3-node cluster and an execution time of 35.93 seconds (0.00998 hours), the cost for rendering 100 documents was approximately $0.00026. However, additional costs for EKS must be considered, including control plane charges ($0.10 per hour) and potential load balancer usage. Like EC2, EKS clusters also incur costs for all running nodes, even when not actively processing tasks, which significantly increases the true cost for workloads requiring persistent resources.

4. Local Container on Dedicated Server

For this simulation, running the Local Container on a dedicated server was assumed to be free. In a real-world scenario, however, a dedicated server typically costs between $0.05 and $0.10 per hour. With an average processing time of 63.41 seconds (0.01761 hours), the estimated cost for rendering 100 documents would be approximately $0.001 to $0.002, depending on server pricing. While this approach offers predictable costs, it requires maintaining dedicated infrastructure, which could become inefficient for variable workloads.

Discussion

The results clearly highlight the strengths and weaknesses of each architecture:

• Local Container:

  • Benefits: Suitable for isolated or small-scale deployments.

  • Limitations: Fully self-managed, with a lot of overhead and constant costs.

• EC2:

  • Benefits: Full control over the environment, flexibility, and resource allocation.

  • Limitations: Requires manual scaling and management of resources.

• Kubernetes (EKS):

  • Benefits: Automated scaling, resource management, large workload handling.

  • Limitations: Complexity in setup and management, higher cost due to infrastructure overhead.

• Lambda (FaaS):

  • Benefits: Fully serverless, automatic scaling with no infrastructure management.

  • Limitations: Cold start latency and limitations on execution time and resource allocation.

Conclusion

Choosing the right infrastructure for your workload depends on several factors, including cost, scalability, and performance. AWS Lambda offers serverless scalability for small-scale, cost-effective solutions but may struggle with high concurrency. EC2, while providing higher resource limits and simplicity, comes with continuous infrastructure costs. EKS shines for large-scale, continuous workloads, harnessing Kubernetes’ power for orchestration, but its complexity and cost can hinder low-utilization tasks. A Local Container setup is ideal for development or small deployments but lacks the scalability for more demanding applications.

Ultimately, assessing the specific needs of your workload—whether it’s predictable or variable, small or large-scale—along with budget considerations will help you make the most informed choice. A hybrid approach combining these options often provides the optimal balance of cost, performance, and flexibility.

Recommendations

My personal take on choosing the right infrastructure for this specific use case, rendering PDF documents, is:

• Online solution -If our goal is to generate documents, whether for sale or personal use, I would go for Lambda (FaaS). The pay-as-you-go pricing model is ideal because you only pay when documents are generated. If we are selling them, the cost of document generation essentially “pays for itself.” There are no costs for personal use, and when documents aren’t being processed, no infrastructure is running in the background.

• Offline solution - Usually, this use case means that a mid-to-large company generates documents on-premise. If this is for personal use, I would suggest just using Docker and starting a container locally. But, if this is for a large company where we need to handle big workloads and offer scalability, reliability, and elasticity, I would go for a local Kubernetes orchestration.

Check out the full paper here for more detailed information on cloud architecture choices and performance comparisons.

We often write repetitive code when starting a new Web API project, whether using the modern, minimal API style or using classical .NET Controllers.

The most common cases are:

• Rewriting pagination and sorting filters across projects;

• Handling navigation properties and managing joins manually;

• Creating controllers and database queries from scratch.

What I will go through within this article won’t be a replacement, but rather a package to quickly build and test an API, whether in minutes or hours… it depends on many things. All you have to do is think about the models and their relations beforehand. The rest can be built by using proper annotations.

Disclaimer: This is not a full implementation, or maybe it could be in the near future. For now, its peak potential will likely serve as a prototype for testing your ideas or perhaps for a personal project that doesn’t require heavy “configuration.” I mean, it is possible to do that, but it’s just not the intent— at least for now, though maybe in the future.

Meet dappi

The name stands for dotnet application pre-programming interface; it’s all lowercase because it’s small, if that makes sense at all (the truth is, dapi was taken, and I had to settle for dappi, which I’m equally happy with).

Now, I will introduce you to the annotation [CCController]. While the name may not seem directly related to dappi, I chose it because of my strong affection for the company where I work (CodeChem), hence the initials as a prefix. As for the name Controller, well, it speaks for itself.

 [CCController]

This can be used on top of any class representing an entity in your db, something we want to expose to the world in a REST API manner.

Let’s imagine we’re building a simple API to list our books and their author. We probably, almost always, would start by creating the class, right?
Yes, so let’s start with a book class.

[CCController]
public class Book
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid Id { get; set; }
    public string Title { get; set; }
    public int YearPublished { get; set; }

    // Foreign key to reference the Author
    [Required]
    [ForeignKey("Author")]
    public Guid AuthorId { get; set; }

    // Navigation property: Each book has one author
    public Author? Author { get; set; }
}

Yep, it looks like every other class represents a table in the database. The attributes mentioned here are part of Entity Framework or .NET's System.ComponentModel.DataAnnotations namespace. These attributes help Entity Framework understand how to map our class properties to database schema columns and create relationships. While we’re not discussing Fluent API or EF in detail right now, we are simply referencing the tools we use.

Since we have finished the Book class and mentioned the Author there, let’s also create the Author class.

[CCController]
public class Author
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid Id { get; set; }

    [Required]
    [MaxLength(100)]
    public string Name { get; set; }

    [Required]
    [Range(0, 120)]
    public int Age { get; set; }

    // Navigation property: One author can have many books
    public ICollection<Book>? Books { get; set; }
}

Yes, that's it, folks! Believe it or not, we now have e a "fully” functional API ready to serve our needs. It includes all the CRUD operations that we would typically write manually and it is ready for testing. Simply just run dotnet run <your api-project> and open swagger in the browser… if you have it configured, of course. :)

Something like this should pop up:

Filtering, Sorting, and Pagination

Now only that, but our read operation come along with features for filtering, sorting, pagination, and database manipulation. And yes, they all work!
Here’s an example of what a GET request for books looks like:

The result:

In the query, we have a limit of 3, sorted by YearPublished in ascending order.

Here is an example for filtering, can be done for any property:
We are asking for books that are published in 2019.

The result

We have retrieved the books that have been published 2019, this query can also be combined with sorting, we can limit our picks and we can add pagination.

What is this magic? Where can I find the controllers’ code?

This will definitely make it onto the FAQ list, so here it is: It’s located in the /obj folder generated at compile time, specifically during the C# build process. As for any other IDEs, it’s typically found under Dependencies/Source Generators/.

For VS Code, you can load it from the/Generated folder under /obj, but previously, you had to modify your .csproj like this:

<PropertyGroup>
    <!-- This for setting the path to find your source generated files -->
    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
    <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\Generated</CompilerGeneratedFilesOutputPath>
</PropertyGroup>

Can I debug the code?

Yes, fully; just locate the files from the section above and place breakpoints.

Can I change the implementation?

No, unfortunately, you cannot change the implementation, but you can definitely extend your controller by adding code to your implementation. For instance, if we had a system to rent books, we would want to incorporate that functionality. Just ensure you declare it as a partial class, something like this:

namespace CCApi.WebApiExample.Controllers;

public partial class BookController
{
    [HttpGet("rent/{id}")]
    public async Task<IActionResult> RentBook(Guid id)
    {
        var book = await dbContext.Books.FirstOrDefaultAsync(book => book.Id == id);
        // rent the book.
        return Ok(book);
    }
}

This will register it under the same BookController, and swagger will recognize it and display it in the same section.

What happened? How did this code end up here?

Simply put, this package utilizes the C# Source Generators, which is how it’s building our API in the background.

How to Install

It’s fairly easy! Just add the NuGet package by running the command below, and happy coding! No real dependencies, just a dotnet-api project with <TargetFramework>8.0</TargetFramework>.

dotnet add package Codechem.Dappi.Generator --version 1.0.0

Note: The package is not yet deployed, will be within the next couple of days

Final Thoughts

Yes, I plan to develop this further and make it production-friendly. I hope to help many developers and save their time, potentially even creating a GUI. It’s not a replacement for custom solutions but a big leap forward in saving time and reducing boilerplate.

Until then, I hope some of you will try this package and build something good with it. I am open to feedback, suggestions, and contributions, so please reach out to me at dule@codechem.com.

Until next time, stay curious and keep exploring!

Dule Pop-Andov

TL;DR:
This blog post explores the implementation of OpenVAS (Open Vulnerability Assessment System) to enhance our company's network security. If you’re interested in a deeper dive into the process, I’ve written a detailed paper on the subject, which you can refer to for more in-depth insights.

Initially, OpenVAS was set up on a Linux VM. Several scan types were configured, including host discovery, full/fast scans, authenticated scans, and CVE scans, which helped identify critical and minor vulnerabilities. The tool's detailed reports prioritized remediation efforts.

After testing, the setup was moved to a dedicated on-premise server for better reliability and performance. As things progress, automation and integration with other security tools are planned to streamline vulnerability management. OpenVAS proved to be a valuable, cost-effective solution for identifying and mitigating security risks in corporate networks.

While the tests also show potential false positives, having automated security scanning can prove invaluable with a proper process in place for scanning and triage.

Introduction

In today’s interconnected world, cybersecurity is more critical than ever. You might never think your company will be the target of a cyber attack, but you can never rely on beliefs.

Organizations face constant cyberattack threats, making a robust vulnerability management system essential for safeguarding sensitive information. OpenVAS (Open Vulnerability Assessment System), a powerful open-source vulnerability scanner, can be a pivotal tool in securing your network.

In this blog post, I will walk you through implementing OpenVAS in a corporate network environment, discussing its setup, findings, challenges, and benefits.

What is OpenVAS?

OpenVAS is a comprehensive vulnerability scanning tool designed to identify potential security risks in a network. It performs detailed assessments by scanning various devices, ports, and applications for vulnerabilities. It also provides valuable insights through generated reports, allowing security teams to prioritize remediation based on the severity of the risks.

The flexibility of OpenVAS makes it a strong candidate for organizations looking for a cost-effective, open-source solution to monitor their network's security posture continuously.

Getting Started With OpenVAS: Setup and Configuration

The first step in implementing OpenVAS was setting up the tool on a macOS machine. However, due to networking restrictions with Docker on macOS, I faced challenges giving OpenVAS access to the network from the container. After several attempts using custom bridges and VLANs, I decided to set up a Linux VM running Ubuntu, which worked seamlessly with Docker, enabling me to deploy OpenVAS without any issues. The docker-compose.yml I was using can be found here.

An important thing to note is that to each container, network_mode: "host" should be added to allow all the containers to be treated as separate machines in the network. The point is that they get a private IP Address from the local network, allowing them to ping all devices inside this network.

With OpenVAS running on the Linux VM, I could begin scanning CodeChem’s network to identify vulnerabilities. I configured OpenVAS to scan two subnets within the network (192.168.0.100/24 and 192.168.0.101/24), ensuring that it covered the entire range of addresses managed by the router. This initial scan uncovered valuable information, such as operating systems, ports, applications, CVEs, and certificates, which were ranked based on their severity.

Scans: Types, Setup, and Results

One of the most important features of OpenVAS is its scan types and how they can be configured to meet specific needs for vulnerability assessments. I configured several types of scans for our network to ensure thorough vulnerability detection.

Defining Targets and Network Segmentation

I began by selecting two subnets (192.168.0.100/24 and 192.168.0.101/24) to scan, covering all devices connected to our network, including servers, workstations, and networked devices. It ensured that every device would be included in the vulnerability scanning process.

Host Discovery

The first task was a Host Discovery scan to identify all active devices on the network. This scan helped create a comprehensive inventory of devices essential for targeting future vulnerability scans.

Full and Fast Scans

Next, I performed Full and Fast Scans across the network. The Full Scan checked for vulnerabilities like missing patches, open ports, and configuration errors, while the Fast Scan focused on critical issues. These scans uncovered important findings, including a brute-force attack on a VNC Remote Control service. OpenVAS identified the weak password, allowing us to act quickly and secure the device.

Authenticated Scans

I set up Authenticated Scans on critical systems like web servers and databases for deeper insights. These scans required valid credentials, enabling OpenVAS to detect vulnerabilities not visible from the outside, such as misconfigurations and outdated software.

CVE Scan Tasks

To ensure no known vulnerabilities were missed, I created CVE Scan Tasks, which specifically checked for critical vulnerabilities cataloged in the CVE database. These scans were vital for systems exposed to the internet, like public-facing web servers.

Fine-Tuning the Scan Process

After initial scans, I refined the process by scheduling daily scans at 7:00 AM and configuring email alerts for critical vulnerabilities. This automation ensured continuous monitoring without manual intervention.

Generated Reports

Each scan generated detailed PDF reports that listed vulnerabilities, categorized by severity, and offered actionable remediation steps. These reports helped our security team prioritize fixes and strengthen the network's security posture.

The results from these scans were detailed and comprehensive, with OpenVAS identifying both critical vulnerabilities that required immediate attention and minor issues that could be addressed over time. For example, some critical findings included outdated software versions with known exploits, while minor findings were related to less severe configuration issues.

Here’s an example of one of the generated reports, which visually breaks down the scan results:

These detailed reports helped prioritize remediation efforts based on severity, allowing the security team to address the most pressing vulnerabilities first.

Transitioning to an On-Premise Setup

While the initial configuration on the VM was successful, I realized that for OpenVAS to perform daily scans and provide continuous monitoring, it needed to be moved to a dedicated on-premise server. Running OpenVAS on a VM can be unstable, especially if the virtual environment encounters resource limitations. Moving to an on-premise machine offered the following benefits:

1. Reliability: The server would always be available, ensuring scans ran without interruptions.

2. Performance: On-premise hardware offered more control over resources, allowing OpenVAS to handle larger networks and more complex scan tasks.

3. Scalability: As the network grows, the on-premise setup can be upgraded to meet increasing demands.

Once the transition was made to the dedicated server, OpenVAS was successfully set up and configured to run daily scheduled scans. This setup will ensure that our network remains continuously monitored, providing regular reports and timely alerts whenever vulnerabilities are detected.

The Next Steps: Automating and Integrating OpenVAS

With OpenVAS now running on an on-premise server, the next steps involve automating the vulnerability management process. These include:

• Automated Remediation Workflows: Implementing automated processes to address vulnerabilities once identified, reducing the need for manual intervention.

• Integration with Other Security Tools: Enhancing OpenVAS's capabilities by integrating it with other security tools used in the company, creating a more cohesive security strategy.

These additional features will help streamline the vulnerability management process, improve response times, and strengthen the organization’s security infrastructure.

Conclusion

In summary, implementing OpenVAS within a company’s network environment has been a rewarding and educational experience. The tool's ability to perform thorough vulnerability scans, generate detailed, actionable reports, and offer customized scanning options makes it an indispensable asset for any organization's cybersecurity framework.

While OpenVAS is a cost-effective and open-source solution, it’s important to note that it does come with some challenges. These include occasional performance limitations when scanning larger networks and the need for manual intervention to handle false positives. However, its flexibility, scalability, and robust reporting features make it an essential part of a comprehensive vulnerability management system.

The transition to an on-premise setup ensures that OpenVAS can continue to monitor the network reliably and efficiently. As the next step, I plan to focus on automating remediation workflows, integrating OpenVAS with other security tools, and fine-tuning the system to adapt to evolving threats.

By adopting OpenVAS as part of a broader security strategy, organizations can enhance their defenses, mitigate risks, and reduce the potential impact of cyber threats.

The Old Way

Strapi’s docs on using the REST APIs, including its many features are quite extensive and well-explained, even for complex usecases. To sum it up, the way the REST API handles data querying is by mimicking a database query engine, which is very powerful and allows us to write queries like this:

{
  filters: {
    $or: [
      {
        date: {
          $eq: '2020-01-01',
        },
      },
      {
        date: {
          $eq: '2020-01-02',
        },
      },
    ],
    author: {
      name: {
        $eq: 'Kai doe',
      },
    },
  },
}

Then to make the call you make a GET request by using qs to stringify this into a URL-friendly query string, and you get:

filters[$or][0][date][$eq]=2020-01-01&filters[$or][1][date][$eq]=2020-01-02&filters[author][name][$eq]=Kai%20doe

Now it’s getting sticky.

This way of building queries is quite powerful, but can become very unwieldy when we want to express something in a more programmatic fashion; we have to spread a bunch of JSON objects on a bunch of different depths which can become very painful, very fast.

The “new” way - a fluent query builder

As is tradition in the JS ecosystem when you run into a problem - you build a library.

The goal behind developing this library was simple: to streamline the process of building dynamic, complex queries with a fluent, easy-to-understand API. Whether you’re querying content for a blog, managing a large product catalog, or building a custom CMS with intricate relationships, this library should make working with Strapi’s REST API significantly more efficient.

While Strapi Fluent Query Builder is designed with Strapi in mind (it’s in the name), it’s also meant to be agnostic—it should theoretically work with any RESTful API that adheres to similar conventions. (if you know of any, let me know :))

Let’s take the example we looked at in the previous section:

{
      filters: {
        $or: [
          {
            date: {
              $eq: "2020-01-01",
            },
          },
          {
            date: {
              $eq: "2020-01-02",
            },
          },
        ],
        author: {
          name: {
            $eq: "Kai doe",
          },
        },
      },
    };

The equivalent of this code with the query builder would be:

query("blogs")
  .where("author.name.$eq", "Kai doe")
  .or({
    date: {
      $eq: "2020-01-01",
    },
  })
  .or({
    date: {
      $eq: "2020-01-02",
    },
  });

While it’s not a lot less code, it does provide us with a JS/TS API for interacting with the parameters we want to send to our API, this means we can chain calls and perform any other operations as we would with any other builder.

Key Features

1. Fluent API for Easy Query Building

One of the standout features of the Strapi Fluent Query Builder is its fluent API. This allows you to chain methods in a clean and readable way, making query building intuitive and reducing the need for boilerplate code. You can focus on what you're querying, not how to format the query.

Example:

const result = query('books')
    .where('title.$contains', 'example')
    .sort('createdAt', 'desc')
    .page(1)
    .pageSize(10)
    .get();

2. Advanced Filtering Capabilities

The library offers a flexible filtering system that supports multiple filter types, such as equality ($eq), inclusion ($in), and string matching ($contains). You can easily apply logical operators ($and, $or, $not) to combine multiple conditions and create complex filtering logic.

Example:

const result = query('templates')
    .or({ title: { $eq: 'test' } })
    .or({ tags: { $in: [1, 2, 3] } })
    .get();

This will match either the templates that have exactly the title ‘test’ or that contain the tags 1, 2 or 3.

3. Sorting and Pagination

With the library’s sorting and pagination features, you can precisely control how results are returned. Whether you're displaying a list of blog posts or product pages, you can easily sort by multiple fields and control pagination parameters (e.g., page size, start index).

Example:

const result = query('templates')
    .sort('createdAt', 'desc')
    .page(1)
    .pageSize(10)
    .get();

4. Population of Relations

Strapi allows for complex relationships between content types (e.g., one-to-many or many-to-many). With the populate method, you can easily fetch related content along with the main resource in a single query. The library also supports nested relations, meaning you can populate relations within relations, with filtering options to optimize your queries.

Example:

const result = query('books')
    .populate('author')
    .populate('author.friends');

Even populating with sorting and filtering is supported

Let’s take for example the more complex samples from the Strapi docs:

Here’s the QS generated query string:

GET /api/articles?populate[categories][sort][0]=name%3Aasc&populate[categories][filters][name][$eq]=Cars

It was created using the following piece of code:

const qs = require('qs');
const query = qs.stringify(
  {
    populate: {
      categories: {
        sort: ['name:asc'],
        filters: {
          name: {
            $eq: 'Cars',
          },
        },
      },
    },
  },
  {
    encodeValuesOnly: true, // prettify URL
  }
);

With our query builder it’s as simple as:

query("products")
  .populateQ("categories", (q) =>
    q.sort("name", "asc")
     .where("name.$eq", "Cars")
  );

5. Content Status & Localization

The ability to filter content by its status (e.g., published or draft) is crucial for content management. The Strapi Fluent Query Builder makes this easy with dedicated methods to retrieve content based on its publication state. Additionally, it supports querying content in different locales, which is useful for building multilingual applications.

Example:

const result = query('templates').published();  // Fetch only published content
const result = query('templates').locale('en'); // Query content in English

6. Field Selection

Another powerful feature is field selection. You can specify exactly which fields to retrieve from the API, reducing unnecessary data in the response and improving application performance. This is especially useful when working with large datasets.

Example:

const result = query('templates').fields('id', 'title', 'description');
// select is equivalent to fields, it just exists as a more descriptive name
const result = query('templates').select('id', 'title', 'description');

7. Transform your built query into anything you need

You can get the output of the query builder into the following:

• To JSON by calling .json() when you’re done building, it will give you a stringified version of the query in JSON form.

• As an object by calling .get(), this will return the fully built JavaScript object.

• As a query string only by calling .qs(), this will only return the query string part of the URL.

• As a full URL (path + query string) by calling .full().

8. Type Safety with TypeScript

The library is built with TypeScript to ensure full type safety across all query operations. This not only helps with autocompletion and error checking during development but also ensures that you’re working with well-structured data when building queries, even when populating nested relations.

While far from perfect, it tries to provide you with as good a guess as possible on your structure without getting in your way.

Why You Should Use It

Let’s go back and reiterate on what you would get by using the query builder instead of creating filters manually:

• Cleaner Code: By chaining methods together, you can create complex queries with minimal boilerplate.

• Easier Maintenance: The fluent API makes it easier to read and maintain queries, especially when working with dynamic or variable conditions.

• Flexibility: Although optimized for Strapi, this library is agnostic and can be used with any RESTful API that follows similar conventions.

• Unopinionated: It helps you cobble together the requests, nothing more, nothing less, bring your own way to make requests and go to town.

• Very good coverage: I don’t have a percentage for you, but the vast majority of operations that are possible by creating a filter manually should be possible with this builder. Aiming at 100%, if you find an incompatibility, feel free to open an issue, or even better - a PR on the GitHub repository.

How to Get Started

Getting started with Strapi Fluent Query Builder is quick and easy. Simply install the package via npm or yarn:

npm install @codechem/strapi-fluent-rest-api

Or:

yarn add @codechem/strapi-fluent-rest-api

Once installed, you can start building queries like never before. Here’s a simple example:

import { query } from '@codechem/strapi-fluent-rest-api';

const result = query('books')
    .where('title.$contains', 'example')
    .sort('createdAt', 'desc')
    .page(1)
    .pageSize(10);

const myData = await request.get(result.full());

The library supports a wide range of features and can be customized to fit your needs.

You can find the repository on GitHub and the package itself on NPM.

Playground / CodeSandbox

You can play around with the query builder below and list some of the events on 42.mk to get a feel of the API and its capabilities, 42.mk runs a version of Strapi 4.

If you want to chat about the library, feel free to find me on the Discord server of 42.mk.

Conclusion

I hope the Fluent Query Builder can help make working with the Strapi REST API easier, cleaner, and more efficient.

Feel free to explore the library, contribute to its development, and let me know how it improves your workflow!

I’m open to feedback, contributions and ideas, shoot me a message, comment, issue or whatever else comes to your mind. :)

Cheers,

Ilija

Gather around the heart, people! We’re about to take you on a journey through our amazing team-building trip to Nikiti, Greece! 🙌🏼 Let’s face it: team building can, quite frankly, be bland! To prove you wrong, we’ll go through these 200 passages! 📖 Joke aside, there are only a few, and it will take up to 10 minutes of your precious time!

Now, let’s go through it!

Day 1: The Beginning

We gathered at the bus stop early Friday morning with our luggage in hand, ready to roll at 08:00 sharp. 🕗 Knowing it’s rocket science for us to be on time, we left at 08:30. 🤣 Only half an hour late, but a record when dealing with so many people! We all have our flaws, but 100+ people to be on time is a mission impossible. However, we made it possible, and with the fantastic team from Simbiotika, we were officially ready to be “team-built.” 🎉

Games on the Go

The bus ride wasn’t just any trip; it was more like a party on wheels. 🥳 During it, we played “Who am I?” where everyone tried to guess the mystery person, no matter if it was a colleague or a celebrity. Things escalated quickly into chaotic fun as we scrambled to guess when some celebrity photos popped up!

Next, we were thrown into a survival scenario, imagining ourselves stranded in the middle of the ocean in a boat. 🚨 Spoiler alert: If this had been real, we’d be long gone by now. Thank goodness it was just a game! 😆

Angels Among Us: The Secret Angel

Simbiotika also introduced us to the “Secret Angel” game, and it’s like they truly knew us because taking care of each other is what we do best at CodeChem. Everyone had a secret angel looking out for them, doing little acts of kindness. 💞

It reflects how we support each other, whether grabbing a coffee ☕ for a colleague or offering a listening ear when someone’s down. And yes, even though “we’re a family” 🙄 sounds cringy, we spend so much time together at work that it feels spot on.

But let’s get back to the subject! ✍🏼

Finally There: First Beach Impressions

We arrived in Nikiti in the afternoon, checked into the hotel, and headed straight for the beach without missing a beat. Our initial reaction? The beach was fantastic, and the view was absolutely breathtaking. 🏖️ After a tiring journey, we decided to take it easy and plan activities everyone could enjoy.

Whether it was volleyball, frisbee, archery, spike ball, swimming, or just lounging on the beach, 🏐 🏹 🥏 🪷 🪸it was amazing to see everyone getting involved in the fun. The sunset was spectacular, and thanks to the talented photographer, we have some postcard-worthy photos to remember it by. 📸 🌆 ✨

Hula and Limbo Madness 🌺💮💃

Did we go to Hawaii, or was it still Nikiti? Yup, we had a themed party, dressed in traditional Hawaiian Leis and haku leis, and had a competition in Hula dance. Turns out, our dance moves are out of this world. But that wasn’t all; we also had a Limbo contest.

Shoutout to Alek, the most flexible person on the planet, for dominating the Limbo!

The night wasn’t over after the dancing. Board games kept the energy alive, and it was amazing to see how conversations and laughter flowed even between people who had only known each other over a short period of time.

Day 2: The Shipwrights

Day two started with breakfast, salty coffee included because, you know, the tap water in Nikiti is a little bit salty. 😂 🚰 We tried to see the bright side, though, treating it as an extra dose of electrolytes to supercharge our bodies for the day ahead. With our energy levels high (thanks, salty coffee!), Simbiotika divided us into teams for the “Cardboard Boat Building Challenge” with a twist. 🤔

While each team received specialized equipment, tools, and detailed blueprints for crafting their boats, we also had to hunt for hidden objects on the beach to complete our creations. A little scavenger hunt never hurt anyone, right?

One thing’s for sure: we get seriously competitive when it comes to any challenge. But despite the rivalry, we’re always fair and polite, and believe it or not, we still love each other! Of course, that doesn’t mean we didn’t pull out all the stops to win. 🌟💪🥇

When the boats were finally built, it was clear that teamwork truly made the dream work. Not only did every boat float, but the creativity in their design and execution was impressive. 🛶 🛠️ The flags waved proudly, and the team names? Hilarious! We had everything from the prehistoric "Nendertalci" to the not-so-optimistic "Titanic." ⚐

And the Winner Is…

Congrats to “Brodolom” who won the first place! 🥇 Milan definitely nailed the sweep rowing skills, 🚣 but let’s not forget that every team member played a crucial role; just like in our work, cooperation was vital because your boat is bound to sink without it.

The fun didn’t end there! After the boat race, we dove into the Beach Olympics, with different teams battling for the top spots. Post-Olympics, we split into three groups to tackle the next set of challenges. 🎖️

Artistic Avant-Garde

There was one cool corner near the pool bar where Simbiotika set up a whole place for “Paint & Sip,” which also had a twist; everything about this team building was with a twist. 🎨🍷 It was hilarious and heartwarming to see how our colleagues interpreted us. Some arts were true masterpieces, while others… well, let’s just say they belong in a meme gallery! 🤭🥰🙈

CodeChem Survival

One group ventured off into the wilderness (well, not too far) to learn some essential survival skills. We learned how to orient ourselves if we got lost in the great outdoors and Bojan from Simbiotika taught us how to set up a tent, 🏕️ pack for backpacking, ⛰ and, best of all, try military food. It might not have been gourmet, but hey, at least we know how to set up a tent for the next music festival or survive a surprise adventure. 𓆝 𓆟 𓆞 𓆝 𓆟

Exploring Emotional Intelligence

The opportunity to explore emotional intelligence in a truly engaging way was great. Lazar from Simbiotika led an interesting workshop where we learned that emotions can be powerful assets when understood and managed correctly. 🫶🏻 One key takeaway was that if you're struggling to identify an emotion, you should pause, close your eyes, reflect on your feelings, and then define what’s happening internally. 😌

Empathy as Strength

We also discussed how empathy, far from being a weakness, allows us to better understand the motivations behind people’s actions. 💞 However, knowing your limits is important, as well as ensuring that empathy doesn’t lead you to repeat the same mistakes or situations.

Lazar emphasized the importance of balancing emotions in decision-making—knowing when to lead with your heart ❤️ when to rely on your head,🧠 and, more importantly, how to combine both effectively.

Understanding and Helping Others

Emotional intelligence, at its core, involves helping others by not dismissing their words but by truly stepping into their shoes, understanding their perspective, and then, if possible, offering support. 🤝 Sitting by the beach, we practiced active listening techniques and discussed how emotional intelligence enhances team dynamics.

Despite the workshop’s intensity, the open discussions made it a memorable experience. Afterward, we treated ourselves to a refreshing swim, soaking in the warmth of the Indian summer. 🌊 It was the kind of moment that made you pause and appreciate both the company and the calm, a perfect balance to all the heavy lifting we’d done with our emotions earlier.

Coachella: The Surprise on the Agenda

When we saw "Coachella" on the agenda, questions buzzed—what could it mean? Soon enough, we got some festive outfits again from Simbiotika, 🎊 and the event started with a twist—a Kahoot quiz about how well you know your colleagues. It was a personal and, yes, fiercely competitive challenge that had everyone on edge, revealing just how much (or little!) we all knew about each other.

Balloons & Battles: Let the Games Begin

The evening escalated with even more fun and games: cup stacking with balloons, a hilarious Head-Hoop Basketball challenge, and the ultimate showdown: a Dance Battle! 🎈💃🎈

In pairs, we had to keep a balloon between us while dancing to various music genres. The last couple that managed to keep the balloon intact the longest won the battle without it popping or falling. Of course, there were prizes, medals, and loads of laughter as the night progressed.🏅🏅🏆🏆

Bioluminescense, Adolescence

As the party continued under the stars, the vibe turned into a beachside jam session. 🏖️ Instruments came out, 🎸 songs were sung, ♫♫ and stories were shared. Midway through, someone noticed the algae glowing in the water and dropped the news like it was no big deal. 🌊✨✨🌱 ✨

Turns out, those glowing dinoflagellates are pretty important marine microbes. They light up when something strange happens in their environment, kind of like us after too much karaoke. 🎤 🎙 Luckily, only a few species are actually toxic, so we were safe.

Plus, did you know that 70% of marine animals produce bioluminescence, too? Some use it to attract prey, others to navigate the deep waters. Pretty cool stuff, and no, this wasn’t just the wine talking. For the science nerds among us, here’s a research to dive deeper!

Day 3

The Return: Reflecting, Relaxing and Heading Home

We started the final morning with a peaceful yoga session, during which a few of our colleagues stretched out and embraced the tranquility of the early hours. 🤸‍♀️🧘‍♀️ You could tell how relaxed they were; some even showed up in their pajamas (because why not?) 🛏️

After breakfast, we gathered for a closing talk—sharing impressions, reflections, and lessons learned. It was heartening to see everyone fully engaged as we reinforced our commitment to supporting each other. This team-building experience will stay with us long into the future. 💫

We began our journey back to Skopje with everything packed and checked out. The bus ride was filled with laughter and games, particularly a never-ending association game where "Is it Galichica?" became the running joke; 🤣🤣 someone would ask, another didn’t hear, so they’d ask again, keeping the fun going. Meanwhile, the other bus turned into a lively sing-along, making those five hours fly by in a flash. 🎤♫⋆｡♪ ₊˚♬ﾟ.

Conclusion: A Journey to Remember

As we wrapped up our adventure, it was clear this trip was more than just team-building. It was an unforgettable journey that brought us closer in unique and fun ways. From the competitive games and hilarious moments to the deep emotional discussions and early yoga sessions, we experienced it all, and we did it together.

Big thanks to Simbiotika for organizing such an unforgettable experience and for taking care of us every step of the way. You somehow managed to bring us even closer together while keeping up with our endless jokes, endless energy, and so many different personalities! But we could tell you were having just as much fun as we were… and that’s saying something!

Here’s to more adventures, unforgettable memories, and even stronger teamwork in the future!

And for those who missed the fun (or just want to relive it), here’s a video capturing all the best moments of the chaos. Trust us, it’s definitely worth the watch! 🎥 😂

❤️, CodeChem

Hey there! Welcome back to our Infrastructure as Code series on the CodeChem blog! 👋

If you missed our last article on the topic of Managing Azure Services & Resources, definitely give it a read first. But don’t worry, you can dive into this one right away because today we’re talking about something exciting—Microsoft’s new, declarative language: Bicep! 🦾

After a brief introduction, we’ll explore a practical example of how to create everything you need to deploy and host a full-stack application using Bicep!

Let’s get started!

What’s Bicep?

Bicep is a domain-specific language (DSL) created by Microsoft for deploying and managing Azure resources. Throughout the development lifecycle, you can utilize a Bicep file to define the infrastructure you want to deploy to Azure and then repeatedly and incrementally deploy it. This guarantees consistent deployment cycles of your resources.

What makes Bicep stand out is its code reuse assistance, dependable type safety, and clear syntax. Bicep provides top-notch authoring for your Azure infrastructure-as-code solutions and it offers a much better developer experience.

Benefits of Bicep

Let’s talk about what makes Bicep awesome and why I’m a big fan:

• Support for all resource types and API versions: If you didn’t know, every Azure resource is controlled through its respected API. When a resource provider introduces new resource types and API versions, you can use them in your Bicep file. No waiting around for updated tools, just jump in and go.

• Simpler Syntax, Happier Developer Life: If you’ve ever wrestled with JSON templates, you know the struggle is real. They’re long, clunky, and prone to errors. Bicep, though, feels like a breath of fresh air—simple, clear, and so much easier to work with. You don’t need to be a coding wizard to understand it; the syntax is clean and declarative, so you just describe what you want to deploy. Easy-peasy!

• Modularity: Keep Your Infrastructure Organized and Scalable: One of the cool things about Bicep is its modularity. You can easily break your resources into multiple Bicep files and manage them with modules, giving you the flexibility to keep everything neat and organized. I prefer keeping all of my infrastructure in a single main.bicep file. However, if you use a lot of resources and get to a point where the file gets too bulky, no problem, just split it up!

• Seamless integration with Azure services: I mean, of course, right? Bicep was born for Azure, so it’s no surprise that it plays perfectly with all Azure services. The language was created to deploy.

• Preview changes: You can use the what-if operation to get a preview of changes before deploying the Bicep file, much like the git diff command.

• Repeatable results: Bicep files are idempotent. Repeatedly deploy your infrastructure throughout the development lifecycle and have confidence your resources are deployed in a consistent manner.

• Orchestration: You don't have to worry about the complexities of ordering operations. Resource Manager orchestrates the deployment of interdependent resources so they're created in the correct order.

How to Create the Resources Needed to Deploy Your Full-Stack Application?

Note: Before we dive into the details, here’s a quick note: The code formatter here doesn’t support Bicep syntax highlighting. For the best experience, I recommend installing the official Microsoft Bicep extension and opening the file in VS Code. It’ll make everything much easier to read and work with!

Now, let’s get into how to set up all the resources you need for deploying and hosting your full-stack application using Bicep.

bicep

// Parameters
param location string = resourceGroup().location
param appServicePlanSku string = 'P1v2'
param sqlServerAdminLogin string = 'adminuser'
param sqlServerAdminPassword string = 'P@ssword123!'
param databaseName string = 'appdb'
param frontendAppName string = 'frontendstaticapp${uniqueString(resourceGroup().id)}'
param backendAppName string = 'backendapp${uniqueString(resourceGroup().id)}'
param sqlServerName string = 'sqlserver${uniqueString(resourceGroup().id)}'
param keyVaultName string = 'keyvault${uniqueString(resourceGroup().id)}'
param staticWebAppSkuName string = 'Free'
param staticWebAppSkuTier string = 'Free'

// Resource: Static Web App for our Frontend
resource staticWebApp 'Microsoft.Web/staticSites@2022-03-01' = {
  name: frontendAppName
  location: location
  sku: {
    name: staticWebAppSku
    tier: staticWebAppSkuTier
  }
  properties: {
    repositoryUrl: 'https://github.com/your-org/your-repo' // GitHub repo containing frontend code
    branch: 'main'
    buildProperties: {
      appLocation: 'app' // Directory containing the frontend app
      apiLocation: '' // Optional: leave empty if no API is required here
      outputLocation: 'build' // Output directory for the frontend app
    }
  }
}

// Resource: App Service Plan for our Backend
resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: 'appServicePlan${uniqueString(resourceGroup().id)}'
  sku: {
    name: appServicePlanSku
  }
  kind: 'linux'
}

// Resource: Backend App Service
resource backendApp 'Microsoft.Web/sites@2022-03-01' = {
  name: backendAppName
  location: location
  serverFarmId: appServicePlan.id
  httpsOnly: true
  dependsOn: [appServicePlan]
  siteConfig: {
    appSettings: [
      {
        name: 'APPINSIGHTS_INSTRUMENTATIONKEY'
        value: applicationInsights.properties.InstrumentationKey
      }
      {
        name: 'SQL_CONNECTION_STRING'
        value: sqlDbConnectionString
      }
      {
        name: 'KeyVaultUri'
        value: keyVault.properties.vaultUri
      }
    ]
  }
}

// Resource: SQL Database
resource sqlDatabase 'Microsoft.Sql/servers/databases@2022-02-01-preview' = {
  name: '${sqlServerName}/${databaseName}'
  location: location
  sku: {
    name: 'S1'
    tier: 'Standard'
  }
}

// Resource: SQL Server
resource sqlServer 'Microsoft.Sql/servers@2022-02-01-preview' = {
  name: sqlServerName
  location: location
  administratorLogin: sqlServerAdminLogin
  administratorLoginPassword: sqlServerAdminPassword
  version: '12.0'
}

// Resource: Key Vault
resource keyVault 'Microsoft.KeyVault/vaults@2021-06-01-preview' = {
  name: keyVaultName
  location: location
  properties: {
    sku: {
      family: 'A'
      name: 'standard'
    }
    tenantId: subscription().tenantId
    accessPolicies: [
      {
        tenantId: subscription().tenantId
        objectId: 'your-principal-object-id' // Replace this with your Object ID for access
        permissions: {
          secrets: [
            'get'
            'list'
            'set'
          ]
        }
      }
    ]
  }
}

// Resource: Application Insights
resource applicationInsights 'Microsoft.Insights/components@2021-04-01' = {
  name: 'appInsights${uniqueString(resourceGroup().id)}'
  location: location
  kind: 'web'
  properties: {
    Application_Type: 'web'
  }
}

// Output connection details
output sqlDbConnectionString string = 'Server=tcp:${sqlServerName}.database.windows.net,1433;Database=${databaseName};User ID=${sqlServerAdminLogin};Password=${sqlServerAdminPassword};'
output frontendAppUrl string = 'https://${staticWebApp.defaultHostname}'
output backendAppUrl string = backendApp.defaultHostName
output keyVaultUri string = keyVault.properties.vaultUri

Quick Summary

The example bicep file will provision the following resources:

• Static Web App: Hosting the frontend app;

• Backend App Service: Hosting the backend services;

• SQL Server & Database: Hosting the SQL Server and the app's database;

• Key Vault: For securely storing secrets;

• Application Insights: For monitoring the frontend and backend services.

This is the basic infrastructure for a full-stack application with essential resources. You can modify and extend this according to your specific requirements. The Static Web App, Backend App Service, and the SQL Server & Database are all you need. The Key Vault and Application Insights are optional but nice to have.

At the end of the bicep file, we have some output values. You can return output variables valuable to you for subsequent scripts in the pipeline or the application itself, e.g. the sqlDbConnectionString or the backend API URL.

Keynotes to Keep in Mind

The order in which the resources are declared in the bicep file doesn’t matter. For example, notice how we declare the SQL Server after the SQL Database. Of course, we can’t create the SQL Database before provisioning the SQL Server. The Azure task that executes your compiled bicep code is smart enough to know the order in which it has to provision the resources. If you want to ensure your order is followed, there is an optional parameter called dependsOn, which takes an array of resources. You can see this in the backendApp resource, where we say, “this backendApp depends on the appServicePlan resource.”

For the sake of simplicity, you might’ve noticed some of the declared parameters really shouldn’t be hard coded. Or, at least, not be a part of the bicep file. That’s true, most if not all parameters should be input parameters from the pipeline. For example, they should be declared as Azure Pipeline variables and passed to the bicep file.

Never expose sensitive information in your bicep file. Your bicep file is version-controlled and should be treated like any other file you keep in your remote repository.

Bicep also offers the @secure() annotation. When you set a parameter to a secure string or secure object, the parameter's value isn't saved to the deployment history and isn't logged. However, if you set that secure value to a property that isn't expecting a secure value, the value isn't protected.

Deploying Your Resources

After you have defined your bicep file and declared your necessary resources, it’s time to deploy! You’re going to need the AzureResourceManagerTemplateDeployment@3 task in your Azure Pipeline.

Example:

- task: AzureResourceManagerTemplateDeployment@3
         inputs:    
           deploymentScope: 'Resource Group'
           azureSubscription: '${{ parameters.azureServiceConnection }}'
           action: 'Create Or Update Resource Group'
           resourceGroupName: 'exampleRG'
           location: '<your-resource-group-location>'
           templateLocation: 'Linked artifact'
           csmFile: './main.bicep'
           deploymentMode: 'Incremental'
           deploymentName: 'DeployPipelineTemplate'
           deploymentOutputs: deploymentOutputs

This task will deploy the resources declared in the main.bicep file in a Resource Group. The deployment mode is ‘incremental’ to update existing resources and provision new first-time ones. Also, all the output variables will be available in the deploymentOutputs object.

Final Thoughts

I hope the example bicep file and example deployment task were useful to you! This is just the tip of the iceberg if you want to use Bicep in your CI/CD pipelines! In this article we explored deploying with Azure Pipelines, but you can also use Bicep in GitHub Actions! I’ve provided some additional reading material. And remember—when working with Bicep, the official Microsoft documentation is your best go-to guide.

Happy deploying!

Resources

• Bicep Documentation (https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/)

• Deploy Bicep files by using GitHub Actions (https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-github-actions?tabs=CLI%2Cuserlevel)

At our recent party, our colleagues reflected this Tudor theme with a Romanian accent through their costumes, looking so convincing that they could have easily traveled back in time. Their hilarious costumes won the best group costume award for April Fools' Day.

Are you sure this isn't Elizabeth I in the pictures? :) Or her mother, hand in hand with her husband, accompanied by the striking beauty of Vlad’s wife and Vlad himself?

The party had this cool Western theme going on, with cowboys tossing their hats around. And can you believe it? We could still hear Mandark's laughter, Dexter's biggest rival, echoing throughout the place. Are we still in Dexter’s laboratory?

There was also an Asian corner where we got to experience some traditional clothing. Oh, and not to forget the Lipton tea group mask that brought nature to us while we had to keep an eye out for the pirates, who are known for their bad behavior of stealing stuff.

Kаде ми е HDMI кабелот? Кој го украде донглето од конференциска?

Ahoy!

We won't spill the beans about this year's best individual costume award, as we don't want to be kicked off social media, but let's talk about the awesome things these people did to make the event even more unforgettable!

A mixology station

Yup, the cocktails were out of this world! Our very own personal cocktail expert created a custom menu for us, and it was all just perfect. The music was on point, too - our famous DJ had us all dancing and singing along to his amazing playlists.

Let's not forget our show master and judoka—he definitely won the crowds with his hilarious jokes and incredible hosting skills. But then, out of nowhere, Hermione showed up and cast a spell, "*Evanesco!"* that made us all go home and disappear.

It's amazing, don't you think? CodeChem is hosting many important events, including Open Day, which will be held on May 11th this year at our offices. This is our biggest event and is an excellent opportunity for students in their 3rd or 4th year of study, especially those looking for internships and employment.

If this blog post made you want to be present on our April Fools' Day, or if you believe our culture and vibe match your skills and education, be sure not to miss the registration link for Open Day, which we will share very soon!

January has finally passed, and besides being so long and a month of empty pockets, we still have some great news to share. The Global Game Jam happened during the last week of January in Base42 - a mystic hackerspace that seems to be the place everyone’s crazy about.

Intro

For everyone unfamiliar, Global Game Jam is a worldwide event where participants gather to create games for fun. Game development enthusiasts from various backgrounds gather to create games in 48 hours. Organized by the Macedonian Game Initiative, this year's event brought together many newcomers, but also participants who attend every year. A small group of CodeChem’s crew also participated in the event, making it even more eye candy.

Read on as we are going to unroll some exciting events. Did our engineers push their limits? What were their goals, and who won what? Nope, we won’t reveal it. Sorry, but you must read this till the very last line of this blog post. I bet you have five minutes to spare and read something spellbinding.

The Layer Underneath the Jam

Let's dive deeper into the jam-packed action!

Picture Base42 buzzing with energy, the air thick with anticipation as participants eagerly awaited the announcement of making teams and an official start, setting the stage for what was to come. This time, the globally announced theme was revealed a week or so before the event: “Make Me Laugh,” and we bet everyone did.

The Interviews

When we interviewed the guys and asked them how they felt and what they thought of the event, we got one mutual answer: the atmosphere was crazy good, and this even came from Tomislav, who attended GGJ for the fifth time. They were all amazed by the event's success, but somehow, we managed to put all impressions in one place. As you continue to read, you'll have the opportunity to witness firsthand the incredible work they accomplished during the event.

Team Lama - Laughter Lord

The Best Dev: Gjorgji Dimeski 🏆

Gjorgji was surprised to find himself exceeding his expectations in so many areas of gameplay implementation. He was particularly happy that “Laughter Lord” perfectly embodied the "Make Me Laugh" theme with a certain amount of humor and wit. Although Team Lama was randomly chosen, this multiplayer browser game won an award, “The Best Dev,” in other words, team Lama used the best technologies for this Game, such as llama2, nest.js, angular, Tailwind CSS for animation, and so on.

The story revolves around a thrilling face-off between two players who battle it out by delivering humorous jokes that can make the powerful Laughter Lord chuckle. The game features a simple and user-friendly interface, where players can write their own jokes and unleash them on the Laughter Lord, each trying to top the other with their comedic skills.

Team Toilet Skibidi - Skibidi Toilet

Vasilaki's journey into Game Jam was quite unique compared to that of the other participants. He hadn't even planned on joining the competition, but something about the excitement in the air drew him in. Sitting on the sofa at Base42, he couldn't help but notice the toilet across from him. That's when inspiration struck - he decided to base his game on a true story and an existing meme where you keep the toilet door shut with all your extremities up. We have to admit - an amazing start for someone who didn’t even know the theme before.

Despite feeling exhausted from a long work day, Vasilaki was determined to turn his idea into a reality. He used his knowledge of blender to create 3D models applicable to Unity and write scripts for them with C#. Unlike some other participants, he preferred to work independently, so he acted as a one-man band throughout the competition. The endgame was so good that Vasilaki still works on Toilet Skibidi at home together with his sister, a talented 3D artist.

Conversely, of being the last to submit the game, Vasilaki brought the best from the day. From lending a helping hand to volunteers to networking with new people, this GJ was a lifetime experience for him. The creative mindset and the way the game turned out led Skibidi Toilet to be a candidate for “The Best Game Award.” It was a challenging but rewarding experience that he will never forget.

Team CBT - Laughing Stock

Next on this list is Tomislav Ignjatov, who attended Game Jam for the fifth time. Tomislav has a standard team for this event, so together with his gang, they nurture this tradition and consider it very important. They even attend similar events to GGJ, and their main goal is always the creativity and the fun times during the event, but most importantly, the ideas that are a great start to be developed in the future.

As mentioned earlier, although attending for the 5th time, Tomislav has never seen such an atmosphere as this year. The place was crowded, but it was tremendous and cozy. Enough about the atmosphere; let’s talk about the game that CBT created.

Laughing Stock is an auto-shooter-inspired game where the main character, an evil Demon Clown, converts the local villagers into minions by throwing balloons at them. In the left corner, you can see the health bar, which shows the status of the balloons, and also you can see the score in the other corner.

The CBT team used different technologies for this game, such as Wave Function Collapse, an algorithm that can generate procedural patterns from a sample image - in this case, a different map - and Godot - an open-source game engine and art by PixelArt. One key takeaway for Tomislav from this event was the importance of borrowing wisdom from other jammers, sharing experiences and techniques to overcome challenges more effectively, and elevating the quality of each game.

Team Clumsy Coders - The Last Laugh

The last team with the “Last Laugh” in this blog post is Clumsy Coders, where our engineers Angel Stojanov and Stefan Ivanovski created a 2D game together with other game designers and artists. Their team was also randomly chosen, but everyone had a specific role, and for them, the planning of the game and the idea were the driving force of this event.

The game interface perfectly pictures the story behind it. So, let’s get into this incredible narrative. To be fair, I really liked how Clumsy Coders put together this storyline, so I decided to borrow it! 😊 👇

“In a medieval kingdom very far away, a king has been betrayed and murdered by his heir. The former king's ghost is back and attempts to possess the body of the court jester to spread malicious rumors about the new king and have him "canceled.”

The Last Laugh is an exciting game where two players compete against each other. The game aims to see who will come out on top. One player is a jester trying to navigate away from a ghostly presence while keeping his head on his shoulders and controlling his bodily functions. The other player is the ghost trying to succeed in his evil plan. The jester must outmaneuver the ghost to win the game.

Stefan and Angel worked on a new game with other team members, including talented designers and artists. Collaborating with Angel, they utilized cutting-edge technologies in C# and Unity to create stunning animations, bringing their vision to life. Things got even more exciting when Stefan and Angel both worked on Unity simultaneously, something they had never done before. They both enjoyed the competitiveness and the freedom to experiment with new ideas during the 48-hour game development process.

Final Thoughts

Despite the challenges and constraints, the journey of participating in a Game Jam, as our engineers said, is incredibly rewarding. Whether a student, amateur, hobbyist, or professional, engaging in game jams fosters creativity skills and provides a platform for experimentation and innovation. As everyone mentioned in this blog post aptly puts it, jamming is one of the most worthwhile activities an engineer can undertake, regardless of their skill level.

In conclusion, the Global Game Jam 2024 was a testament to the power of collaboration, creativity, and community in game development. Participants walked away with awards, newfound skills, valuable connections, and a passion for doing more. Each year, as the event ends, innovation inspires game developers worldwide to take on new challenges and push the boundaries of what's possible in game development. It’s an icebreaker for everyone who feels joy in the gaming world.

As we look back on the incredible games developed by talented jammers behind them, we can't help but be amazed by the gaming community!

Read on, as we are going into full detail about Secret Santa and who won the cooking competition. 👇

Who Could My Santa Be?

We decked the halls of Base42 with a beautiful light ambiance, presents, and a Christmas tree, creating a warm and inviting seasonal atmosphere. After our working hours, the whole crew went to Base42 and had the gift exchange. Everyone took this task very seriously, and you could feel the suspense and the excitement. Once the gift exchange was over, happy and surprised faces were everywhere, and the holiday joy filled the air. 💕

We decided to skip the public guessing part for Secret Santa 🎁 so that people could discover by themselves. Although some people weren’t thrilled with this decision, we hope you understand that guessing who bought a gift for 100 people would have lasted for hours, and you always have to take into account that there are other activities. After all, the season is about gathering, connecting with your colleagues and friends, and surrounding ourselves with joy and warmth. Plus, a little curiosity never kills anyone! 🤗

The Teams Behind the Cooking Competition

After exchanging presents, we put on our aprons and chef hats. There were seven teams, each representing a different color: blue, orange, green, red, yellow, violet, and indigo. These colors were not chosen randomly, and we'll discuss their significance in some of our upcoming blog posts. Finally, all the teams presented their pre-made Christmas desserts on the table.

Suddenly, the atmosphere transformed into something resembling a scene from a popular cooking show, as if Gordon Ramsey himself would emerge from around the corner any moment. It was the exact moment when you could feel the excitement and the competitiveness. The level of dedication, hard work, and teamwork required for this competition was truly surprising. The desserts looked impeccable, and when combined with the colorful aprons and chef hats, we resembled the crew of MasterChef.

Judge-Mental Much?

As we planned for this competition, we decided that the judges should be unbiased, honest, and willing to provide genuine feedback. Who is the most pure-hearted and honest person in this world? Children, of course. Thus, we came up with the idea of allowing our employees' children to become judges. Initially, we introduced them to the voting guidelines, and then they stepped onto the stage, officially introducing themselves to the teams as their judges.

The Rule of Three

All the teams had one common goal: to create the most outstanding dessert within a specified budget, select a wine that complements the dessert, and strive to win the competition. The judges evaluated each team based on their teamwork, decoration, and taste and awarded points accordingly. The first and foremost rule of the competition was that every team member had to be actively involved in the dessert-making process, and each person had a specific role to play, ranging from purchasing the ingredients, finding the perfect recipe, decorating the dessert, and so on.

It was enjoyable to overhear people discussing their cooking plans, what they would make, and who would bake. It was heartening to witness the level of enthusiasm and dedication everyone had, to the extent that some teams even held meetings to plan their cooking strategies. The dessert was made one day before the event, and each team made videos of the cooking process, proving the teamwork and that the dessert wasn’t bought from a confectionery (because everything looked so good).

Special Thanks to the Video Editors

Some videos were very professional, and some team members stood out from the crowd with their teamwork. Whoever made the video did a great job and left the judges impressed. After watching the videos of all the teams, the judges went around the table and carefully examined the decorations of each team. From gingerbread houses, winter wonderland brownies, Christmas cookies, Christmas tree muffins, chocolate snowmen, and pinecones, everything looked so magical that everyone enjoyed just watching it.

A Recipe Has No Soul, Your Team Has to Bring Soul to the Recipe

There is one popular quote among famous chefs: “If you are a chef, no matter how good a chef you are, it's not good cooking for yourself; the joy is in cooking for others,” and we somehow got stuck to it. 🌟❣️

The judges stepped away from the table and moved to another room to award points to the teams for their teamwork and decorations. Despite being young, they were very strict and made decisions quickly. Still, they got silly questions like, “Why are your gingerbread cookies painted red? Is that blood?” “Why is my father not included in the cooking? Is it because he really doesn’t know how to cook anything?” “Why are you lying to us that you are covering your gingerbread house with snow? We are adult enough to know that it’s icing sugar?” “Are those ghosts? Isn’t this a theme for Halloween?” which made the competition even funnier. 🤣

After a long day of judging, the judges became exhausted and hungry. They took a break to evaluate the final round based on taste. Each judge tasted every dessert before returning to the voting area to score them. It was a difficult decision, but eventually, they came to a conclusion.

The Verdict: Golden, Silver and Bronze Spoons

After making the decision, the judges ran back among the teams to claim the winner, the team with the best dessert in taste, decoration, and teamwork.

1st Place: The blue team won, so they got the first prize in the cooking competition, wine degustation in one of our local wineries, + their golden spoon (actually a wooden spoon with a golden ribbon, but let’s pretend it was a golden one 😀).

2nd Place: The indigo team came in second place, but the judges noted that although their decoration was excellent, their muffins were dry, which prevented them from winning the top prize. They received a free meal day and a silver spoon as a consolation.

3rd Place: Finally, the announcement for the third-place winner was made. The orange team was awarded a recipe book and a bronze spoon for their impressive gingerbread house. Despite the elaborate design and delicious taste, the judges didn't award them a higher position because they felt deceived by the snow on the cake, which was clearly made of icing sugar.

The judges had a tough time choosing the winners because each team put in their best effort, but ultimately, they felt that the blue, indigo, and orange teams had won their hearts.

The Ultimate Battle of Best Dessert

After claiming the winners of the competition, we were all invited to try out the desserts and drink some wine that the teams bought with their desserts and some soft drinks and snacks for our young judges who got tired from the competition because it was exhaustive and hard to decide. While trying the desserts, everyone was invited to vote for the best dessert, excluding their own team.

After counting the votes, we declared the green team the Best Dessert Award winner and awarded them a Michelin Star. Their chocolate snowmen were incredibly delicious, and we couldn't resist having more of them in the following days.

Catching Snowballs

The competition ended with a silly game where the participants had to gather cotton balls from a table using a spatula while their eyes were sealed. The winner was the one who gathered the most cotton balls. However, the interest in the game could have been higher, as people were more curious to find out who their Santa was and what gift they had received.

Nevertheless, the organizer forgave the lack of enthusiasm, as the event was already long enough without this part. After the game, some crew members stayed behind, and the night continued with karaoke and music.

Final Touch

Long story short, regardless of who won, you proved again that you are all amazing. Creating a dessert as a team, with a limited budget, that is both impressive and visually appealing enough to capture a child's imagination is exceptionally challenging. So congratulations on your hard work and creativity and for showing respect and participating in this event. Keep nurturing these values; combined with your work, you will someday conquer the world! 💕👏🏻

As this is our final blog post for this year, we are extremely optimistic as we set our sights on 2024. ‘Tis the season to be jolly, and we are certainly spreading the joy! 🎄 We can't wait to see what the future holds! 🌟

See you next year!

After a significant pause of this chapter, it's finally revived. So, if you are located in close geographic proximity or are interested in remotely following the events, join the official Meetup Group.

Reflecting on the exhilarating experience of spearheading the community's revival during the first event post-hiatus! It was an honor to contribute to reigniting the community spirit. Our exploration into the realms of interoperability and operationalizing ML models with ONNX was truly rewarding.

The added excitement of delving into the seamless deployment capabilities offered by ONNX Runtime made this journey unforgettable. A heartfelt thanks to everyone who joined the discussion, and let's look forward to many more insightful conversations on the horizon!

Synopsis of my talk

Challenges: Taming the Complexity

First off, let's acknowledge the challenges we face in the ever-expanding universe of deep learning. Multiple frameworks like TensorFlow and PyTorch, coupled with varied training accelerators (think T4 GPUs and VPUs), make the landscape intricate. This is where ONNX steps in, initiated by tech giants AWS, Microsoft, and Meta. It acts as a unifying force, providing an abstraction layer over frameworks and hardware, reducing the complexity of integrating these different components.

Design Principles: Flexibility and Standardization

ONNX isn't just another acronym; it's a set of design principles supporting both deep learning and traditional machine learning. These principles aim to be flexible enough to keep up with the rapid advances in AI while providing a standardized, cross-platform representation for serialization. Imagine it as the Common Language Runtime for programming languages, minimizing the number of moving parts in the deep learning landscape.

Understanding the ONNX Specification

So, what's under the hood of ONNX? The ONNX specification reveals a structured format where each computational graph is a directed acyclic graph. Nodes represent inputs, outputs, and operators, with metadata documenting crucial details about the model and its production environment. Data types, including tensor types and non-tensor types in ONNX-ML, showcase the framework's versatility.

Operators: The Essence of ONNX

Now, let's talk about operators – the heart and soul of ONNX. These are defined by name, domain, and version, encapsulating the essence of various operations. Take, for instance, the Relu and Abs operators, which I'll be diving into during the presentation. These examples demonstrate input-output relationships and type constraints, showcasing the elegance and power of ONNX.

Practical Demos: Bridging Theory and Application

Enough theory; let's get hands-on! In Demo 1, we'll walk through defining a PyTorch model, training it, exporting it to ONNX, and visualizing the resulting graph. The practical application comes to life as we tackle a real-world problem – training a classifier for the MNIST dataset using a convolutional neural network in PyTorch.

ONNX Runtime: Bridging the Gap

What about deployment? Enter ONNX Runtime, the bridge between the ONNX file format and deploying the graph on different hardware. Microsoft takes the lead here, maintaining ONNX Runtime as a distinct project from the ONNX specification governed by the Linux Foundation AI.

Interoperability: ONNX in Action

But ONNX isn't limited to theoretical discussions. We'll explore interoperability, touching on the ONNX Model Zoo, Azure Cognitive Services, and methods to convert existing models or train from scratch. Practical tools like Netron and VisualDL will be your companions in understanding and visualizing ONNX models.

Demo 2: ONNX in the Real World

The finale? Demo 2, where we take the model from Demo 1, integrate ONNX Runtime in JavaScript and build an inference REST API with Express.js. This real-world application underscores ONNX's cross-language applicability, bringing everything full circle from theory to practice.

Join the ONNX Adventure

I'm beyond excited to share this ONNX adventure with you. Whether you're a seasoned deep learning enthusiast or just dipping your toes into the data science world, this journey promises to offer insights, practical knowledge, and a newfound appreciation for the unifying force that ONNX brings to the table.

As we rapidly move at CodeChem, we encourage engaging in extracurricular activities that add some fun to our routines. In that matter, for the second year in a row, ping-pong has generated a surprising interest among our team members.

Join us in this blog post as we pull back the curtain, inviting you to step "behind the scenes" and enjoy the best moments of our latest ping-pong tournament.

The Very Beginning

It all started a few years ago when everyone was working. Back then, you could often hear the sound of a bouncing ball echoing through the hallways, and even today, we can still hear it (it's pretty funny, actually). That was the first sign that we had a group of people who absolutely loved playing ping-pong.

As always, we had to do something about it, and that’s how the idea of our first CC tournament came. Our first official ping-pong tournament happened in 2022 in Hazard, an excellent pool billiard club in Skopje, but this year, the tournament occurred in Base42, which is way more private and a perfect fit for this event.

New Faces, New Places

We are constantly growing and learning from each other. While our main focus is software engineering, we always remember about knowledge-sharing, which often comes in different segments, including our hobbies. During 2023, many new faces joined CC, and thus, we welcomed fresh faces to our ping-pong crew, by whom our squad has significantly grown. That’s why we put an accent on our fun zone in CC, where one of the key elements is our ping-pong area.

Suppose you ask one of the players why they love playing ping-pong so much. In that case, you’ll probably get a variety of answers like it makes them feel relaxed, they measure their strength, they cannot wait to inspire other players, or compete with the most successful ones, but you’ll get one mutual answer for sure: ping-pong connects people, makes them laugh, makes them focus, and they all can compete, bond and have fun while cheering.

Whether you are a coach, a player, a colleague who came to watch the tournament, or even someone who came just for the beer and snacks, you all have the spirit of sportsmanship.

The Serve-ivors and Winners

Everyone who participated in the tournament should be proud of themselves, even if they didn’t make it to the next match. We had 16 participants in total, and throughout the matches, we could all feel the excitement and competitiveness because of the unexpected and tight results. There were moments when we didn’t know what would happen till the very last second.

Although ping-pong appears to be a simple game, in reality, it requires great skill and focus, evident from the concentration and perspiration visible on the players' faces as they all strive for victory. We always value courage, honesty, fairness, and competitiveness at CC; according to that, the tournament ended with one trophy and three certificates.

Our colleagues Aleksandar Mirchovski and Kosta Halicea won third and second place, respectively. At the same time, Mino Todorov triumphed in the tournament and will keep the trophy of 1st place till our next CC ping-pong tournament. Everyone else who participated in the tournament was excellent, especially Aleksandra Gjurova, who won 4th place.

Judges and Organization

The tournament wouldn’t have gone smoothly without our professional judges, who kept the atmosphere funny but professional at the same time, keeping the scores and results up-to-date all the time and monitoring each step of the tournament. It was so good, as if Mills Bee Lane was speaking.

Besides the judges, there was an excellent organization from Pale who delivered the certificates, food, snacks, and everything equipped for the tournament in Base42. You must love Base42, an awesome space for awesome people (ping-pong intended), but without Pale nothing would have been possible, so big thanks to her.

Practice What You Preach

Our second official ping-pong tournament ended, but we won’t stop playing, practicing, and having fun. There’s no victory without training, getting new experiences, and adding a unique playing style to beat your opponent.

Our ping-pong tournament is just another way to get to know your colleagues well and bond over something you both have a passion for, and we cannot wait till our next one.

Winner’s Statement

Interviewer: What does playing ping-pong mean to you, and how do you feel after winning 1st place?

Mino: It's a fun way to take a break and use some trash talk 😃. I really enjoy it, especially the long rallies ending with a full-power smash. And the sound of the ball is relaxing. Given my competitive nature and love for winning, it was satisfying and felt great 😊.

Stay tuned until the next serve and victory as CodeChem's ping-pong journey continues! 🏓🎉

• Azure Resource Manager

• Azure Resource Provider

• ARM Templates

Note: ARM is an acronym for Azure Resource Manager.

Azure Resource Manager

The Azure Resource Manager is the official deployment and management service for Microsoft Azure. It provides a layer that enables you to manage (create, update, delete) different resources in your Azure account.

Benefits

Let's take a look at some of the benefits that this service offers:

• Declarative templates instead of scripts: Consistent state amongst deployed resources is guaranteed as your app infrastructure and dependencies are defined in a single declarative template

• Improved management and organization of resources: No more piece-by-piece deployments of your app and manually stitching them together. Resources with a common lifecycle are grouped in a resource group that can be deployed or deleted in a single action. You can see which resources are linked by a dependency and/or categorize resources by tags for management tasks (e.g., billing)

• Authorization: ARM offers control access to resources. You control who in your organization can perform actions on any resource. Permissions are managed by defining roles and adding users (or groups of users) to those roles. ARM logs all user actions so you can audit those actions

Basic Terminology

In the previous section, I mentioned something called a resource group. Before we continue, let's explain some of the most basic terminology you'll need to understand when working with the ARM:

• Resource: Manageable items such as virtual machines, storage accounts, web apps, databases, etc., are regarded as resources. As strange as it may seem, resource groups are also treated as resources.

• Resource group: As the name implies, a resource group is a container that holds related resources for an Azure solution. For example, you usually include all your resources related to a single application deployment in a resource group. This might include an app service, static web app, app service plan, SQL server & database, etc.

• Declarative syntax: It defines "what" we want to happen; we don't care how it happens. ARM templates and Bicep files are examples of declarative syntax.

• Bicep file: A file for declaratively deploying Azure resources.

Management Layer

ARM is the middleman between different access routes to Azure services and the actual resources.

Here's an image that better illustrates this:

No matter how you try to access Azure services & resources, whether through the Azure web portal, the Azure API, CLI, or SDKs, the Resource Manager intercepts all requests. It authenticates and authorizes the request before forwarding it to the appropriate Azure service.

Because all requests are handled through the same API, you see consistent results in all the different tools.

Scope

Azure provides four levels of scope:

• Management groups

• Subscriptions

• Resource groups

• Resources

The most common scopes used are subscriptions and resource groups.

We can deploy templates to tenants, management groups, subscriptions, or resource groups.

It's the first time we mentioned tenants, so I'll quickly explain what tenants are:

• An Azure AD (Active Directory) tenant is a reserved Azure AD service instance that an organization receives and owns once it signs up for a Microsoft cloud service such as Azure or Microsoft 365.

• Azure Active Directory, now known as Microsoft Entra ID, is a cloud-based identity and access management service. It provides single sign-on, multifactor authentication, and more.

These concepts are out of the scope of this article, but we might hear them again in future articles, so I've linked some extra resources at the end so you can check them out.

Azure Resource Provider

An Azure resource provider is a service that supplies Azure resources. It's a set of REST operations that enable functionality for a specific Azure service.

Example per the Microsoft documentation:

The Key Vault service consists of a resource provider named Microsoft.KeyVault. The resource provider defines REST operations for managing vaults, secrets, keys, and certificates.

The resource provider defines the Azure resources you can deploy to your account.

The good thing is that a resource type's name is standardized and follows this format:

{resource-provider}/{resource-type}.

The resource type for a key vault is Microsoft.KeyVault/vaults.

Of course, you don't have to remember different resource types off the top of your head. Microsoft provides documentation for all types, and you can easily look them up!

Why are they important?

Resource providers are important because we use the resource provider types to register our resources in our declarative language (ARM templates or Bicep). That's how we tell Azure what resources we want to deploy.

It's important to note that before we can use a resource provider, we must ensure our Azure subscription is registered for the one we want to use. Tip: register a resource provider only when you're ready to use it. Registering unnecessary resource providers may result in unrecognized apps appearing in your Microsoft Entra ID tenant.

Some resource providers are registered by default. Other resource providers are automatically registered when you take specific actions.

When you carry out specific actions, other resource providers are registered automatically. Usually, the resource provider is already registered for you when you create a resource using the Azure web portal. The resource providers specified in an ARM template or Bicep file are immediately registered when deployed.

There are situations when a templated resource needs supporting resources not included in the template. Resources for monitoring or security are frequent examples. Those resource providers must be manually registered.

ARM Templates

If you made it this far, give yourself a pat on the back! That was boring; now we're getting into the exciting stuff.

ARM templates are normal JSON files that define one or more resources to deploy to a resource group, subscription, management group, or tenant. These templates can deploy resources consistently and repeatedly without configuration drift. That's how we implement infrastructure as code for our Azure solutions!

How does an ARM Template file look like?

Within the template file, we can write additional template expressions that extend the capabilities of JSON. These expressions make use of the functions provided by the Resource Manager.

Each ARM template file has the following sections:

• Parameters: Provide values during deployment that allow the same template to be used with different environments.

• Variables: Define values that are reused in your templates. They can be constructed from parameter values.

• User-defined Functions: Create customized functions that simplify your template.

• Resources: Specify the resources to deploy.

• Outputs: Return values from the deployed resources.

Here's an example ARM template that tells Azure RM to create a Storage Account:

"resources": [
  {
    "type": "Microsoft.Storage/storageAccounts",
    "apiVersion": "2022-09-01",
    "name": "mystorageaccount",
    "location": "centralus",
    "sku": {
      "name": "Standard_LRS"
    },
    "kind": "StorageV2"
  },
]

When a template is deployed, the Resource Manager intercepts the request and converts this template into REST API operations. The example above would translate to the following operations:

PUT
https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/mystorageaccount?api-version=2022-09-01
REQUEST BODY
{
  "location": "centralus",
  "sku": {
    "name": "Standard_LRS"
  },
  "kind": "StorageV2",
  "properties": {}
}

This request is then sent to the appropriate resource provider. In this example, that's Microsoft.Storage provider.

Why should you use ARM Templates?

Here are some benefits to convince you to use ARM templates:

• Declarative syntax

• Repeatable results

• Orchestration

• Modularity

• Extensibility

• Testing

• CI/CD integration

Why you shouldn't write ARM Templates.

Alright, you saw the benefits, but now I will convince you not to write ARM templates! Pretty ironic, but hear me out!

Hello Bicep!

Bicep is a new domain-specific language (DSL) that uses declarative syntax—created explicitly for deploying Azure resources.

It's the recommended way to deploy your Azure resources because it offers the same capabilities as ARM templates. However, the syntax is much easier to use, and the developer experience is way better!

I won't go any deeper; the next article in this series will be about Bicep💪😉.

Conclusion

In this article, we explored the Azure Resource Manager, Resource Provider, and ARM Templates and scratched the surface of Microsoft's new DSL Bicep.

If you enjoyed reading this article, make sure to follow us for more on the same topic in the coming weeks!

Resources

• https://azure.microsoft.com/en-us/get-started/azure-portal/resource-manager

• https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/overview

• https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/resource-providers-and-types

• https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview

• https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/template-functions

Wait, what do you mean by “infrastructure”?

Before explaining Infrastructure as Code, we first need to define what we mean by infrastructure. When we talk about IT infrastructure, we’re talking about interdependent elements categorized into two core groups: hardware and software infrastructure elements.

Hardware components include computers, servers, data centers, routers, switches, etc. Software components include operating systems, web servers, firewalls, resource management systems, databases, etc.

The two primary types of IT infrastructure are traditional and cloud infrastructure. I won’t continue into details, as it would escape the scope of this article. However, I’ve linked some resources if you wish to further read up on these concepts at the end of this article.

Okay, cool, now what do you mean by “infrastructure as code”?

As the name implies, Infrastructure as Code (IaC, a common abbreviation) is the practice of automating and managing IT infrastructure through code, leveraging DevOps and traditional software development principles (like code versioning). It involves using a descriptive coding language to define and provide infrastructure consistently, ensuring rapid development, cost control and reliability relative to treating infrastructure like standard application code.

I mentioned it uses a descriptive coding language. This isn't always the case, as imperative IaC exists and we’ll quickly discuss that at the end of this article.

History

I'll take a very short detour to explain the history of deploying and maintaining software infrastructure and why the process of IaC was developed.

In the era before IaC, setting up and managing infrastructure typically involved several manual tasks and processes, including:

• Providing physical hardware: This means providing physical (often on-site) servers, switches, routers, storage devices, etc.

• Operating system installation and configuration: After the hardware was set up, system administrators manually installed and configured operating systems on each server.

• Deploying the software application: Each application had to be installed and configured individually and manually.

• Network configuration: Manual setting up and managing network connections, firewalls, load balancers, and other networking components required manual configurations

• Storage management: Managing storage resources involved creating partitions, configuring RAID arrays, and manually allocating storage space to different applications and servers.

The main downside of manually setting up infrastructure was, well, obviously, that we’re doing all of this manually, but also:

• Slow deployment

• Error-prone

• Lack of scalability

• Inconsistency

• Difficulty in versioning

Infrastructure as Code addresses these challenges by automating the provisioning and management of infrastructure using code, enabling rapid, consistent, and error-free deployments while facilitating versioning and scalability. It represents a significant advancement in the field of IT infrastructure management.

Other benefits

Besides the things we highlighted in the previous section, IaC has other benefits:

• Allows a company to enter the cloud computing scene more easily

• Cost reductions

• Increased deployment speeds

• Eliminates configuration drift

You might be wondering what I mean by configuration drift so here’s a short definition:

Ad hoc configuration updates and changes can cause a discrepancy between the environments used for development, testing, and deployment, known as configuration drift. Designing apps and services that must adhere to stringent regulatory compliance standards might lead to problems during deployment, security vulnerabilities, and hazards. By consistently offering the same environment, IaC reduces drift.

IaC is also crucial for DevOps, as it streamlines the process and CI/CD by automating provisioning. It unifies teams and ensures consistent deployments. IaC's benefits span all environments, including production. It extends DevOps principles to infrastructure, enabling rigorous testing and version control.

Declarative vs. Imperative approach

Declarative usually defines “what” we want to happen, while imperative defines “how” we want the thing to happen.

In most cases, the declarative approach, also known as the functional approach, is preferred. It specifies the desired final infrastructure state with the IaC software handling tasks like VM setup, software installation, and version management. However, it may require skilled administrators to set up and manage.

On the other hand, the imperative or procedural approach involves creating automation scripts for each step of infrastructure provisioning. While this may be more manageable for existing staff, it can become complex and costly at scale.

I’m going to leave you with this fantastic analogy I read on IBM’s website:

Choosing a declarative or imperative approach is analogous to using a GPS or following turn-by-turn instructions. With a GPS, you enter an address, and the GPS does the rest, plotting the fastest route and avoiding traffic for you, but you probably need an expert to tell you why it made the choices it made. The turn-by-turn instructions are based on personal experience; the provider knows the route and why he/she chose it, but if you encounter obstacles or want to optimize the route, you have to call for help or do the work yourself.

Conclusion

Hey, you made it to the end! Thanks for reading my article❤️🙏.

Infrastructure as Code is a big part of DevOps and the entire software development and maintenance process. It provides codification, versioning, ease of life, and, most importantly, consistency

If you enjoyed reading this article, make sure to follow us for more on the same topic in the coming weeks!

Extra resources

• "Infrastructure as Code - Crash Course" by freecodecamp

• Red Hat’s definition of Infrastructure as Code

• IBM’s definition of Infrastructure as Code

• "What is IT Infrastructure?" by IBM