May 31 2023
As a part of a broader initiative of refreshing Allegro platform, we are upgrading our internal libraries to Spring Boot 3.0 and Java 17.
The task is daunting and filled with challenges,
however overall progress is steady and thanks to the modular nature of our code it should end in finite time.
Everyone who has performed such an upgrade knows that you need to expect the unexpected and at the end of the day prepare for lots of debugging.
No amount of migration guide would prepare you for what’s coming in the field.
In the words of Donald Rumsfeld there are unknown unknowns and we need to be equipped with the tools to uncover these unknowns and patch them up.
In this blog post I’d like to walk you through a process that should show where the application hangs,
although there seems to be nothing wrong with it. I will also show that you don’t always know what code you have – problem known as dependecy hell,
place we got quite cosy in during this upgrade.
Apr 18 2023
Label noise is ever-present in machine learning practice.
Allegro datasets are no exception.
We compared 7 methods for training classifiers robust to label noise.
All of them improved the model’s performance on noisy datasets.
Some of the methods decreased the model’s performance in the absence of label noise.
Apr 5 2023
Hermes is a distributed publish-subscribe
message broker that we use at Allegro to facilitate asynchronous communication between our
microservices. As our usage of Hermes has grown over time, we faced a challenge in effectively distributing the
load it handles to optimize resource utilization. In this blog post, we will present the implementation of a dynamic
workload balancing algorithm that we developed to address this challenge. We will describe the approach we took, the
lessons we learned along the way, and the results we achieved.
Mar 21 2023
Many of us, software engineers, have experienced those days when nothing really sparks joy in coding, debugging,
preparing spikes or refining tasks for the next sprints. Obviously, we would like to have as few of such days as possible
and go on with our work effectively. A solution to this definitely is not tormenting our brains with guilt and forced
labour. There are other ways, and I would like to invite you to explore them with me and learn a little about our
nervous systems in the process. We’ll find out where the motivation comes from on a biological and psychological level.
We’ll also take a look at the changes you can introduce into your day to take advantage of certain mechanisms working
on a neural level and boost your motivation and productivity.
Mar 10 2023
Hardware is always hard. The amount of operations, maintenance and planning that goes into supporting a data center
is a daunting challenge for any enterprise. Though often unseen, without hardware there is no software.
Feb 13 2023
Software Architecture is an elusive thing which, if neglected, can lead to a hard-to-develop and maintain codebase, and
in more drastic circumstances to the failure of a product. This article discusses one of the backend application
architecture styles which proved to be successful in providing a good foundation for building and maintaining an
application in the long run: Onion Architecture.
Jan 25 2023
Sometimes great results in code performance come with a small amount of work. We’d like to tell you a story about how we changed the Allegro mobile homepage and reduced usage of Allegro service infrastructure with only a few lines of code.
Dec 21 2022
Let’s look at what transactions in MongoDB are and how they differ from SQL transactions.
Nov 10 2022
Building a complex web platform can be a real challenge, especially when parts of it are delivered by independent teams.
Picking out the correct architecture is crucial, but maintaining it can be even more challenging.
Frontend microservices, aka microfrontends, is an architecture that gives a lot of flexibility, but can cause
performance issues in the future, if not managed well. This article presents an approach to the microfrontends
architecture to keep the frontend technology stack efficient based on the complexity of user interface.
Oct 4 2022
What would you say if we stored 1 000 records in a database, and the database claimed that there were only 998 of them? Or, if we created a database storing sets of values and in some cases the database would claim that some element was in that set, while in fact it was not? It definitely must be a bug, right? It turns out such behavior is not necessarily an error, as long as we use a database that implements probabilistic algorithms and data structures. In this post we will learn about two probability-based techniques, perform some experiments and consider when it is worth using a database that lies to us a bit.
Sep 26 2022
Currently, in the Android world, the topic of modularization is very popular. Many bloggers describe their experiences
with it and analyze what Google recommends. Our team
started the modularization process before it was hot. I will describe our reasons, decisions, problems and give you some
advice. We will see if modularization makes sense and what it brings to the table. I will also post some statistics
showing what it looked like before and after the modularization process.
Sep 13 2022
Cloud providers like to brag about high availability and unlimited scaling of their services – and they are correct,
as these features are indeed significant advantages of cloud solutions. Their computational power is so high that for
most use cases, it’s almost unlimited. In this blog post, I would like to tell you about our experiences with Azure
Cosmos DB and batch processing.
Aug 3 2022
In this article, we want to share our approach to using server-driven UI in native mobile apps. In 2019 we created the first version of the in-house server-driven rendering tool called MBox and used it to render the homepage in the Allegro app on Android and iOS. We have come a long way since then, and now we use this tool to render more and more screens in the Allegro apps. After almost three years of working on MBox, we want to share how it works and the key advantages and challenges of using this approach.
Jul 19 2022
With this article, I would like to introduce you to EventStorming and explain to you how to get started. I am not discovering
anything new, just gathering available knowledge in one place. What I will show you is a few tips on how to conduct
and facilitate EventStorming workshops.
Jun 30 2022
Each of us has probably experienced a time in our career when we wanted to get rid of the Garbage Collector from our application because it was running too long, too often, and perhaps even led to temporary system freezes. What if we could still benefit from the GC, but in special cases, also be able to store data beyond its control? We could still take advantage of its convenience and, at the same time, be able to easily get rid of long GC pauses. It turns out that it is possible. In this article, we will look at whether and when it is worth storing data beyond the reach of the Garbage Collector’s greedy hands.
Jun 20 2022
At Allegro we decided to introduce GraphQL as our API Gateway for building several internal client systems.
By building such a solution we’ve learnt a lot about this technology
and we would like to share it with you in this article.
Jun 7 2022
Nowadays, technical debt can be considered the bread and butter of most IT-powered enterprises around the world.
Almost every company that survived the startup phase and managed to deliver its first products to customers will face at some point technical challenges related to past architectural decisions. Although code engineering gets better every year, we cannot argue with the obvious fact of life: the market will always force many of us to deliver tech products faster than we wish. Time To Market has always been a key success factor for many product companies and it puts a lot of pressure on Engineering to keep up with challenging deadlines.
Apr 14 2022
This blogpost is the result of a research collaboration between the Allegro Machine Learning Research team and
the Institute of Mathematics of the Polish Academy of Sciences (IMPAN), Warsaw.
Apr 1 2022
A picture is worth a thousand words — see for yourself how this unique Agile team learns BASIC from their Product Owner.
Mar 30 2022
We use written (source code) language to express our intentions in a machine-readable form. We use spoken language to
communicate with other people. We pride ourselves as ones choosing a programming language optimized to the task at hand.
Do we use the optimal way to express our ideas?
Mar 9 2022
Will automatic UI tests be able to replace manual testers as artificial intelligence will try to replace
programmers? I’ll show you how we write automatic UI tests on Android in Allegro Pay.
Mar 1 2022
The attack on Ukraine has shocked the entire world, but in Poland it is making especially big waves. Not just due to geographical proximity - Ukrainians are one of the largest minorities in Poland and simply put it is affecting people we know personally.
Feb 22 2022
Have you ever worked on a project where after downloading the code from the repository you start to wonder what business
requirements are hidden under the layer of unreadable tests?
Or maybe you are currently wondering how to test a new feature that you have been entrusted to implement?
Feb 10 2022
Everyone repeats like a mantra that tests are an indispensable element of development work. Is there anything to it?
Well, I need to admit that as a developer, I rather often want to skip the test writing stage. I assume I’m not the
only one. I’m aware that it’s a mistake, even with testers on board. Effective and efficient testing of your own
code can help with catching bugs in new functionalities, as well as in changes to already existing ones. It cannot
be questioned. Sometimes tests also help to understand how some long-unused functionality or component works. And
that’s a small bonus too. Can a large project cope without testing? Probably so. But the number of errors and
their severity will probably be much higher. That’s why in Allegro Ads we pay attention to writing tests.
Jan 24 2022
Most of applications we create are basically loops. An average program waits
for an event, then processes it following some business logic. Afterwards it
begins waiting for another event to arrive. Java Servlets work this way too.
Popular frameworks such as Spring allow us to only care about the business logic,
while the framework takes care of the application main loop.
