Writing Cleaner Test with Domain-Specific Assertions
Domain-specific assertions can help create an extremely clean test base. Learn how to create your own manually or with LLM.
Software Engineering
-
-
How to Choose and Name Commands for Event Sourcing or CQRS
Explore two approaches for creating and naming commands in command-based systems, balancing domain logic with structured formats.
-
Everything I know about Server-Side Caching
Boost application performance and scalability with effective caching strategies, from basic principles to advanced implementation in Spring Boot.
-
Create In-Memory Repository based on HashMap for Unit Tests Using Generative AI Instead of Mocking
Increasing accuracy of your Unit Tests and making them as easy to write as Integration Tests.
-
Automated Backward Compatibility Testing for APIs, Libraries and Databases
Ensuring backward compatibility through structured deprecation processes and automated testing minimizes disruptions during system updates and migrations.
-
Decoupling DTOs from Service Layers in Transactional Systems
Efficient strategies for managing data transformation within Spring Boot and RDBMS environments, optimizing response handling and maintaining transactional integrity.
-
Blueprint for a High-Performance Redux Store
Learn how to optimize your Redux store for peak performance with clear steps and practical tips.
-
Navigating Global State Management - From Singletons to Redux
Discover the transition from singleton patterns to advanced state management with Redux. Learn why modern libraries offer superior scalability and maintainability for UI applications
-
Crafting Unique ID from Composite Attributes for Key-Value Pairs (Redis, Map, and even Droppable-Id in React Beautiful DnD)
Guidelines for generating clean, unique ID fields from composite attributes to enhance application maintainability and scalability, using encapsulated functions and semantically meaningful IDs.
-
Event Sourcing - Good Naming Convention, File Organization and Enforcing with ArchUnit tests
Find out a naming convention and package structure to generate clean event sourcing code.
-
5 Step Implementation of Custom Clean Event Sourcing in Spring Boot (without AggregateRoot)
Implementing event sourcing in Spring Boot from scratch is easy. You just need to understand some core concepts.
-
![Naming Convention for Indexes [Quick Read]](/images/naming-contention-database-redux-indexes.png)
Naming Convention for Indexes [Quick Read]
Create a clean descriptive index name
-
How to generate and enforce naming conventions for you and your team?
Creating a good naming convention that can help you and your team maintain a clean codebase
-
6 Approaches to come up with good variables, methods, and class names to create a fluent codebase
Easy approaches to help you come up with descriptive clean names
-
3 Important Benefits of Good Naming in Programming / Software
The Naming convention is more important than any other part of clean code. Once you nail the name, everything else fits precisely!
-
Efficiently Connect Components with Redux and Other Stores
A state management library like Redux, Recoil, etc., can help you manage application state for large applications. These come with their own set of challenges that can be eliminated with good design.
-
A Simple Vanilla Contract Test between Backend and Frontend
Response during unit tests can be saved in files which can be used for Testing UI.
-
Thinking Microservices - Don't tie yourself to one or more downstream (consumer)
Be careful not to introduce high coupling between microservices.
-
Understanding Event Sourcing
Event Sourcing is a paradigm where the entire state of an application is derived by replaying a series of events, providing benefits such as accurate auditing and schema flexibility.
-
Using ApplicationContext to Debug Spring Boot Faster
Using ApplicationContext directly can indeed be a handy approach for debugging without setting up the entire application infrastructure.
-
5 Step Process to Planning and Building a UI DOM Efficiently with Boxes, BEM and TDD
BEM, TDD, and thoughtful design supercharge web development by streamlining UI DOM planning for maximum efficiency.
-
Synchronous Request-Response over Kafka with Redis
Each message sent by a producer would include a unique correlation-id. Once the message is received and processed by the consumer, it will publish a response message back to Kafka with the same correlation-id.
-
Write Cleaner UI Tests with Page Object Model Pattern
Page Object Model can be used with any testing framework to write cleaner and simpler tests that are fast to write.
-
TDD example for REST API - CRUD
Extending our Movie example creating a REST API with TDD. Scenarios covered are Create, Read, Update and Delete.
-
TDD example on a backend - Upsert Method
Learn the foundation of TDD with a simple example explained in depth.
-
How to promote the habit of TDD within a Team
Promoting TDD within a team requires patience, consistent effort, and a focus on creating a positive and supportive environment for learning and improvement.
-
-
How we implemented OData for MongoDB and use it in OpenAPI
Implementing OData, Utilizing Specifications, and Enhancing API Flexibility.
-
Keep your business logic in the backend. Not frontend.
Making your application secure, high performance and maintanable.
-
Efficient Standups - Achieving Clarity through Walk-The-Board Standups
I believe walking the board is an important step towards facilitating Continuous Delivery. The standup format facilitates perfection in updates, focused on one card at a time which is closer to completion and takes less time to complete.
-
-
Automate Validation of Your Configuration
With TDD, you don't find any logical bugs. The remaining types of bugs are data bugs and configuration bugs. This article discusses configuration validations to find and fix config bugs.
-
-
-
-
-
Implementing an OAuth Server Manually
Implementing OAuth server is easier than it looks and it saves money in the long run.
-
BDD vs UI/UX/TDD - Understanding the Key Differences for Customer-Centric Problem Solving
BDD focuses on solving customer problems, not implementation details like UI. Those are addressed in other activities like wireframing and TDD.
-
-
You are really doing BDD when
Placeholder
-
Separating Connectors and Service (Business Logic) - A Key Principle for Service Reusability
Separating connectors from business logic in a service-oriented architecture promotes reusability and single responsibility.
-
Migrating DB smoothly with a migration script
Placeholder
-
-
Defining Scopes for your OAuth Service
Placeholder
-
RSA Algorithm
Placeholder
-
Start your project with Continuous Delivery till 'PROD'
How Zero-To-One is relevant in software development, why you should make Deployment&Delivery Pipeline first and how to make releases un-cool.
-
Template for Gherkin Specs
Placeholder
-
Observability For Developers
Fix bugs before your user reports
-
Code Review Checklist
Placeholder
-
Pre-save Data Validation
Data validation at various stages minimizes bugs and unnecessary overhead, ensuring consistent and accurate information flow.
-
Writing Meaningful Log Messages
Placeholder
-
My experience working with MongoDB
Placeholder
-
Adapting to Project Reactor / Webflux Mindset
Placeholder
-
-
-
Keeping database simple
Placeholder
-
The Prometheus Cheatsheet
The monitoring and time series database
-
Thoughts & Notes on User Stories
Details about breaking user story added
-
Fixing Tools - IDE, Code Editors, Etc.
Placeholder
-
Blind 75 - Invert Binary Tree
Swap left and right. Then repeat for those nodes.
-
Blind 75 - Linked List Cycle
Have a fast pointer and a slow pointer. fast increases by 2. slow increases by 1. if both become the same then the cycle exists. if fast one reaches end then no cycle exists.
-
Blind 75 - Maximum Depth of Binary Tree
go to each depth, incrementing a depth counter by 1. return max of it.
-
Blind 75 - Merge Two-Sorted Lists
Iterate over both and store minimum one in current; Increment in the list from where minimum came. Once one of the lists is empty, empty the other one.
-
Blind 75 - Number of 1 Bits
Check if the last bit is 1 by (n&1). Do the right unsigned shift (logical shift >>>). Loop.
-
Blind 75 - Reverse Bits
Get the last bit of value from the original. append to the reverse one. shift reverse one to the left. instead of adding, you can do `or` because after the shift last value will be 0. Imp - iterate 32 times only.
-
Blind 75 - Reverse LinkedList
Similar to swapping two numbers. Start with prev as null and current and keep swapping next. Return prev because that's the last value.
-
Blind 75 - Same Tree
Placeholder
-
Blind 75 - Subtree of Another Tree
Check if root is same as subtree or root.left is same or root.right is same;
-
Blind 75 - Best Time To Buy And Sell Stock
Make sure the left pointer is always the lowest yet. Keep checking the difference between left and right. And return max.
-
How to develop a robust plugin architecture?
Placeholder
-
Blind 75 - Valid Parentheses
God-level solution - iterate.<br>If an opening bracket is found, put the closing bracket in a stack.<br>If the closing bracket is found, pop and check for equality.
-
Blind 75 - Valid Palindrome
Have 2 pointers. One at the start other at the end. Skip if `!Character.isLetterOrDigit` and compare with `Character.toLowerCase`
-
JUnit Template For Tracking Bugs in Unit Tests
Placeholder
-
Blind 75 - Product of Array Except Self
Loop twice.<br>first right to left while multiplying.<br>Then second left to right while multiplying.<br>This can be done in a single array and one extra product variable
-
Blind 75 - Contains Duplicate
Create a set and put items in one by one while checking if `num` is already there.
-
Blind 75 - Top K Frequent Elements - IMP
count all numbers. sort. and return top k. Use streams to make it cleaner. or use bucket sort.
-
Blind 75 - Valid Anagrams
check if the length is the same.<br> find the difference in the count of letters in both numbers.<br> since there are only 26 letters, you can count in a single int array of 26. <br>index = char - 'a'
-
Blind 75 Two Sums
Make a map of item and index. Check if target - currentItem exists.
-
Why Framework Development Is Biggest Software Development Baton?
A Comparison between Application/Domain vs Framework Development
-
Increase collaboration for Developers
Placeholder
-
Understanding & Using HTTP Status Codes
Placeholder
-
Separate Technical Code From Domain Code in both Frontend and Backend
Separate out technical code from business/domain logic for extreme reusability for code.
-
-
Microservice Chassis
Placeholder
-
How to test interfaces, abstract classes and design patterns?
Testing interfaces, abstract classes, and design patterns efficiently can be tricky since parents and children depend on each other.<br><br>We can write tests to eliminate these dependencies during the test time, making our tests very short and decoupled.
-
Thoughts on Reading Documentation
Placeholder
-
Be a more empathic developer
Placeholder
-
Making Object Immutable for Concurrency
It's best to start with immutable objects and then modify them if needed.
-
-
How AutoConfiguration works in Spring Boot
Understanding and extending spring boot with custom AutoConfiguration
-
Chaos Engineering
A powerful way to increase resilence of a system
-
Ideal Development Workflow
From card picking to release
-
A responseType field for all response classes
Practical Chaos Engineering Part 1
-
TDD over JSON
TDD Example that saved around 2 hours
-
Feature Flagging
For Chaos Engineering and Continuous Delivery
-
Code Reviews and Pair Programming
Placeholder
-
Speed up Pipelines
Placeholder
-
Enforcing Architecture with Architecture Testing
Architecture is a crucial pillar of accelerating product delivery. It's hard to keep a team in sync with architecture over time. Architectural testing can enforce architectural decisions as simple tests, dramatically reducing code review effort and extending code maintainability.
-
Encapsulate Blocking Call the Reactor Way
Notes from Avoiding Reactor Meltdown
-
Writing better BDD specifications
Placeholder
-
What and when to publish on message queue
Placeholder
-
Mutation Testing
Placeholder
-
Leave Clues
Comments and Naming Conventions
-
Speeding Up Spring Boot/JUnit tests
From 8 minutes to less than 3 minutes.
-
Tips on fixing and upgrading Maven Dependencies
Placeholder
-
-
Writing better commits with Atomic Commits
Why small frequent commits leads to higher productivity
-
Always choose Reactive Programming
Multithreading programming has never been easier.
-
-
Rules of thumbs for Distributed System
Placeholder
-
Writing cleaner tests with creative variable names
Creative variable names in tests can make them fun and interesting to read.
-
Making TDD and Testing easier
Placeholder
-
Paper work is like DevOps
Placeholder
-
The Gist of Behavior Driven Development - BDD
The process that keeps everyone in sync
-
The need for executable specifications
Ideas shape development; specs sync teams; Gherkin tests ensure precision.
-
Writing better commit with conventional commits
Placeholder
-
Writing cleaner tests with Fluent Assertions
Fluent Assertions make tests highly readable and English-like, presenting a concise structure that simplifies comprehension
-
Writing cleaner tests with Test Data Factories
Consolidating object creation, mock of methods and more.
-
What to test to write after functional TDD
Placeholder
-
Make your code configurable.
Things that should take 0 coding effort
-
Debugging Effectively
Placeholder
-
-
Avoid Mocks and understand the blurry lines between Unit and Integration Tests
The distinction between unit and integration tests blurs with embedded implementations, combining accuracy from both while overcoming limitations of traditional mocks and infra-heavy integration tests.
-
Whenever you encounter a bug
Placeholder
-
Thinking and writing cleaner tests with method/when/should blocks
A template for thinking and creating understandable uniform tests
-
The Synchonized 3 Man Squad +/-1
Placeholder
-
Clean code - Naming convension for design patterns
Making it easy for future-code readers to understand
-
My current approach to TDD
A step by step algorithm
-
Elements of Good REST API Design
Placeholder
-
Maintaining Documentation
Placeholder
-
Using StackOverflow as challenge log
Placeholder
-
Angular and React Comparison
Placeholder
-
Typescript
A much better alternative to Javascript
-
-
-
CSS Tips
Placeholder
-
Tips for working with `package.json`
Placeholder
-
Solving N+1 Problem in Hibernate
Speed up fetching of child entities
-
Gist of DevOps
Placeholder
-
Applications of Recommender Systems
Placeholder
-
Quick Refactoring Tips
Placeholder
-
There is no one size fits all
Choose the right tool for the job.
-
Keeping Web Dev Code proper
Placeholder
-
User Experience
Placeholder
-
-
Open Source Software (OSS)
Impact, Revenue and Deceptions.
-
A replicable Development Environment with Docker + VS Code
Mitigating the most discoraging part of software development
-
Developer Productivity
Placeholder
-
How I learned basics of programming.
Placeholder
-
Write Tests after Cleaning Code.
Placeholder
-
First Hackathon
Placeholder
-
Software project never ends
Unless you stop
-
Office is just school for adults
Placeholder
-
Cloud is Worth the Hype
Your robot on the internet
-
Tips for coding on a slow computer
Placeholder
-
-
-
Faster SQL Batch Save in Spring Data JPA
Placeholder
-
-
Programming is now Configuring
beyond algorithms and data structures
-
Deciding to learn a \{programming\} topic
Placeholder
-
How we created a query and evaluation language similar to Google Sheets and Excel formulas
Using the best current programming language creation-tool.
-
Agile and DevOps
Placeholder
-
Clean Code Resources and Tools
Constructing the simplest possible code
-
Advice for those who want to learn Deep Learning
or Machine Learning
-
Series Kaggle Getting Started
Baby steps towards competitions
-
Digit Recognition
MNIST: Kaggle Getting Started
-
-
Simple Hacks for increasing website load time
For those who don’t require Google level optimization
-
Leave it better than you found it
Atomic Habits applied to code. Thanks James Clear.
-
Exception handling
and Logging with style
-
Remove un-necessary code
You ain’t gonna need it
-
Avoid inventing algorithms and data structures
especially for maths
-
Avoid creating god classes and long methods
Minimalism
-
Make the database do the heavy lifting
You cannot compete with SQL
-
Flat is better than nested
Leave when not okay
-
Clean Code
constructing the simplest possible code that would solve your problem resulting in an increase in productivity by producing higher quality in less time.
-
10 Google Collab Tips
Placeholder
-
How To Download Dataset From Kaggle
Using Kaggle CLI
-
Easy Jupyter Notebook Tips
Placeholder
-
Lessons Learned from my first Deep Learning contest
Game of Deep Learning was an image recognition challenge on AnalyticsVidya. The task was to classify 5 different types of Ships (Cargo, Military, Carrier, Cruise, and Tankers)