Blog

All posts are entirely written by me, without the help of synthetic text generative tools.

Testing
August 17, 2024
Nullable type narrowing in tests
Non-trivial integration tests in TypeScript projects might require us to use functions that return Nullable types, especially when asserting side effects. This might force us to use less that ideal solutions such as type assertions or type-check ignoring comments. However, there is much better and elegant solution which we'll explore in detail.
Testing
August 09, 2024
Partial matching test assertions
This blog post explores two different approaches to describe partial test assertions: omitting insignificant data and picking only relevant data. Both approaches are useful, but they address different scenarios.
TypeScript
November 23, 2023
Hash Maps in TypeScript
In this post, we'll explore two different methods to implement Hash Maps with optional items in TypeScript and analyze the member access type safety.
Testing
December 19, 2022
A decade of testing
This post describes all the tools and practices I currently use to cover automated functional testing for an entire web application: unit and integration testing, end-to-end system testing, and isolated UI components testing.
Testing
October 30, 2022
Reasons for writing tests
Since I'm a big fan of automated testing, I'll describe my personal reasons for writing tests, which took shape during the last decade, writing all kinds of tests with the majority of available frameworks and tools within the JavaScript ecosystem.
Testing
October 29, 2022
Excuses for not writing tests
In this post I'll describe the most popular excuses I've heard so far when asking others about the lack of automated tests in their code. As we'll see, most of them are fallacies or unfounded arguments.
JavaScript
July 07, 2022
Fixing long npm installsCase study
In this case study, we'll analyze how to detect npm packages with long instalation times, use different techniques for debugging the cause of the problem, and optimize once we understand the issue.
CSS
May 28, 2022
CSS-in-JS misconceptions
Despite its versatility and potential, CSS-in-JS received a significant kickback from the community. We'll analyze the most recurring misconceptions, shedding some light regarding what CSS-in-JS is, but more importantly, what CSS-in-JS is not.
CSS
January 24, 2022
The evolution of scalable CSS
The evolution of scalable CSS is a multi-part chronicle, intended to document the progress of tools and practices that enable us to write maintainable CSS at scale. It covers CSS scalability issues, CSS processors, essential good practices, methodologies, semantic and atomic CSS, styles encapsulation, CSS-in-JS, and type-safe CSS with Typescript.
User Interface
October 10, 2021
Isolated Components Driven Development
In unit tests, we execute code in isolation, outside the application. The same approach could be applied to UI components, proving to be a very convenient method during development and debugging. As a bonus, this technique also provides documentation, valuable to all team members working on the project.
React
September 21, 2021
The anatomy of React component files
This article describes in detail my personal and current approach to defining React component files and the rationale for each decision. It covers function components syntax with TypeScript.
CSS
September 06, 2021
CSS-in-JS styles output methods
There are two mutually exclusive methods that CSS-in-JS libraries use to generate and ship styles to the browser: Runtime Stylesheets and Static CSS Extraction. Both methods have benefits and downsides, so let’s analyze them in detail.
User Interface
August 18, 2021
Developing UIs connected to web APIs
As UI developers, we have multiple methods we could use to connect to web APIs during development. We'll explore 3 different approaches, analyzing their strong points and limitations.
Learning
July 15, 2021
Validating our understanding
There is no absolute measurement tool to determine our level of understanding of a particular concept. But there are specific heuristics that we can use to evaluate ourselves.
Learning
July 09, 2021
Complementary learning
We took some courses, attended a few workshops, read a ton of articles, and probably one or two books too. We have even worked on a couple of personal projects. Ok, what's next?
JavaScript
June 04, 2021
Distinguishing between pages and components in Next.js
In Next.js we can customize what file extensions should be rendered as pages. This enables us to create components inside the pages folder without generating unneeded routes.
TypeScript
December 27, 2020
Empty objects initialization with TypeScript
We'll examine multiple methods to initialize empty objects in TypeScript, which is something you'll probably have to deal with in any application that has some form of state management.
Software entropy
December 22, 2020
Tech Debt or Tech Loan?
Technical Debt is a trade-off, a choice we make as developers. Sometimes we are (or feel) compelled to make these trade-offs. Sometimes it's our own decision. The fact is we can't always avoid them, so we need to learn how to manage them.
CSS
November 06, 2020
Definition lists with grid layout
In this post, we'll examine various implementations for a given layout, using both flex and grid, debating the robustness of each approach. The layout contains a horizontal list of 3 key-value pairs, the values being displayed beneath the labels.