363 Blog Posts To Learn About Code Quality

Let’s learn about Code Quality via these 363 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.

Whatever your metrics for judgement are, code quality stories on HackerNoon provide pointers that ease your way.

1. Overloading Vs. Overriding in C#

Method overloading and overriding are two common forms of polymorphism ( the ability for a method or class to have multiple forms) in C# that are often confused because of their similar sounding names. In this article, we show the difference between the two with some practical code examples.

2. Effective Code Splitting in React: A Practical Guide

Large bundle sizes and slow startup is a common problem faced by single-page applications (SPAs), since they typically download all the JavaScript required for every single page of the application right at the start, before rendering a single pixel.

3. Software Maintenance Types: Corrective, Adaptive, Perfective, and Preventive

Enhancing product functionality, reducing deterioration, and satisfying the needs of users – all of that is achieved through software maintenance.

4. How to Set up C++ Debugging in VSCode Using a Makefile

This tutorial will demonstrate how to set up VSCode for compiling and debugging C++ in a way that causes it to trigger a makefile target compilation each time.

5. Effective Static Code Analysis Techniques for Improving Code Quality

Increase the value of your static code analysis with the help of test impact analysis and predictive test selection.

6. Why It is Important to Monitor Code Quality

Code is a book and what the reader gets out of this book will depend on how the code is written.

7. How to Detect Malicious JavaScript Code

JavaScript is a powerful tool that has changed the way we interact with websites and different apps.

8. Using Black To Auto Format Your Python

How to stop worrying and embrace Auto Formatting in your python code.

9. WebdriverIO Vs. Selenium: Who Will Win?

Selenium is the most popular web UI automation tool, but does that mean that it’s the best solution in test automation market?

10. Are Implicit Operators a Path to Clean Code or a Buggy Nightmare?

Implicit operators are a C# feature that can make our code more readable and expressive. But beware! Misuse can backfire and cause a great deal of headaches!

11. Creating Clean Architecture Using Golang

Hi guys, I’m a Front-End developer. Before there was a time 2 years working CMS Magento, I like CMS Magento because system clean, and architecture database EAV (Entity — Attribute — Value) but I don’t understand why present I’m dev front-end (I don’t know) in the 2-year current. And present I chance comeback working position Back-End that I like.

12. Introduction to Object-Oriented Design Patterns

After hitting a certain level of experience & spending quite enough time in the industry, I have realised the importance of designing/architecting system & software. So I have started looking into system/software design & got to know nothing can better start than a Design Pattern. And the first thing I have done is googling “What is Design Pattern?” Hence got the idea of this article.

13. 10 Coding Hacks to Remember in 2023

Let’s take a look at some of the best coding hacks to remember in the new year.

14. How to fix Security Vulnerabilities in NPM Dependencies in 3 Minutes

Hola people!!! 🥑

15. Python Static Analysis Tools: Clean Your Code Before Running

Review of essential modern Python code static analysis tools.

16. Streamline Your Software Testing with Batch Testing

By employing batch testing, we can validate various scenarios and edge cases related to user registration in a consolidated manner.

17. GO Design Patterns: An Introduction to Builder

Streamlining Your Code: An Introduction to the Builder Pattern in Go

18. Flood Fill Algorithm with Recursive Function

We all are known to the “Bucket” tool of Microsoft Paint which is used
to fill an area with single specific color. But do we know how it actually
works? Well, Let’s discuss this.

19. Making Your Code Look Pretty

When you are new to programming, you’re focused on making your code work—not on making it look pretty.

20. 7 Qualitative Metrics to Measure Code Quality that Every Engineer Needs to Know

High-quality code is critical to creating functional error and bug-free software that is easy to edit and understand. Let’s look at how to measure code quality.

21. The Basics of Penetration Testing

Here is the detailed blog on penetration testing. Check it to know what it is, its steps, methods, and the best tools for penetration testing.

22. How to Measure Your Technical Debt: 8 Metrics to Consider

Technical debt metrics help you to monitor deficiencies in your current codebase. We decided to look at how they work, and pick out the best tracking tools.

23. How to Upload Source Maps to Sentry with Next.js

Troubleshooting with source maps uploading to Sentry with Next.js

24. Automated Software Testing Using GitLab CI/CD And Selenium Grid

We will configure a CI/CD pipeline with GitLab CI/CD and execute Selenium testing over it through LambdaTest, an online Selenium Grid of 2000+ real browsers.

25. What is the Basic Structure of a Programming Language?

Programming languages enable complex applications and efficient issue-solving in modern software development.

26. How Google’s Python Code Style Guide Can Help You Speed Your Engineering Team

Creating a consistent style guide for your codebase can help your team be more consistent and productive. Here’s how Google’s Python Code Style Guide looks like

27. Refactoring With Tests in Python: a Practical Example

This post contains a step-by-step example of a refactoring session guided by tests. When dealing with untested or legacy code refactoring is dangerous and tests can help us do it the right way, minimizing the amount of bugs we introduce, and possibly completely avoiding them.

28. Are Unit Tests a Waste of Your Time?

Unit tests are just a waste of time: you’ll always end up spending more effort maintaining them than writing code

29. Asynchronous Programming Techniques with Kotlin

An introduction to Kotlin coroutines compared to Futures/Promises such as Reactor’s Mono or Java’s CompletableFuture

30. Functional Testing With Your Backend in Go

For Terrastruct, which has a little over 50K lines of code as of now, I’ve only written functional end-to-end tests. This blog post describes a successful setup that took some iterating to get to, and it’s one I wish existed when I started with a Go API backend.

31. C++ Metaprogramming: Variadic Templates & Fold Expressions—Now with 100% Less Headaches

Explore modern C++ variadic templates and fold expressions to simplify code, handle multiple arguments, and write more maintainable code

32. How to Configure Rubocop in Code Base

Rubocop is a code-style linter for Ruby based on the official Ruby style guide.

33. The Limits of LLM-Generated Unit Tests

LLMs can generate unit tests, but do they truly validate code behaviour? This article explores Codex experiments revealing their real limits and pitfalls.

34. A Comprehensive Guide for Handling Errors in Rust

This article address how errors are handled with the Rust programming language.

35. Using the Dynamic Regression Model (DRM) in Software Development

Boost software testing efficiency with Dynamic Regression Model (DRM). Understand dependencies, update test plans, and use feature matrices for better results!

36. My Top 10 JavaScript Articles from 2019

JavaScript has come a long way since its humble beginnings as a clunky, exclusively front-end scripting language. We saw some big developments in the JavaScript landscape during 2019, including the widespread adoption of React hooks and functional programming concepts, steady conversion to TypeScript, and continued domination of React in the front-end framework ecosystem.

37. 100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

Clean Code by Robert C. Martin is the most recommended programming book of all time. There’s a good reason why.

38. C++ Metaprogramming: Compilation of Calculations, from Basic Techniques to Advanced Methods

Discover how to leverage templates and constexpr in modern C++ for faster, safer compile-time calculations. Uncover practical tips, pitfalls, and best practices

39. It’s 2023, But We Still Need to Talk About Nested Styles in CSS

Why don’t I need to use nested css styles in my product and why is it a bad practice.

40. Streamlining Your Django Development Environment with Docker Containers

Learn how to containerize an entire Django project from the ground up, including a Postgres database, Redis cache server, Caddy, and Celery instances.

41. A Code Review Checklist to Focus on the Important Parts

A code review checklist, as well as clear rules and guidelines around code reviews, can make your code review practice so much more beneficial to your team and significantly speed-up code reviews.

42. Why You Should Always Avoid Encoding Type Into Names

The Rule: When naming a variable, don’t encode it’s type into its name, even in a dynamically typed language.

43. Data Access for Microservices

If you want to access data in a distributed environment such as in a microservice architecture, then data services are the way to go. The idea is to create a data abstraction layer (DAL) that the rest of the system’s applications and services can share. Thus, a data service gives you a generalized interface to the data you’re exposing and provides access to it in a standard manner. This would be in a well-understood protocol and a known data format. For example, a popular approach is to use JSON via HTTP/S.

44. Top Security Penetration Testing Companies

Cybercrime is one of the world’s fastest-growing threats, with malicious actors constantly elaborating their methods of undetectable intrusion. According to Verizon’s Business 2020 Data Breach Investigations report, there has been a 100% increase in web app breaches, and stolen credentials were used in more than 80% of these cases. These statistics are worrying for many businesses that actively move their processes to the cloud and deal heavily with customers’ personal data.

45. Why the Hell Do People Confuse Prettier With Eslint?

Clearing up the confusion between Prettier and ESLint. Prettier tidies code, ESLint ensures quality. Use both wisely!

46. Laravel Real-Time Monitoring Using Inspector

Hi, I’m Valerio, software engineer from Italy.

47. This Is What I Learnt After Making Over 1,000 Code Reviews

This story was originally published on my blog. If you’re interested in this kind of content, feel free to check it out and subscribe 🙂

48. Continuous Integration (CI) Branching Strategies: What You Need to Know

When you have multiple developers working on the same code, you may face a lot of challenges when merging. That’s where branches come in.

49. Why Rust Is So Popular?

If you are looking for some kind of metal panel business idea, allow me to be clear: the Rust I am referring to is a programming language.

50. Understanding Currying, Closures, and Coupling in JavaScript

Here’s a problem. You have an object in your code exposed via an export. You also have a function in the same file (also exported) consuming that object directly.

51. How To Use Git Merge: Beginners Guide

Isolating features into different branches is a crucial practice for any serious developer. By separating each feature, bugfix or working experiment you will avoid a lot of problems and keep your development branches clean.

52. Reset, Revert and Checkout in Git

Git toolbox provides multiple unique tools for fixing up mistakes during your development. Commands such as git reset, git checkout, and git revert allow you to undo erroneous changes in your repository.

53. How to Build Awesome Integration Tests with Capybara

Tips that would help you build integration tests using RSpec and Capybara.

54. A Walk-Through to Github For Beginners

And slowly github became the new facebook for coders where instead of posting pictures and life events people post code for projects and your fellow developers comment, request features and fork the code to suit there needs.Brian Doll, GitHub’s vice president of strategy says “If you look at the top 100 sites, you’ve got a handful of social sites, thirty flavors of Google with national footprints, a lot of media outlets — and GitHub”

55. How do I Encourage my Manager to Support Automated Tests?

56. 7 Laravel Tips You Should Know

Hello, my name is Adrian. After writing an article about 6 Eloquent Tricks Every Laravel Developer Should Know and receiving a better than expected feedback from the readers, I decided to show some more Laravel tips that are used at Weap.

57. From “Feature branches” to “Feature environments” with Terraform

“The advantage of feature branching is that each developer can work on their own feature and be isolated from changes going on elsewhere.” (FeatureBranch)

58. Programming Principles for Beginners

A lot of us have struggled with algorithms and data structures. When I began with programming at my University, the name of a subject that got my attention and got me motivated to find my life call was the Principles of programming. I started devoting a lot of time to figuring out how to solve professors’ assignments. Now those algorithms are easy for me but then they were not, and I couldn’t pass the exam, I had the wrong approach in learning, you can not memorize them, you must practice and figure out what you need to do.

59. Git Branches

In the current era, most software development companies work in a collaborative environment where several developers contribute to the same source code. While some will be fixing bugs the others would be implementing new and different features. The problem raises, how to maintain different versions of the same code base?

60. 12 Essential Coding Standards for Quality Web Development

The delivery of high-quality code is crucial in the constantly changing world of web development, and coding standards compliance is essential. In addition to improving development productivity, writing clear,well-organized, and maintainable code guarantees the longevity and scalability of online projects. We will look at the coding standards in this blog article to make sure that high-quality code is produced in web development projects.

61. Why Letting AI Handle Your Code Reviews Might Be the Best Decision You Make This Year

Code reviews have always been crucial in maintaining a standard and emphasising on the best practices of code in a project. This is not a post about how..

62. SOLID Principles of Object Oriented Design And Architecture

Object oriented programming (or OOP) is a style of programming that encapsulates data and behaviours into models known as objects. In this way, related code is grouped together and kept separate from other code, and provides reusable blocks that can be used to rationalise the problem at hand.

63. Advantages of Using RXJava Over Java 8 Stream

Java 8 stream has made my programming life simpler as a software engineer. However there are a lot more that can be improved by incorporating the RXJava library. RXJava contains tons of functionalities to process streams or observables.

64. Avoiding Software Bottlenecks: Understanding the ‘God Object’ Anti-Pattern

Avoid software bottlenecks by understanding the ‘God Object’ anti-pattern in object-oriented programming. Learn its impacts, examples, and best practices.

65. The Importance of Code Quality, Explained

One would expect that writing code which any programmer can read and understand would be an inherent skill of software developers. The fact is that only 20% of programmers have this ability. The code that you are writing must be understood not only by the machine but also by humans. In software development, quality should be everyone’s priority. Throughout the development process, the goal should be the delivery of good quality and working code.

66. The Battle Between Jest and Mocha for Testing JavaScript Applications

Jest vs Mocha, which one should you chose? What are the pros & cons? All about our experience about making the call between Jest & Mocha.

67. Onboard New Developers with Better Coding Practices

Onboard new developers take time, so you need to set up an efficient process to boost their appropriation of your technical culture and your best practices

68. Functional Programming Techniques in Java with Examples

If you’re a Java developer, I’m sure that you have seen code similar to the featured image snippet above at least once. The code in the snippet above is an example of functional programming paradigm implementation in Java, which will filter and transform the List<String> in the request to another List<String>.

69. Top 7 Smart Contract Auditors to Check For Your Smart Contract

Top 7 Smart Contract Auditors. We look at the best in web3 & smart contract security, and give you a list of who they are.

70. Analyzing Your Code With SonarQube Running via Docker Image

Dockerize Your C# Code Analysis: A Beginner’s Guide to SonarQube and Docker Image.

71. How To Improve Code Quality With Code Reviews and Refactoring

Originally published at Managing Technical Debt.

72. How Do Code Reviews Work at Google?

Code reviews at Google play an important role as an engineering practice and have been adopted already in the early days of Google. Still today, they are used to keep the code base clean, coherent and to ensure no arbitrary code is committed. Even though the code review process looks similar to code reviews at Microsoft, there are some Google specifics that allow for a particular lightweight code review process.

73. Groundbreaking Tips On How To Use XPath In Selenium

Identifying element has always been the trickiest part and therefore require an accurate and correct approach. If you are unable to find elements by the easily available approaches like ID, class, name, link or tagname then XPath in Selenium can help rescue you. Locating dynamic elements have always been the pain area while you wish to automate the scripts, the only ray of hope to deal with such fiascos is XPath. In my current article, I will be digging into the steps of locating an element via XPath example in Selenium and its various ways.

74. Helpful Tips for Writing Clean Code

In this short, but nonetheless useful article, I have summarized the most beneficial tips for writing clean code. These rules are independent of the language you use and are invaluable for both beginners and experienced programmers.

75. An Essential Guide to Code Quality

Just like quality assurance is done in manufacturing, testing code quality is also done in software development. While developing software or if you’re inspecting code written by your team, you need to make sure you verify its quality at every level of development before it gets more complex. In the world of software, the phrase code quality can be interpreted in different ways by different industries and teams.

76. 4 Simple Habits For Engineering Teams To Beat Technical Debt

In the previous article, we looked at the macro trends that make tech debt inevitable. However, even though tech debt is a fact of life, technical bankruptcy doesn’t have to be. So this time, let’s look at the methods we can employ to avoid technical bankruptcy and save everyone a lot of grief, time, and money.

77. Keeping Your Code in Monorepo -Pros and Cons

78. Less Dirty Code

Clean Code is a Lie and Nobody Writes it.

79. Code Smell 260 – Crowdstrike NULL

Learn how to avoid the null trap in privilege mode drivers to prevent system crashes, security risks, and instability.

80. I Told My Team to Complain Every Week—It Transformed Our Productivity

Over time, Kaizen has helped improve processes, boost morale, and even tackle technical debt bit by bit. It’s a simple but effective way to ensure continuous i

81. The Hidden Cost of Over-Engineering (and How to Stop Yourself)

Over-engineering feels like smart planning—until it slows you down. Learn how to spot the signs, avoid common traps, and keep your code simple, scalable, and ma

82. Code Review Is Inherently Flawed. Here’s How to Fix It

The classic code review process contains several severe flaws and should be redesigned. The story depicts how to do so.

83. Exception Handling with Examples

Exception handling is common to most programming languages, and the mechanism and behaviors are similar in most languages: trycatchfinally. It is well documented. We are not going to discuss that.

84. How To Debug React Native Debugger

React Native Debugger is a powerful tool that helps developers debug React Native applications more quickly. It provides a suite of impressive features, such as UI inspector, redux inspector, breakpoints and networking inspector. In this article, we are going to learn how to install and use the React Native Debugger, which will boost your development productivity by an order of magnitude.

85. How To Set Up a tsconfig For Nodejs

Learn how to easily setup a tsconfig file to build for nodejs.

86. How To Write Unit Tests, Elegantly

“If you don’t like unit testing your product, most likely your customers won’t like to test it either.” — Anonymous

87. Code Refactoring: A Comprehensive Guide for Engineers

In this guide, you’ll learn all about refactoring source code: the benefits, challenges, tools, and best practices, and what is the difference between refactoring and technical debt.

88. How to Mock Azure Event Hub in .Net Unit tests

.Net NUnit tests for Azure Functions with Event Hub Integration

89. Turn Your IDE Into a Powerhouse for Laravel Development With These Plugins for PhpStorm

I will cover plugins that I use and recommend for your PhpStorm installation.

90. How We Set Up a Production Ready CI Workflow Using GitHub Actions

Recently, we started a new project and it decided it was a good time to try GitHub’s newish CI/CD tools which became generally available in November last year.

91. Memento Design Pattern Overview

Memento design pattern is a software design pattern that is used to roll back an object to its previous state. It is a part of the behavioural design pattern which is concerned with algorithms and assignment of responsibilities between objects.

92. Code like You’re Building a Lego Castle

The article compares coding to building a castle with Legos and emphasizes the importance of following best practices to avoid mistakes and build a sturdy code.

93. The Next 11 Things You Should Do For CI/CD Pipeline Optimization

Many engineering teams are making the switch to a DevOps culture. This has a lot to do with the way the software development cycle has changed over the years. It used to take months to implement a new feature, get it through testing, fix any issues, and finally get it to production.

94. Understanding Prototype Chain And Inheritance in JavaScript

JavaScript is a bit confusing for developers experienced in class-based languages (like Java or C++), as it is dynamic and does not provide a class implementation per se (the class keyword is introduced in ES2015, but is syntactical sugar, JavaScript remains prototype-based).

95. What Do Engineers Really Think About Technical Debt?

My team at Stepsize has surveyed 200+ Engineers and published the State of Technical Debt 2021 Report that explores the impact of tech debt on companies.

96. Micro Optimization: Don’t Get Lost In The Rabbit Hole

I had to settle a performance discussion within my team. Because of a simple PR, I started a 2 weeks journey in the dark twists and turns of javascript. To save you a lot of pain and frustrating questions, I sum up my research in this really long post. I tried my best to show you the train of thoughts but if you don’t care about the details, you can jump to the end for the TL;DR section.

97. The Dirty Code Problem: Improve Your Game with Good Naming Practices

The Rule: Whenever you name a variable, function, or class, ask if it is concise, honest, expressive, and complete.

98. Software Design Principles: Doing Little Things Right

Designing software systems is about tradeoffs and making tradeoff decisions is hard. You always feel like you are loosing one thing or the other but that’s not what we are going to talk about today.

99. How to Organize Unit Tests for AI-Generated Code

AI writes code faster than you can review it. Here’s a structured unit testing method that keeps your codebase trustworthy and easy to maintain.

100. How To Integrate Security Testing Into Your Software Development Life Cycle

101. Conditional Breakpoints: A Guide to Effective Debugging

Master effective debugging with conditional breakpoints. Streamline your process, tackle complex bugs, and deliver higher-quality code with precision and power.

102. Always Leave the Code Better than You Found It – Boy Scout Engineering 101

Most engineers have heard of the ‘boyscout rule’: ‘Always leave the code better than you found it.’ It’s often been heralded as a magic cure for technical debt; if only all software engineers behaved like good citizens, our software wouldn’t deteriorate so relentlessly.

103. How to tell if your code actually sucks…

There is no better moment for me than starting a brand new project.

104. An Introduction to Test-Driven Development

Test-driven development (TDD) is all the rage these days and has been a discussion topic for quite some time. If you are brand new to TDD, this article should serve as a good introduction to what TDD is, why it’s useful, what a typical TDD workflow looks like, and when to use TDD.

105. Microservices and Service Mesh with Istio, Explained

Application builds when broken down into multiple smaller service components, are known as Microservices. When compared to the traditional Monolithic way, a Microservice Architecture treats each microservice as a standalone entity/module, essentially helping to ease the maintenance of its code and related infrastructure. Each microservice of an application can be written in a different technology stack, and further be deployed, optimized and managed independently.

106. 5 responsibilities of a Tech Lead and 17 Metrics to Track Their Performance

Tech lead, team lead, software architects, and engineering managers — as any developer already knows, naming is hard. Throughout the industry, those roles are as fuzzy as their responsibilities.

107. Modularity Concept in Java and .Net

Modularity is central to modern software engineering – or may be all type of engineering not just software. We’ll explore support for modularity in Java and .Net platforms, but before that let’s first try to find answers for what and why of modularity.

108. How to Write Clean Code and Save Your Sanity

Learn how to write clean code that will save you time, headaches, and sanity. This article covers practical strategies & tools to help you elevate your coding.

109. Clean Code: Classes and Objects in TypeScript [Part 3]

Learn how to write clean and maintainable code in TypeScript by following best practices for classes and objects.

110. Continuous Testing vs. Traditional Testing

We hear the term ‘continuous testing’ a lot in the software testing industry. It’s one of those buzzwords that just keeps coming up, time and time again.

111. Hacking Your Way Through Microservice Architecture

With an emerging pattern of organizations embracing the DevOps framework, adopting Microservice Architecture is steadily gaining the respect it deserves.

112. What are Unit Tests and Why Should You Write Them?

Unit tests might seem like a waste of time to a junior programmer, but they bring significant advantages with them such as faster checks that makes better code.

113. Building Your Own Toolbox with Extension Methods in C#

Extension methods are one of the coolest features of C#. It allows our custom methods to be used on the objects without needing to extend or change the underlying class.

114. Why is This So Hard?

This article explores what good code is and shares some tenets of good structure.

115. Reducing Time Spent on Refactoring 3 Tips from a Dev

Recently, I had to deal with an old codebase that was difficult to maintain and scale. In this article, I’ll share how my team and I decided to deal with maintenance and the best practices we implemented to reduce time spent on refactoring.

116. Newbie React Developer? Watch Out for These 15 Common Mistakes

15 common mistakes that every newbie React developer ends up making

117. Biome.js: The New Challenger to Prettier and ESLint

Explore the evolving landscape of JavaScript development tools with our analysis on whether the reign of Prettier and ESLint is coming to an end.

118. A Guide to Using Data Classes in Python

In “C” Language, you have structs. With the help of structs, we can define the return data type. You can do the same using classes in python.

119. The Secret To Succesully Simulate An Attack With Gremlin To Test Kubernetes

Gremlin is a leading software company focusing on chaos-test in the market. It also has a tool similar to Chaos Monkey which belongs to Netflix, but is more customized to test the system with random loads or scheduled shutdowns. In the article below we will be testing a simple Kubernetes cluster running on EKS with Chaos Test.

120. Creating a Strong Code Quality Culture in Your Organization

Learn how to build a culture of code quality to improve maintainability, scalability, and efficiency, and stay ahead of the competition.

121. How To Use Nightwatch.js Framework For Test Automation

Selenium is a widely used tool for automated browser testing. Being an open-source framework allowed Selenium to be compatible with multiple test automation frameworks for different programming languages and if we talk about automation testing with Selenium and JavaScript, there is a particular framework that never fails to take the spotlight and that is the Nightwatch.js. This is why I decided to come up with Nightwatch.js tutorial for beginners.

122. How To Use Gulp And Prettier on Code Snippets and API Outputs

Code editors come with “beautifiers” which programmers can use to make code uniformly and conventionally laid out, aka: “pretty”.

123. Early Exit From Functions

Ok! It’s crucial to keep the code readable and maintainable. One of the easiest ways to increase readability is terminating early from methods/functions.

124. Tips For Documenting Your Code

Some will tell you that good code is self-documenting. In other words, if you write clear code then you won’t need comments.

125. The Myths and Realities of Bug-Free Code

126. Setting Up Ruby on Rails On Github Using CircleCI [A How-To Guide]

This is the ultimate guide for your next Ruby on Rails project setup on Github with CircleCI for continuous integration in 2020.

127. Introducing Microservices Security in Action

The book Microservices Security in Action, which I authored with Nuwan Dias is now available to buy online from Amazon and Manning. Nuwan and I spent last 27+ months writing/re-writing the book. It was a marathon effort, but yet a great experience, and we both are very glad to see how it came out at the end! This is the story, which lead us to write the book.

128. Design Patterns: Singleton Pattern in Modern C++

In software engineering, Creational Design Patterns deal with object creation mechanisms, i.e. try to create objects in a manner suitable to the situation. The basic or ordinary form of object creation could result in design problems or added complexity to the design. In this article of the Creational Design Patterns, we’re going to take a look at the much-hated & commonly asked design pattern in a programming interview. That is Singleton Design Pattern in Modern C++ which criticizes for its extensibility & testability. I will also cover the Multiton Design Pattern which quite contrary to Singleton.

129. How to Write Meaningful Code Comments

In this guide, you will learn why it is important to write code comments, what are different code comment types, and the 4 best practices.

130. Writing Good Commit Messages: A Practical Guide

To create a useful revision history, teams should first agree on a commit message convention to use, and this also applies to personal projects.

131. What to do When You’re Tired of Slow Code Reviews

An ex-tech lead’s guide to create a healthy code review culture that helps you ship your code faster.

132. 10 Expert Tips for Improving Code Reviews: A Guide for Developers

Code reviews are an essential part of the software development process. In this article, we’ll discuss 10 best practices for conducting effective code reviews,

133. Future of DevOps: DevSecOps, AIOps and something else?

DevOps have become a popular term in the software industry since 2009. The primary reasons behind this increasing popularity are the high-speed and less-cost of development. DevOps were born to meet the increased software industry velocity. In comparison to DevOps, traditional Ops are 41% more time-consuming.

134. How Internal Developer Platforms Impact Your DevOps Team Success

This article takes a look at DevOps under the hood, with a deep dive into the use of Internal Developer Platforms to improve self-service and developer workflow

135. How to Setup SonarQube Locally Using Docker

I will explain how you can set up SonarQube locally with docker.

136. Python @classmethod vs @staticmethod vs Module-level Functions

When studying Python, you inevitably face the problem of choosing between static methods, class methods, and module-level functions

137. An Introductory Guide to Building a Website with Good Quality Code

Guaranteeing code quality when your website is in the development stage is a colossal task. However, even with a steady number of programming designers, keeping up code quality can be daunting. Without code quality tools and a reliable framework, the entire task can amount to enormous technical debt, doing more harm than good in the long haul.

138. The Diffusion of Responsibility Phenomenon Analyzed: Unravel the Truth

Data-based analysis shows that Collective Code Ownership can do harm and affected code areas can probably become hotspots of maintenance.

139. Hack Your Technical Debt: The 1% Better Every Day Challenge

It’s easy for technical debt to grow in our codebase. Commit to spending 20 minutes a day for 30 days to tackling technical debt and get 1% better every day.

140. 5 Metrics to Track when Refactoring your Codebase

Code refactoring provides a well-needed mental break for developers, and I think many devs can relate to this. Writing code all day is very demanding, especially if you create new functionality day by day. It’s a taxing exercise, and developers often need some space to think about the codebase’s overall organization and look back on what can be improved.

141. What is Functional Programming?

Most of what I will discuss in this article is knowledge accumulated from reading, “Functional Programming in JavaScript”, by Luis Atencio. Let’s dig right in…

142. The Engineer’s Complete Guide to Backlog Grooming📝

Without organization, backlogs get messy quickly, and issues can’t be prioritized.

143. Code Reviews: A Practice That Depends on Culture

It would be way easier for managers if they could only draw a flow chart explaining how code review works. The manager then would email all the peers, telling everyone should follow the new process.

144. 5 Best Practices for Writing Efficient Python Code

In this article, we’ll discuss some basic principles of coding in python that can help you optimize your programs’ performance.

145. Avoiding the Pitfalls of Unit Test High Code Coverage With TDD

High unit test code coverage is often viewed as a key indicator of code quality, but it’s important to focus on the quality of the unit tests, not just the cod

146. Move Business Logic out of Application Using Higson Engine

Well-written multitier applications consist of multiple layers. The most widespread three-tier architecture divides our code into a presentation, business and data access tiers. Like it or not, but the business layer is where we, developers, spend the most time on a daily basis. This is the place where all processes and decisions our application depends on take place. Therefore, requirements for the business layer change more often than in any other layer. What hurts us, developers, most is that with every change, even the smallest ones, we need to recompile and rebuild our app. It usually takes a piece of the valuable time that we could use for more interesting things. What if we could move a business logic out of our code and let non-technician people change it?

147. Better Application Acceptance With LogRocket

Application Acceptance

148. Best Advice On DDD For Data-Focused Devs

The domain design approach to software development contributes to solving a specific domain model. It revolves around the business model, linking execution to key business principles.

149. Can You Make a Bug on Purpose?

At first glance, the question “Can you make a bug on purpose?” may seem banal. However, if you think about it, everything doesn’t seem so obvious anymore.

150. You Absolutely Need To Read This To Master AWS Lambda [Part 1]

Welcome to the Serverless world. One of the first things you’ll hear about is AWS Lambda – and you’ll continue to keep hearing about it! While architecture can be serverless without Lambdas involved, it’s very often the key component within a serverless application. In the first post of this 3-part AWS Lambda Handbook series, we run through what is AWS Lambda, dialling back to basics with the various terminology, how to create a Lambda function and how to run it.

151. How to Stop Developers from Writing Low-Quality Code

Developers tend to go for getting things working, ending up with a working program, lacking the quality you would like to see. In this article I will explain how to get quality code as well.

152. Technical Debt Horror Stories Shared by Developers (Part 1)

I asked a bunch of developers to share some of their horror stories of technical debt.

153. Tests Automation with Examples: ‘Click’ Button Method in Selenium

One of the most fundamental and crucial interactions while Selenium automation testing is done by automating click operations over elements on a web page. We facilitate the click interaction using a method called Selenium.click().

154. Mastering Git and Version Control: A Beginner’s Guide

Understanding version control and mastering git – The basics…!!

155. Fundamental Concepts of Angular

Fundamental Concepts of Angular for beginners to advanced level developers.

156. The Technical Debt Illusion: From The Trenches

Originally, the metaphor of technical debt was introduced to help us explain the need for refactoring software systems to upper management.

157. How To Manage Technical Debt Properly

We’re used to thinking that you cannot deliver fast and maintain a healthy codebase. But does it really has to be a trade-off?

158. Fight Technical Debt With These 10 JetBrains Extensions

I see many Engineering teams under huge pressure to build fast and often lacking time to fix and clean up their codebase.

159. To Log Or Not To Log, Is The (Eternal) Question

An alternative logging strategy to make loggers your friends, not enemies

160. Swift Dependency Injection With Functions

Implementing an architecture within an application can be challenging. There are rules we can follow (SOLID, Clean Architecture) and patterns to guide us (MVVM, MVP, MVI, Redux, …) but sometimes, things we thought were well established deserve a step back.

161. You’ll Never Fix It Later – How to Pull Your Team Out of the Quicksand

The more quick and dirty code you write, the more stuck you’ll get with it blocking you from releasing any piece without a big bang. Pull yourself out.

162. Laravel Background Processes Analytics with Inspector

In this article I would show you how to turn on analytics in the dark side of your application: “background Jobs and scheduled Artisan commands execution”.

163. How to Improve Your CI/CD Workflow Using GitHub Actions

GitHub Actions is one of the most powerful tools that you can use if you are storing our code on this service repository. The idea is simple, you can design a complex workflow using automated tasks (called actions) in order to be activated and run when a commit is done in your repository.

164. Technical Debt Management is Important: You Can’t Keep Building on a Broken System

Every software company has some amount of technical debt, which is additional development work created in the long-term by taking a shortcut in the short-term to get code out the door. Technical debt can take the form of poor design decisions, much-needed refactorings, technology upgrades, and outstanding bugs.

165. How to Prevent Code Reviews from Wasting Everyone’s Time

This post is the fourth article in our Tactical Guide to a Shorter Cycle Time five-part series. Read the previous post here.

166. Is Dry Code Still Relevant Today?

167. Open Closed Principle With Service Locator Pattern

Open closed principle is the most simple one in the list of software design principles I understand. “Open for extension, close for modification” – the idea seems quite straightforward. Let’s create an example about validation.

168. Why SaaS Companies Require Security Testing?

SaaS companies offer a lot of flexibility when it comes to providing essential software solutions to their customers. They have an added advantage of being easily accessible and that too on all kinds of devices. As a result, the modern age businesses are rapidly switching to these solutions provided by SaaS vendors.

169. Navigating the Debugging Abyss: Conquering Mobile App Bugs in an Adrenaline-Fueled Adventure

A story of the ups and downs of debugging a new mobile app, full of unexpected twists and turns.

170. Is Your Code Overly Complex?

Cyclomatic is one way to measure code complexity – but it isn’t a great option. We look at two metrics – Cyclomatic Complexity and Cognitive Complexity.

171. The Code Is the Documentation; a Paradox That Rings True

The first time I heard someone say: “the code is the documentation”, I thought it sounded completely wrong, like a lazy excuse for not producing documentation.

172. Understanding JavaScript Generators And Basic Use-Cases

In one of my many deep-dives about JavaScript, I came across generators. They looked interesting.

173. Replace Comments With Better Code

Hi, I’m Valerio, software engineer from Italy.

174. Approaching Unit Testing in iOS Correctly

Why does my application get so buggy after each release?

175. GitHub Security: How To Protect Your Company From Credential Leakage

Disclaimer: I am the CEO of GitGuardian, which offers solutions for detecting, alerting and remediating secrets leaked within GitHub, therefore this article may contain some biases. GitGuardian has been monitoring public GitHub for over 3 years which is why we are uniquely qualified to share our views on this important security issue.

176. Why You Should Automate Your Code Review

It’s 2020 and there are plenty of tools to help you develop better code. The emergence of DevOps tools and the rise of Artificial Intelligence open up opportunities to automate many aspects of the code review process. In this article, we explain why you should automate your code reviews (even if you develop solo), what are the limitations of these tools and what comes ahead!

177. 5 Critical Topics Covered at Once: Code Review Practises You Cannot Miss

Why do code reviews? How reviews help improve culture? In this article we’ll summarize the lessons from a dozen of official company engineering blogs.

178. Software Testing Tools: A Complete Guide to Smarter Testing

Struggling to choose a testing tool for your application? Here’s a list of the best Software Testing Tools in 2023, along with perfect scenarios to use them.

179. Use Dynamic Classes to Debug in Python

Oh! If all your code worked as it was supposed to.. Of-course you just made a tiny change and the whole system came crashing down! The existing system seems almost alive, and resists any code change by crashing! Quite often, developers declare a truce in the form of a ‘code-freeze’! After a deep breath (perhaps several weeks..) the code-freeze is lifted, and the battle is renewed.

180. The Step-by-step Guide to Prioritizing Test Cases in End-to-end Testing

In this article, I will demonstrate the testing approach I’ve been using successfully in a project I’ve been working on for the past 8 years.

181. A Beginner’s Guide to Pull Request Stacking

Explore the concept of PR stacking in software development, its benefits, tools to use, and strategies for effective implementation.

182. API Automation: 5 Areas to Focus on

API automation goes beyond testing: here are 5 automation areas to focus on in your API program.

183. Types of Crypto Wallets and How to Choose Best Crypto wallet

For software quality-assurance testers and engineers, acquiring new skills has never been more important. However, according to the O * NET Career Portal, the number of QA jobs is expected to grow modestly over the next decade – if “faster than average” —7%, so this growth will not match the skyrocketing demand for information-security practitioners and software. Developers.

184. Property-Based Testing: The Diamond Kata, First and Last Line Content

Intro

185. What Fixing a Bug Looks Like

It’s impossible to write code without bugs— you always start with something, test it, and repair whatever is wrong.

186. How I Refactored a SPA Project

In this article, I’m not gonna talk about specific code refactoring details but some critical issues of this project.

187. 10 Ways to Prevent and Manage Technical Debt—Tips from Developers

Developers deal with technical debt every day, and they know how to prevent and manage it better than anyone else. Here’s just some of what they had to say.

188. Code Smell 238 – Dealing With Entangled Code

Learn practical solutions to common Python code problems related to readability and scoping.

189. How to Limit the Ever-growing Execution Time of E2E Tests

Maintaining the same E2E coverage will require more and more tests—and their execution time will add up.

190. How to Create A Detailed Description for Your Pull Request

Many developers are familiar with the situation like “where did this code fragment come from and why is it needed?”. You have to spend time and deal with the details already considered by another colleague. How to make it take a less amount of time? To achieve this, pay attention to a process of writing descriptions for Pull Requests (known as “PRs”) and Merge Requests (known as “MRs”). This article will focus on the content of the PR description without any explanation of coding since each project has its own coding-related specifications and requirements.

191. RSpec Testing: Let Vs. Before

In RSpec, there are two different ways to write DRY tests, by using before or let. Their purpose is to create variables that are common across tests. In this post, we will explore differences between before and let and explain why let is preferred by the Ruby community.

192. A-Z Of DevOps: Managing Multiple Environments With The Help Of These Tools

In most DevOps settings you’ll find that there are multiple environments in the pipeline. You might have conditions that change the environment based on which branch was merged or when a branch is tagged for release. There are a number of reasons you want to have more than just a production environment, the biggest reason being testing.

193. Getting the Best Out of Code Reviews

Explore the intricate balance of art and science in code reviews. Dive into techniques for effective feedback, and a collaborative culture.

194. The FAQs of React Native

React Native is a framework created by Facebook that is used for building native apps using React. It is mainly used for developing applications for Android, iOS, and Web. It an open-source framework. So, today we will be checking out the 13 most asked React Native questions.

195. How To Adopt TDD In Your Team

This is the first in a series of blog posts in which we outline the benefits of TDD for your organization and what are the projects to consider while adopting this agile process. Link of Part Two.

196. How To Release Your Software Without Losing Your Hair: Feature Flags Technique

Anyone who has ever released software to customers before I’m sure has suffered from the stress and anxiety it can cause when you’re hoping and praying everything will work just as it did during testing once it’s in production.

197. 5 Ways To Fortify Your Code Against Memory Leaks

Learn 5 practical, no-BS techniques to prevent memory leaks in Java, .NET, and React. Improve performance, reduce crashes, and debug less at 3 a.m.

198. Why To Prefer JSX Over JSON-like Objects For Building React Components

Imagine you have several blocks of similar layout which are hard-coded on the frontend side. These blocks are not dynamic, they are not being fetched from back-end, it’s just a layout. Most beginners, when they see similar blocks of layout, start to think about arrays as a tool to handle similar stuff.

199. Real-time Notifications for Jenkins Jobs with CatLight

Before deep into, I would like to say this will be useful if you are managing multiple Jenkins jobs which you think is a little bit complex 😊

200. Taking A Glance At Software Testing, In Particular E2E Web Apps Testing

In this blog post, we will try to explain software testing from a very simple perspective and look in particular into end to end testing for web applications. We will also explore a very popular tool used in end to end testing for web applications.

201. Do not Troll Your Teammates: 5 Key Rules for Reviewing Code

Code review is an essential step needed for effective software development.

202. How To Format Your CSS Code as a Professional

As a full-stack web developer, I’m building different websites by writing code every single day. Experiencing several situations including solving problems and fixing errors.

203. A Brief Intro to Legacy Code

Let’s talk about legacy code and its refactoring

204. A Video Game, a Fighter Plane, and a Story to Explain Technical Debt – Even to Non-Technical People

Imagine you are a project manager building a historic fighter plane in a video game. A technical debt story about white stripes on a fighter plane.

205. The Importance Of Bug Bounty Programs

A bug bounty program is one of the elements ensuring projects protection against cyberattacks that does not fully substitute other forms of security testing bug

206. The Significance of Using a Standardized QA Procedure

By standardization, we do not expect you to do expensive changes in your complete quality assurance procedure.

207. “Perfect” AI Code Won’t Fix Your Legacy Stack

AI can generate code fast, but it won’t fix legacy systems. The real productivity gains come from maintenance, iteration, and engineering discipline.

208. Open Closed Principle: SOLID as a Rock

This is the second part of a five-part series about SOLID as Rock design principle. The SOLID design principles, when combined together, make it easy for a programmer to craft software that is easy to maintain, reuse & extend. Open-Closed Principle(OCP) is the second principle in this series which I will discuss here with minimalistic example in Modern C++ along with its benefits & generic guideline.

209. How The Modern Web Test Automation Is Changing Our Lives

This article leaves you with the thought of the importance of imagining and implementing solutions to help the test automation world evolve swiftly.

210. Your First Line of Defense for Clean Code is Pre-Commit: How to Set It Up

This article describes pre-commit, a framework for managing and running git hooks to automate code quality checks before code is committed.

211. Code Coverage: I Don’t Think You Know What This Means

Code coverage is a poor metric for indicating whether or not your code has been tested well. Instead, we should invert the metric.

212. How Engineering Leaders Can Prioritize Code Quality

Learn why code quality matters, the most important metrics you need to manage quality, and how to track and manage code quality issues.

213. Measuring Sprint Velocity

We’re going to look at what sprint velocity is, how it can affect your development cycle, and what formulas you can use to measure sprint velocity.

214. Junior Devs, Let’s Talk About Balancing Code Quality and Your Speed of Delivery

Junior developers often find themselves caught in a dilemma between delivering code quickly and ensuring high code quality.

215. Tips About TestNG Listeners In Selenium WebDriver With Examples

There are different interfaces provided by Java that allows you to modify TestNG behaviour. These interfaces are further known as TestNG Listeners in Selenium WebDriver. TestNG Listeners also allows you to customize the tests logs or report according to your project requirements. TestNG Listeners in Selenium WebDriver are modules that listens to certain events and keep track of test execution while performing some action at every stage of test execution.

216. The FAQs of RuboCup

RuboCop is a Ruby static code analyzer and code formatter which helps to track errors easily and fix minor code issues during the development process saving your time. It has many advantages and you can learn more about RuboCop on https://docs.rubocop.org/en/stable/.

217. Code Churn: How it Relates to Refactoring and Technical Debt

Code churn is a measure or indication of how often a file changes. It typically refers to how often a developer throws out code

218. How to Make a Code Review When You Are a Single Developer

An April Fool’s Day jo article about making an “independent” code review by an author of that code using his/her brain’s hemispheres.

219. How to Use Eslint With Webpack And ES6 Modules

Today we are going to talk about eslint and webpack. This is not going to teach you how to install eslint in your project, I will assume that you already did.

220. The Dangers of Using async void Methods In C#

Learn why async void methods in C# can be dangerous with clear code examples. A perfect for beginner software engineers wanting to understand the risks.

221. The Essential Data for Leading a Remote Engineering Team

When your team is building a software product, the majority of the work that they do is invisible. As a manager, you have to rely on in-person cues for blocked work or frustrated engineers. When they move to a remote workflow—your team also becomes invisible, and all those critical signals are dropped.

In-person, you might notice:

222. Top 7 Project Management Instruments That Facilitate Remote Work

Project Management for a team is an important task at the best of times. Many processes make a project successful- scheduling, planning, executing, and other stages. However, project management can get trickier when your team is distributed across the world and working remotely.

223. So, You Read Accelerate. Now What?

“Our analysis is clear: in today’s fast-moving and competitive world, the best thing you can do for your products, your company, and your people is institute a culture of experimentation and learning, and invest in the technical and management capabilities that enable it.” – Nicole Forsgren, Jez Humble, and Gene Kim, Accelerate.

224. How To Determine A Good Application Architecture

When I started writing a small but real growing project, I noticed that the app shouldn’t only work well but also should be well organized.

225. The Meaning, Purpose and Benefits of Code Refactoring

In the article, we cover the topic of code refactoring and discuss the value of the process.

226. The Ultimate Guide To Hassle Free Bugs Fixing In Premium Python Projects By SonarCloud

As developers, there always comes a time when we find a bug in production and wonder how it passed all our quality checks. The truth is that we can never be sure our code is bug free. We can only choose the tools and workflows which will find the most bugs without slowing us down too much.

227. How to Set Up a Team’s Systems and Culture for Strong Code Reviews

All software companies must take an intentional and structured approach to code reviews. Here are some tips on how to do that.

228. Maintain The Quality of Your Node.js Apps With These Best Practices

Node.js is an open-source, cross-platform, Javascript runtime environment for running javascript code outside the web browser.

229. Selenium Testing: Running First Pytest Script

Selenium as we know, is an open-source test suite used for cross-platform browser automation. Due to its popularity and ease of use, many compatible test frameworks with respect to different programming languages have been developed to extends support of Selenium for cross browser testing over multiple programming languages. Today we’re going to look into Selenium Python tutorial to run our first automation script using PyUnit framework with Selenium.

230. Master GeoSpatial Data: From Python’s .apply() to Advanced Alternatives

Discover the fastest ways to perform row-wise operations in Pandas. This benchmark study compares apply(), iterrows(), itertuples(), vectorization, and more.

231. Securing Real-World Microservices With gRPC And Istio Service Mesh

232. How To Use Filter Pattern With Generic Lambda Expression

The filter and pipeline patterns can be optimized with code reduction using lambda expression(shortcuts for anonymous method) as concrete filter condition. To demonstrate concept, the sample WPF UI application was created. Here is Source code

233. Clean Architecture; How To Keep Your Codebase Scalable Without Overengineering

Clean Architecture made practical. Stop drawing circles and see how to apply the layers in a real mobile projects, explained by a dev for devs.

234. Git Reflog: Your Local Time Machine

Sometimes, we make do some unintentionally merge or rebase which we wish we could recover to the previous stage. But there is no commit for you to get back. That moment, you probably feel like the git log – time machine which you admire become not really helpful. But you should know that “git log” is not the only way to trace the history. There is another kind of git history which been keep tracked in your local and your local only, which is so-call reflog. This reflog stores the whole shebang of you local activities and you can undo almost everything with it.

235. What is Data Collection and What are The Most Important Events to Track

When your company is client-oriented, one of your priority tasks is understanding your clients’ problems and gathering insights on how people use your product and when exactly they benefit from it.

236. How To Make A Record of Selenium Test

Selenium is a open-source free and automation testing tool for web applications across all different browsers. It is quite similar as HP QuickTest Pro (QTP, currently UFT). However, Selenium mainly focused on automating web-based applications. So the testing done using Selenium tool is referred as Selenium Testing.

In order to record a test, follow the given steps:
Step 1 : Open Mozilla Firefox web browser, go to tools and click on Selenium IDE. There type the link

237. The Engineer’s Guide to Creating a Technical Debt Proposal

This article will guide you through the process to craft a technical debt proposal to justify the time spent solving technical issues.

238. Everything I Learned as a Software Developer While Creating my Product

Before creating the code, it is crucial to prioritize its quality. It should be the foremost consideration in the development process.

239. Demystifying Manual Testing: Skills, Process and Career Prospects

Learn how manual testing fits into the software development process, the essential skills required, and the ways it contributes to ensuring software quality.

240. Are Your CICD and DevOps Tools Really Helping Developers?

If you are responsible for your team’s CICD and DevOps tools, have you ever asked yourself if the tools you built are really making developers’ lives easier?

241. Elevating Software Quality: A Guide to Effective Code Reviews

Explore advanced code review techniques to boost software quality, featuring AI, gamification, and industry case studies.

242. Computer Vision Is Fun To Play With

I work as a Software Engineer at Endtest.

243. Code Refactoring Tips: No. 015 – Remove NULL

Eliminating The Billion-Dollar Mistake forever – Discover how the Null Object Pattern can streamline your code by eliminating the need for null checks.

244. Code Reviews: Tips On Getting More Feedback

Nobody leaving comments on your code reviews? Try out these 3 tips on getting eye balls on your pull requests

245. Software Intelligence: How to Take Quality Control in 6 Practical Steps

Lead Photo by Max Duzij on Unsplash

246. Comments Rarely Improve Your Code

The debate over comments in code is ongoing. At least once per year for the last 30 years, I’ve been involved in a discussion on the subject – often accidentally and reluctantly. To be honest, my perspective has changed over time. I used to comment every method, I used to comment any line of code that was “weird”, and I used to comment any blocks of code that were too complicated. Today, I rarely comment, if ever. Over time, I’ve come to realize that most comments are unnecessary.

247. 13 Tips on Writing Powerful Test Cases That You Need to Know

Test cases are software development safety net unless they are poorly written. Here are my 13 tips on writing powerful and trustworthy test cases.

248. Custom Logic in Webflow: How to Push No-Code to Its Limits

Discover how to extend Webflow’s no-code capabilities with custom logic, low-code integrations, and performance-first architecture.

249. How ML Challenges Software Engineering

Inherent uncertainty, data-driven behavior, rapid experimentation: characteristics of Machine Learning that disrupt traditional software engineering practices.

250. Selenium Exceptions as the Way to Get More Robust Testing Scripts: the Truth

Exceptions in Selenium are unavoidable. Here are 49 most common Selenium exceptions which might occur while performing Selenium Test Automation.

251. Beginner Python Projects: How to Build an Acronym Generator

An Acronym Generator will take a String as an input and it will return the initials of all the words in the String.

252. How To Evaluate Software Code Quality And Why It Is Important

Software Engineers are in great demand nowadays. Their unique skill sets make them different from the other available professions.

253. ASP.NET FAQs

ASP.NET is an open-source server-side web application framework that was developed by Microsoft. It is mostly used for building dynamic websites and applications. It is free and a cross-platform framework. So, today we will be checking out the 11 most asked ASP.NET questions.

254. Introduction to Mocha Testing Framework

Mocha is a feature-rich JavaScript test framework running on Node.js and in the browser.

255. Git Basics

To playing with git you have to do the following things step by step

256. How to Build an Impressive Demo Project

Discover essential tips for creating an impactful demo project that effectively showcases your coding skills to potential employers.

257. Go 1.21: Taking Your Go Apps to the Next Level

Discover Go 1.21’s cutting-edge features: profile-guided optimization, min-max functions, clear function, loop variable enhancement, and more.

258. Boost Mobile Performance To Better UX

What’s one of the biggest predictors of mobile app success? Performance. Here’s how to whip yours into shape so mobile app performance problems don’t cost you downloads, revenue, and brand perception.

259. Bad Codebases Shoo Developers Away

In this software engineering survey, we learn about the state of technical debt and technical hiring.

260. Creating A Killer README File: Ultimate Guide

After code comments, the README file is one of the most ubiquitous forms of documentation found in software development today.

261. Methodology of Test Case Minimization Using Firefly Algorithm

How to use Firefly Algorithm & UML state chart diagrams to minimize test cases, reduce cost & time, keep high coverage & fault detection in software testing.

262. An Introductory Guide to Screenshot, UI, API, and Performance Testing

Building a product, we face the moment that we need more types of tests. Screenshot, UI, API, or Performance? There are many of them and every one is designed for other purposes.

263. The Basics of a Standard Type Inference Technique

Type inference is a common feature among mainstream programming languages. The functional ones, like ML and Haskell, are pioneers in exploring this programming paradigm where the declaration of a variable or a function may omit a type annotation. Today, even classic imperative languages such as C++ offer, to a certain extent, a kind of type inference.

264. How To Use Ballerina in Azure Functions

Ballerina since v1.2.5 has built-in support for Azure Functions. In this way, you can take a Ballerina function and expose it as a serverless function in Azure Functions. Azure Functions take on a unique approach in defining serverless functions with the function trigger and bindings concept. In this way, we can access other cloud services such as storage services (queue, blob, etc.), CosmosDB, Twillio, and timers right from the function itself without any additional connectors or authentication processes. We map our parameters and return types with these bindings, which provides us direct access to the resources.

265. How to Write Tests for React – Part 2 [Beginner’s Guide]

Writing React Test with React recommend libraries – Jest & Testing Library for React Intermediate users.

266. Software Engineers use Code Reviews to Improve Product Quality

Software engineers need to do code reviews in order to improve overall product quality and learn from each other. Code review process has a set of best practices like any other complex processes. Check best practices below. Do you follow them on your current project?

267. Automation Testing Versus Manual Testing Guidelines

Software development goes through six main stages, otherwise known as the software development lifecycle. They are planning, design, development, testing, deployment, and maintenance. After development, the next phase involving quality assurance and testing is crucial to the success of the software. Proper QA testing identifies redundancies, inconsistencies, bugs, and defects in a newly developed product. Without this process, there’s no way to find out the ability of the product to survive in the real world and to work as intended for many years.

268. Codeless Test Automation is Beneficial, but Not a Complete Replacement for All Testing

If you’re a marketer, product manager, or QA specialist without deep programming skills, you’ve probably thought of an easier way to test a website.

269. Code Smell 265 – Linguistic Confusion

Overcomplicating naming conventions in code can lead to confusion, bugs, and frustration. Here’s how to make your code easier to read and maintain.

270. Elevate Your Code Quality with Effective Unit Testing

Dive into a comprehensive guide on unit testing that emphasizes aligning tests with user interactions, maintaining semantic structure, and optimizing component.

271. A Guide to Examining & Modifying Executable Code

A review of tools and techniques to examine and modify executable.

272. Pair Programming and Code Reviews Can Work, Sometimes.

In the post pandemic screen-sharing workspace, is it time for pair programming to get another shot?

273. Why Open-Source Products Are More Popular Than Kim Kardashian

Developing and releasing open-source solutions is a common practice that has been adopted by companies like Red Hat, Facebook, Google, and Amazon. IT companies that make products available as open-source software have become a sensation in the investment environment. Confluent, Neo4j, HashiCorp, and GitLab are just a few examples of companies that have managed to attract large investments.

274. 3 Things Coding And Prose Writing Have In Common According To Cory House

Does your code read like a book?

275. Code and the Art of Motorcycle Maintenance: Typical Rookie Faults

With coding, just like with riding, you need to be responsible and conscious to stay in the saddle and double that to be a winner.

276. Using Galen Framework For Automated Cross Browser Layout Testing

Galen Framework is a test automation framework which was originally introduced to perform cross browser layout testing of a web application in a browser. Nowadays, it has become a fully functional testing framework with rich reporting and test management system. This framework supports both Java and Javascript.

277. Why Project Maintenance Should Not Be Done By A Separated Team

Suppose you have to add a new major feature to an app.

278. Removing Bugs in Git

When you are working on a huge project, you may discover bugs in the code that prevent you from proceeding any further in your development. How to fix them?

279. Components Genesis: Mastering the Top-Down Code Design Approach

Learn how to write reliable and professional-looking React code using “Wishful Programming” aka “Top-Down Code Design”. Great for coders of all levels.

280. 9 Tips To Make Regression Testing More Effective

With the surging rise in the number of mobile app users in the entire world, it’s a high time that brands should focus on delivering seamless functioning of mobile apps. Hence mobile app testing is one of the ways to achieve this goal. This shows the importance of including regression testing in your mobile application development lifecycle.

281. The Lack of Internal State and How it Makes Your Classes Easier to Test and Refactor

You likely often hear that test-driven development (TDD) or just writing tests can make your code better.

282. Refactoring 029 – How to Replace NULL With Collection

Replace nullable optional attributes with empty collections to eliminate null checks and leverage polymorphism.

283. Dependency Injection with Symfony: Streamlining Code Management for Efficiency

Explore the capabilities of Symfony Dependency Injection and enhance your application’s scalability with this insightful article.

284. A Power-Packed Light Reading on Data Structures

when we talk about data structure and algorithm it’s very important to know the concepts like Big O Notation and Time Complexity
these concepts help us to choose the right data structure and to know
them very vital these are metrics which we use to choose the right data
structure.and things like how memory ,linked list and array works,they
help us to have better understanding of the speed and performance of a
data structure.

285. Code Reviews That Truly Elevate Frontend Quality

Most frontend reviews sign off clean code. But your users don’t see the code, they see the bugs you missed.

286. How to Use JUnit Annotations In Selenium

JUnit is a Java-based, open-source framework to help you execute unit testing. JUnit is used primarily to test each and every unit or component of your application like classes and methods. It helps to write and run repeatable automated tests, to ensure your code runs as intended. The framework offers support to Selenium test automation for web-apps or websites.

287. Exploring Differences Between Promises And Callbacks in JavaScript

You might have heard what a Promise is or what Callback functions are in JavaScript. Clarity is needed when distinguishing between these two functions more so, when working with APIs in JavaScript-based applications.

288. Legacy Code Deserves More Respect Than We Give It

A reflection on old code, missing context, and why understanding past decisions matters more than quick judgment in software development.

289. Code Quality Guardians: The Power of Continuous Integration in Software Development

Why continuous integration? Because it defends your code base.

290. How App Statistics Helped Resolve a Bug in My Mobile App

“Users cannot open the app.“ This was the message causing chaos all over. So I did a quick installation of the app again, and to my surprise, the app was workin

291. 5 Steps You Should Take To Launch A Cool Game

The key steps of the game development process, how each of them functions, and what roles and operations they consist of.

292. Why Using Static Analysis Is Hard

Using static analysis is hard, counter-intuitive and not-automatic. We want to answer some questions related to the use of static analyzers: why this is hard for some users and what are the solutions to help.

293. Introduction To Property-Based Testing in C#

Intro

294. DevOps Shouldn’t be Hard: Deployment Reports

Previously, we managed to make our app redeploy on each commit. As you can remember, we get the status of deployment by processing script execution results. So let’s use it to send a notification to ourselves each time we deploy our code.

295. Tips, Tools, and Best Practices for Optimizing Unit Testing in JavaScript

Learn how to improve the performance of your JavaScript unit tests with this comprehensive guide.

296. 6 Surefire Ways To Suck At Maintaining Projects

Do you want to ensure that working with your repo is a constant source of frustration for your fellow developers? Read on for some awful tips.

297. How To Setup An Effective Refactoring Process of a Heavy Database Interface

This story is about pain, agony, and denial of ready-made solutions. It is also about changes that improve the code’s readability and help the development team stay happy. The object of this post is an interface that helps a program communicate with a database.

298. Adding Source Attribution to Question Answering Systems

Without source attribution, even the most accurate system risks losing user trust.

299. Scaling Web Applications Is Like Walking a Tight Rope in a Storm

Scaling web applications is a skill. It’s like walking a tight rope, in the midst of a storm. There are multiple factors acting on you,

300. How To Manage Multiple IT Projects Like An Expert Using Code Review Tools

Whether you are struggling to organize multiple projects or ensuring that your team’s workload is manageable, there are a few strategies that you can use.

301. How to Avoid Code Smells – A NDepend Tutorial

.NET developers can evaluate and visualize the codebase using the robust static analysis tool NDepend. It aids programmers in understanding the quality and main

302. Bad Software? No Big Deal

Inevitably, we’ll someday come across legacy software, inconsistent databases, or integration modules that simply don’t work. It might sound wise to fix this software, especially if they’re crucial to the business. The problem that refactoring costs development and validation time, and the business does not always have this time to invest, but at the same time needs the fix. How can we both deliver the business requirements in time and still not break everything?

303. Why SaaS Companies Require Security Testing?

SaaS companies offer a lot of flexibility when it comes to providing essential software solutions to their customers. They have an added advantage of being easily accessible and that too on all kinds of devices. As a result, the modern age businesses are rapidly switching to these solutions provided by SaaS vendors.

304. Code Smell 264 – Hanlon’s Razor

Overthinking and overdesigning your code can lead to unnecessary complexity. Learn how.

305. To Err is Human, to Test is Divine

We are humans, we forget, we make mistakes, we change things, ideas; This happens when we work solo, imagine when you are in a team!

306. The Meticulous Coding Strategy Applied to Metabase Issue #14782

This short article describes the application of the meticulous approach to coding to a real-life problem.

307. Code Smell 240 – Dead Store Code

Learn how to detect and address dead store code smells with expert tips.

308. Code Smell 03: Functions Are Too Long – Here’s How to Fix That

Refactor and extract functions longer than 5 lines. Here’s how.

309. Pro Tips For Crowdsourced Penetration Testing

Bug bounties, crowd-sourced penetration tests are increasingly becoming popular. See the top six tips for participating in a bug bounty program.

310. How-to: Website Benchmarks

Time to first byte, first contentful paint, DNS response time, round-trip time, and the list goes on and on. With all of these metrics, how are you supposed to know which are the most important ones that you should monitor?

311. Software Engineering Best Practices + The Best Resources to Save🚀

The reality is, tech moves fast, and it’s easy to get distracted by the latest software, tool, or trend.

312. How to Find the Stinky Parts of Your Code [Part XLII]

Your code smells because there are likely many instances where it could be edited or improved.

313. Clean Code and Speed: Not Either/Or

Refuting claims that clean code hurts performance, this article shows how proper design delivers speed without sacrificing maintainability.

314. How to Start with Autotests

This article is about the approach one could take to ensure the autotests initiative is not rejected.

315. 6 Examples to Differentiate Desirable Technical Debts From Undesirable Ones

Technical Debts have been in the center of software engineers debate for quite some time. Not only its analogy to financial terms has been discussed, but also the different contexts and aspects a debt contains.

316. DevOps Tools That Will Help in Rectifying Errors in the Databases

It is known that the separation between software development teams as well as information technology operations teams that faced many problems in it.  After witnessing this problem, the web-developers came with the idea of developing DevOps which is considered to carry roots in the Agile methodology. The basic function of DevOps is to integrate the set of two teams to improve their collaboration and productivity.

317. Code Smell 275 – Missing Test Wrong Path

This article highlights the critical need for fail conditions in tests expecting exceptions.

318. It is Time To Have A Quality Control For WordPress plugins

When a post on Facebook, on Christmas Eve, about the poor quality of WordPress plug-ins gets hundreds of replies within a few hours you know you are not alone.

319. DevOps Shouldn’t be Hard: Configurating CD Server

I wanted to write this guide for a while because DevOps is one of the things that is not discussed much yet there are a few straightforward actions that you can integrate into your workflow that will make your developer life much easier.

320. Programming Paradigms: All the Things We’ve Learned Not To Do

Programming paradigms don’t give freedom—they take it away. Here’s why Structured, OOP, and Functional might be the last paradigms we ever get.

321. Navigating the Maze of Technical Documentation: Best Practices for Keeping Your Code Up-To-Date

How to manage technical documentation effectively, avoid common pitfalls, and ensure that your knowledge base stays accurate and up-to-date in software developm

322. How is a Code Formatter Implemented in Turtle Graphics

323. Dev Diary #2: Run Away from Nesting Functions in Your Code

Discover how the Orchestrator/Actions Pattern can simplify your codebase, making it easier to navigate, test, and maintain.

324. How to Spot a Good Tester: Interview With Alexander Van Der Berg

Today’s guest is Alexander van der Berg, an experienced software tester who can shed some light on this part of the industry.

325. Unlock the Secrets of Range Loops: How Element Evaluation Affects Your Go Code

Discover how Go’s range loops work, common pitfalls to avoid, and tips for writing efficient, bug-free code. Elevate your Go programming skills today!

326. Finding the Stinky Parts of Your Code: Code Smell 256 – Mutable Getters

Avoid mutable getters to protect your code’s integrity and encapsulation. Learn how to return immutable copies in Java for safer and more predictable coding

327. Code Smell 310 – Why Generic Date Names Break Your Code

Use descriptive date names that reveal their role and business purpose instead of generic “date” labels.

328. Mastering CI/CD: A Simplified Guide for Entry and Mid-Level Full-Stack Developers

Learn to build, test, and deploy applications seamlessly, ensuring code integrity and efficiency.

329. The Mighty App Developer vs a Pesky Bug

A year ago, I, the almighty mobile application developer, was brought down by a pesky bug that was causing my precious creation to crash frequently for users.

330. How To Test A Controller in Ruby On Rails

In this section, I am going to write test code. Here we”ll discuss a little bit philosophy of testing but more writing tests.

331. How to Build an MVC App On Rails

MVC In Ruby On Rails.

332. Assure Superb Quality of Ruby On Rails App Through Code Auditing

This article is all about code auditing and how it helps in refining application code. It also explains the different types of code reviews and how they are use

333. Code Smell 241 – Referential Transparency Violation

Learn how to write pure functions to enhance code readability, maintainability, and testability.

334. Simplified Spinnaker is Possible: I Never Thought About it

Getting Spinnaker running is not an easy feat. Armory’s Minnaker open source application gets you started in 10 minutes, so you can focus on Armory’s value.

335. Continuous Deployment on Steroids

Discover the power of Aptible in redefining continuous deployment. Explore best practices and tips for successful CD processes

336. The Long-Term Benefits of Unit Testing (With Jasmine Examples)

learn how unit testing enhances code quality and accelerates development.

337. How to Find the Stinky Parts of Your Code [Part XLV]

Your code smells because there are likely many instances where it could be edited or improved. Most of these smells are just hints something might be wrong.

338. Top 7 Techniques For The Ideal Secure Code Review

Considering today’s cyber threat landscape, it is undeniable to say that the internet-facing applications are at major risk due to rapid increase in vulnerability exploits and ways to penetrate applications leveraging the hidden weaknesses in them.

339. Instance Comparison Chart: Find The Right AWS EC2 Instance

So you’ve decided to choose AWS as the primary provider of your cloud service and now you’re looking into setting up your environment. You’ve got your project to be deployed and all you have left to do is choose an AWS instance that will run your machine image. But now, like many others before you, you are stumped by the countless choices of EC2 instances out there.

340. The Nascent Concept of Software Recycling

I want to put forward the idea of software recycle. Software recycle is software reuse taken to a new level.

341. Simple Yet Effective Advice To Handle Large Releases with DevOps Effortlessly

When you start working on large scale enterprise systems, handling releases can become complex. You’ll have to think about your front-end, microservices, third-party services, and other services. Making sure these things get deployed in the right order and pass integration tests can be tricky once you start working with asynchronous tasks.

342. Top 10 C++ Open Source Project Bugs Found in 2019

Another year is drawing to an end, and it’s a perfect time to make yourself a cup of coffee and reread the reviews of bugs collected across open-source projects over this year. This would take quite a while, of course, so we prepared this article to make it easier for you. Today we’ll be recalling the most interesting dark spots that we came across in open-source C/C++ projects in 2019.

343. You Probably Underestimate Control Variables

Contexts should always be clearly stated when drawing the conclusions, to ensure that those conclusions won’t be applied to situations where those conclusions

344. Navigate Debugging Challenges with These Proven Techniques

345. How To Outsource Software Testing For CTOs

Determining if outsourcing is best for your needs and how to find the right provider in a sea of options

346. Why You Must Start Refactoring Your Codebase Today

What is refactoring? Why do we go through the trouble of improving code that works?

347. What Mobile Gaming Industry Leaders Think About Testing Challenges

Wonder how the leading mobile games companies test their apps’ functionality and performance? Here are some of their insights!

348. How To Find the Stinky Parts of Your Code: Code Smell 248 – Unreliable Copy

Discover the importance of verifying file copies to prevent silent modifications and uphold software principles like the Least Surprise and Fail Fast principles

349. Building a Divider App: How Many Cases Can Share One Operation?

Thinking about all the things that could go wrong in code execution and preparing for them is a big part of a programmer’s job.

350. What Tools You Must Use to Measure Your Product Performance

Performance testing is a very crucial part of quality control for many applications. If an application is supposed to support multiple connections and/or numerous calls to a server, then it’s very important to be sure that it can handle the load. What’s good about an app that processes user’s requests at a snail pace?

351. The Git Log Never Lies

A hackathon judge shares the forensic signals – git logs, package manifests, ghost dependencies, fake tests – that reveal more about a project than any demo.

352. How to Test Pull Requests Intelligently with a Merge Queue

Learn how to streamline your pull request (PR) testing process with the merge queue strategy.

353. Refactor Or Not To Refactor?

It probably doesn’t have an universal answer other than using case-by-case judgments

354. How To Block Security Vulnerabilities from Penetrating Your Code

As continuous software deployments grow and become the accepted standard, security measures gain even more importance. From development and all the way through to production, security requirements should be adopted by all teams in an organization.

355. Writing and Selling Unit Tests: When You Need Them and When You Don’t

Unit tests help ensure your code works better and prevents bugs. However, that explanation sounds too abstract and impractical for real-world scenarios.

356. How to Backup Your Microsoft Azure Storage Accounts

Azure Storage Account is one of the foundation services of Azure. Pretty much all other services use it under the cover in a way or another. This service is simple, works great, and has crazy SLA and redundancy capabilities. However, it doesn’t provide a point in time restore. Meaning that if you corrupt or delete some data, there’s no way to recover it. There are some solutions that you can find over the internet, but unfortunately, none of them is a silver bullet. Let’s explore and compare some of them.

357. Combatting Overengineering: Don’t Be Afraid To Throw Away Your Code

There are two lessons here: 1) Think before you code – this one I regularly forget. 2) Don’t be afraid to throw away your code.

358. Fine-tune Your Product In No Time

Being experts in the IT industry, we at QAWERK know about the importance of testing and want to share this knowledge as we believe high-quality software is the key to success.

359. Making Friends with RuboCop: Ruby Static Code Analyzer

At Memory.ai, we started using RuboCop heavily. This is a story of how we integrated RuboCop into our existing app.

360. How to Find the Stinky Parts of Your Code [Part XLI]

Your code smells because there are likely many instances where it could be edited or improved.

361. How Gusto Makes Bug Fixing Enjoyable With Bugsnag

By enabling developers to more easily identify and address errors, Gusto can quickly iterate and improve their software’s performance.

362. Writing Clean Code: Practical Tricks for PHP

Writing clean code isn’t hard, but sometimes getting a piece of code to work right can get in the way of making it maintainable.

363. Hack Your Technical Debt: The 1% Better Every Day Challenge

It’s easy for technical debt to grow in our codebase. Commit to spending 20 minutes a day for 30 days to tackling technical debt and get 1% better every day.

Thank you for checking out the 363 most read blog posts about Code Quality on HackerNoon.

Visit the /Learn Repo to find the most read blog posts about any technology.