When I’m working with large datasets in PySpark, I often need to know how many records are flowing through my transformations. It’s a simple thing, but being able to log that information at the right time can help me catch issues early—like unexpected filters wiping out rows or joins ballooning in size. What makes it
Commit Quantity vs Quality Balancing commit quantity and quality is a common challenge for software engineers. While some emphasize frequent, incremental commits, others advocate for single, clean commits that ensure a pristine history. In this post, I’ll share my personal approach to navigating this balance, lessons from past experiences, and tips for fostering a team
Welcome to your first day as a software engineer! Whether you’re joining your first tech company or transitioning into a new role, the beginning can feel like a mix of excitement, nerves, and information overload. But don’t worry—there are a few key things you can do on Day One to set the tone for success
Handling file uploads in a React app is straightforward, but things get more interesting when you need to filter for specific file types and parse their contents. I needed to create an upload button that only accepted JSON and YAML files, then read and displayed their contents in the browser. Here’s how I did it.
When working with Storybook, I wanted my component previews to take up the entire viewport height. But by default, the preview area doesn’t always stretch to fit the full screen. After trying a few different approaches, I found the simplest and most reliable way to achieve this. Here’s how to make sure your Storybook preview
When I started working with Adaptive Cards in a React app, I wanted a way to dynamically load and style cards while keeping them flexible. Adaptive Cards provide a powerful way to render dynamic UI elements using JSON, but by default, their Markdown support is somewhat limited. To improve this, I decided to integrate markdown-it,
Azure Event Hubs are designed as an immutable, append-only store for events. Once events are ingested, they remain available until the retention period expires. This approach is ideal for high-throughput and reliable streaming, but it also means that individual message deletion is not supported. Instead, the available options focus on managing data lifecycle through retention
I’ve always believed that maintaining up-to-date API documentation is crucial for building reliable software. In my latest project, I wanted to integrate Swagger UI into my Express server, but with a twist—I needed the documentation to update automatically whenever I made changes to my API routes. After some research and experimentation, I discovered a workflow
As I work with React Query, I often find myself needing to manage the status of mutations to ensure a seamless user experience. This involves disabling fields and buttons while data is being updated or created, preventing users from triggering multiple requests simultaneously. In this post, I’ll share how I handle mutation status using React
As I began working on my latest React project, I realized the importance of incorporating voice input to enhance user experience. This feature allows users to interact with the app using voice commands, which can be particularly useful for accessibility and convenience. In this post, I’ll walk you through how I implemented voice input in
Keeping Your React App Up-to-Date: A Step-by-Step Approach As a developer, one of the challenges I’ve faced is ensuring that users of my React application always interact with the latest version. This becomes particularly important when users keep a tab open to the site for days or even weeks. During this time, if updates are
Apache Spark and Apache Flink are two of the most popular open-source frameworks for large-scale data processing. While both are designed to handle big data workloads, they have distinct architectures, processing models, and use cases. Here’s a comprehensive comparison to help you understand their differences: 1. Processing Paradigm 2. Latency and Throughput 3. Fault Tolerance