What Caught Our Eye at TechMeetup Conference 2023

We attended several great talks, and we want to share what we took away from them.

Seamless Releases
with Feature Flags:
Insights from
GitHub's Experience

Hana Harenčárová

In the first talk, Hana Harenčárová, a software developer at GitHub, introduced us to the concept of feature flags. Put simply, they're basically a fancier version of if statements. Hanka showed us how they use them at GitHub.

They use the Ruby programming language, and for feature flags, the FlipperExternal link. Developing individual features can take weeks, sometimes even months, so the ability to do incremental builds is important.

Tips from the talk:

• The entire block of new code should sit behind the feature flag, not just, say, a function's return value — so you don't introduce an unwanted, hard-to-spot bug or side effect into your app.
• Once code behind a feature flag has been fully rolled out, you need to clean up and delete the code branches you no longer need.
• GitHub CodeQL is an engine for automated code analysis that flags security issues.
• You need to write tests for both the case when the feature flag is on and the case when it's off.

Rust – a programming language
for a good night's sleep

Jakub Beránek

In the next talk, we got introduced to the Rust programming language. We don't use it ourselves, but we like broadening our horizons.

According to Jakub Beránek, Rust is committed to full backward compatibility across new versions. Compared to JavaScript, it also boasts better performance and fewer bugs in its users' code. Apparently, even Linux creator Linus Torvalds “praised” it, saying: “I don't hate it.”

Rust is used, for example, for backends and serverless technologies, and here's a fun fact — it has no garbage collector.

Design tokens
for developers

Šimon Jůn

Next came a topic much closer to home — design tokens, which we use on many of our projects.

In his talk, Šimon first outlined the most common problems that developer and designer teams run into. Specifically, he mentioned:

• handing off deliverables,
• complicated communication,
• updates,
• development without a design,
• rebranding.

He then showed how to solve these problems using design tokens, introduced the concept, and demonstrated how to work with them in Figma.

For working with design tokens, Šimon recommended the Token Studio plugin for Figma. Figma has since come out with its own native solution, Figma Variables, but it doesn't do everything yet, so Token Studio apparently still comes out on top.

Another interesting takeaway was that developers and designers need to align on a shared language — and that language should be the developer's (JSON), since the design in Figma alone isn't the final product. And that came from Šimon, who's a designer himself.

How to sharpen
a developer's saw
or, developing your team's developers

Karel Pávek

Karel Pávek's talk was more management-focused, and it got us thinking about how to guide developers in their growth.

Employee expectations have changed a lot in recent years. They want the option to work from anywhere, flexible hours, and above all, an individual approach to career growth. A team lead needs to take into account each colleague's different motivations, an individual action plan, and feedback.

Karel also pointed out how important it is to set up team norms around communication and collaboration, in the spirit of “there's no such thing as a stupid question.” Methods like peer programming can help with development, as can dedicating time within a sprint to personal growth — ideally at least 4 hours every two weeks.

How to design an API
that can't be misused

Jakub Neruda

Jakub started his talk on APIs with a quick refresher: ideally, you should design an API so users never even need to read the documentation. That means, for example, naming things clearly — nouns for objects, imperatives for functions, and prefixes like is, has, can, should for queries.

He then outlined five classes of problems you can run into when designing an API, and walked through their solutions using concrete code examples.

Next 14
– React Server Components
and Server Actions

Martin Křištof

The program originally listed a talk about Next 13, but Next version 14 came out just the week before. Hats off to Martin for managing to update his slides at the last minute to keep his presentation as current as possible.

He walked through the concept of server components in React, server actions, and the new routing approach. He also mentioned that the new version of Next comes with a new bundler, Turbopack, replacing Webpack. It's still only in beta, and from his own experience Martin doesn't yet recommend using it in a dev environment, since despite its name, it's actually slow.

A large part of the talk was live coding a small app, where Martin walked through the individual new features one by one and threw in a few extra tips along the way. For instance, an underscore in a folder or file name signals a private component that shouldn't be used for file-based routing. Parentheses in a folder name work similarly, letting you better structure your pages without affecting routing.

Functional languages in production

Antonín Hackenberg

Why use functional programming? As Antonín explained, what matters for any programming language is its features, tooling, documentation, and community. Some functional languages already have all of that built in from the start.

As an example, he showed the Elixir language, which comes with things like a package manager, a formatter, and static typing built in. All of these are things that in our main language for frontend developers — JavaScript — we have to solve in a more roundabout way, using separate plugins.

Antonín also introduced the functional language ReScript, which has neither null nor undefined, compiles to JavaScript, and even lets you write React components directly in it. On top of that, it has a generator that lets you generate types for TypeScript, or the other way around, bring TS types into it. And apparently, it's faster than TypeScript.

Application Observability
from developer perspective

Ondřej Popelka

Chart lovers must have had a field day at Ondřej's talk, because he had prepared a lot of them. Keboola, the company he works for, handles big data using many services written in different languages and managed by different teams. These services handle wildly varying volumes of requests — anywhere from a handful a day to thousands per second. Monitoring and figuring out why something is taking longer than it should is therefore absolutely critical.

In his talk, Ondřej recommended which metrics are worth tracking and how to go about it. But he also warned that things aren't always what they seem at first glance from a chart — in his view, you always need to think more deeply about the data.

AI: a bubble
or a revolution?

David Grudl

The TechMeetup conference in Ostrava was wrapped up by David Grudl with a hearty talk on AI. He pointed out that AI tools can make our work enormously easier once we understand how they work — and that most people are using them the wrong way.

With tools like ChatGPT, for instance, you need to realize they work by predicting the probability of the next word. So the AI isn't actually thinking about the text at all — it just takes a prompt and generates the next likely word. On top of that, AI doesn't work directly with words but with so-called tokens, of which it only remembers a limited number, and it “forgets” anything older.

David also mentioned terms like backpropagation, few-shot, and word embedding. If you're more interested in AI topics, definitely look them up. You can even use AI itself to help you learn, since it has infinite patience — it can even help you with programming.

What interesting things have you learned lately? Let us know.