Understanding RxJS through the lens of the Observer Pattern
Both the classic Observer Pattern and the library RxJS use reactive programming. Both, the Observer pattern and the library, can deal with asynchronous code. Though somewhat similar there are differences that sets them apart. Most notably, when using RxJS compared to the Observer Pattern, is that we stop moving around the reference to the origin and instead refer to the data stream instead. Another difference would be that RxJS is by nature lazy and only subscribing to an Observable in RxJS makes the library (re)do all the steps nessecary to get the value(s) for the subscriber. By reflecting on the classic Observer pattern, a new understanding of RxJS can be grasped that deepens your knowledge and thereby helps to become better in using the library RxJS.
Dennis Gijzen - Mar 21, 2023
A set of noteworthy uses of MockK (that might come in handy)
Doing a job with the right tools can make your job easier, results in higher quality and makes room for creativity. In this article we convince you that MockK is such a tool for Kotlin unit testing.
Christiaan Schop - Mar 6, 2023
Faster NestJS REST APIs with Automated Parallelization of Business Logic
While inspecting the performance of our internally developed REST APIs for an e-commerce project, my team noticed that the performance of certain endpoints was not as good as we wanted, with an average of 6 seconds per call. We felt that an average of 1 second per call would be good to strive for. We came up with the idea to develop a proof-of-concept, to validate how much faster our slowest endpoint would get and if it would be close enough to our ambition of 1 second per call on average.
Maarten Verbaarschot - Jan 11, 2023
Configuring the ELK stack to persist your observability data from Jaeger
Observability is a crucial aspect of modern software systems, as it allows engineers to monitor and diagnose issues in real-time. Jaeger and Elasticsearch are two powerful tools that can be used for observability, but they operate in different domains and have different data formats. Interoperability between Jaeger and Elasticsearch would allow engineers to integrate and analyze data from both systems in a single platform, providing a more comprehensive view of their systems and enabling more effective troubleshooting and analysis. This would be particularly useful for large, distributed systems where multiple teams are working on different components. By bringing together data from Jaeger and Elasticsearch, the connector would enable a more holistic approach to observability, enabling engineers to gain deeper insights and make more informed decisions.
Adolfo Benedetti - Dec 12, 2022
Quit using your mouse - use IntelliJ shortcuts!
Are you done wasting time using your mouse for everything when developing? Try using IntelliJ's shortcuts to help you out! In this article we will have a look at some very useful shortcuts to help you improve your productivity when coding.
Thierry Gerritse - Aug 19, 2022
Spice up your tests using Faker
Having your test data as close as possible to production data is a key to having high quality tests. However, it is rarely possible to use production data for testing purposes. Kotlin Faker library helps with generating randomized data for different domains (addresses, contact details, numbers etc.) that look real. In this article we will explore Kotlin Faker and see what data can we generate for a real-world use case.
Oleksandr Shynkariuk - Jun 20, 2022
Customizing Angular builds with TypeScript AST transformers
Despite the advantages of TypeScript AST transformers, there is no official support for them in the Angular CLI. Fortunately, there is way to make use of them without having to get rid of the CLI. Using custom builders, it is possible to get access to the webpack configuration used by the Angular CLI. This in turn provides the opening needed to add your own AST transformers into the mix.
Daan Scheerens - Feb 6, 2022
Applying markup to translations in Angular applications (the right way)
Multi-language support in Angular application can be achieved with the help of libraries such as Angular i18n, NGX Translate or Transloco. Unfortunately, these all fail to address a commonly needed feature: translated text that contains markup. Translation splitting and innerHTML binding are often used as workaround. But these approaches are far from ideal. A better approach, supporting a context specific markup syntax is outlined in this article.
Daan Scheerens - Jan 11, 2021
RxJS subscription management: when to unsubscribe (and when not)
When working with RxJS observables you will be faced with the concept of subscriptions. Although they are quite useful, they are often used incorrectly, or worse: simply ignored. A detailed explanation of their function and how to handle them in the right way is given in this article. It explains when you must unsubscribe, when it is okay not to unsubscribe and when it is wrong to unsubscribe. You will also find tips for easily keeping track of subscriptions.
Daan Scheerens - Mar 5, 2020
Explicit and type-safe Angular module configuration
Angular's architecture and build system makes it easy to create reusable modules. Reusability largely depends on the available configuration options. Since configuration is also part of the public API surface of the module, it is important to set this up in a simple and safe to use manner. In this article you will learn how to create configuration interfaces for your Angular modules that are both explicit and type-safe. The offered solution also supports more advanced usage scenarios that require dynamically constructed configurations via dependency injection.
Daan Scheerens - Jan 3, 2020