274 Stories To Learn About Code Qualityby@learn
347 reads
347 reads

274 Stories To Learn About Code Quality

by Learn RepoApril 16th, 2023
Read on Terminal Reader
tldt arrow

Too Long; Didn't Read

Learn everything you need to know about Code Quality via these 274 free HackerNoon stories.
featured image - 274 Stories To Learn About Code Quality
Learn Repo HackerNoon profile picture

Let's learn about Code Quality via these 274 free stories. They are ordered by most time reading created on HackerNoon. Visit the /Learn Repo to find the most read stories about any technology.

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

1. 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?

2. 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.

3. 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.

4. 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.

5. 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.

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 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.

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

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

9. 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.

10. 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.

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

Troubleshooting with source maps uploading to Sentry with Next.js

12. 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.

13. 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.

14. 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.

15. 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.

16. Is Dry Code Still Relevant Today?

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

Hola people!!! 🥑

18. Analyzing Your Code With SonarQube Running via Docker Image

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

19. 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.

20. Why You Must Start Refactoring Your Codebase Today

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

21. 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,

22. 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.

23. The Engineer's Complete Guide to Backlog Grooming📝

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

24. Fundamental Concepts of Angular

Fundamental Concepts of Angular for beginners to advanced level developers.

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

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

26. 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.

27. Introduction To Property-Based Testing in C#


28. 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.

29. 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.

30. 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.

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

Does your code read like a book?

32. 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.

33. Less Dirty Code

Clean Code is a Lie and Nobody Writes it.

34. 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.

35. Bad Codebases Shoo Developers Away

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

36. 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.

37. 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.

38. 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.

39. 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.

40. 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.

41. How to Start with Autotests

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

42. How To Set Up a tsconfig For Nodejs

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

43. 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.

44. 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.

45. 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.

46. 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.

47. 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.

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

49. 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

50. 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.

51. 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.

52. 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!

53. 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.

54. 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.

55. 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.

56. Replace Comments With Better Code

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

57. 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.

58. 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.

59. How to Configure Rubocop in Code Base

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

60. How to Build an MVC App On Rails

MVC In Ruby On Rails.

61. Why is This So Hard?

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

62. API Automation: 5 Areas to Focus on

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

63. 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.

64. The Myths and Realities of Bug-Free Code

65. How to tell if your code actually sucks...

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

66. 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.

67. 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?

68. A Brief Intro to Legacy Code

Let's talk about legacy code and its refactoring

69. 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 😊

70. 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.

71. 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.

72. 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.

73. 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.

74. 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?

75. How is a Code Formatter Implemented in Turtle Graphics

76. 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.

77. 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

78. 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!

79. 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.

80. 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.

81. 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.

82. 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.

83. 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.

84. 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.

85. 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.

86. Mobile App Debugging: Localizing Defects and Making Bug Reports

Mobile app debugging requires the creation of bug reporting. In this article, I'll describe how to localize mobile app defects and create mobile app bug reports

87. 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.

88. 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.

89. GO Design Patterns: An Introduction to Builder

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

90. 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

91. 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.

92. 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.

93. Keeping Your Code in Monorepo -Pros and Cons

94. 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.

95. 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.

96. Laravel Real-Time Monitoring Using Inspector

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

97. 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.

98. 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.

99. 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

100. 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,

101. 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.

102. 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.

103. 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.

104. 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

105. 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 :)

106. 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.

107. Computer Vision Is Fun To Play With

I work as a Software Engineer at Endtest.

108. Using Black To Auto Format Your Python

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

109. 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.

110. 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.

111. 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.

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

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. 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.

115. 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.

116. 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.

117. 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.

118. 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.

119. 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.

120. 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?

121. 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.

122. 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.

123. 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

124. 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?

125. 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.

126. 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.

127. 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.

128. 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.

129. 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.

130. 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.

131. 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.

132. How ML Challenges Software Engineering

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

133. 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.

134. 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.

135. 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.

136. 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.

137. 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

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

Originally published at Managing Technical Debt.

139. A Guide to Examining & Modifying Executable Code

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

140. How to Build Awesome Integration Tests with Capybara

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

141. 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.

142. 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

143. 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

144. 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.

145. 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.

146. 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.

147. 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.

148. 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.

149. 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!

150. 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.

151. 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.

152. 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?

153. 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.

154. 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.

155. 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.

156. 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

157. Introduction to Mocha Testing Framework

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

158. 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?

159. 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.

160. 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.

161. 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.

162. 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?

163. 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.

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

165. 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)

166. 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.

167. 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.

168. Making Friends with RuboCop: Ruby Static Code Analyzer

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

169. 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.

170. 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.

171. Exception Handling with Examples

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

172. 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.

173. 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.

174. 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.

175. Refactor Or Not To Refactor?

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

176. 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.

177. 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.

178. 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.

179. 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

180. 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.

181. 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

182. 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.

183. 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.

184. 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.

185. Asynchronous Programming Techniques with Kotlin

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

186. 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.

187. 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>.

188. 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.


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.

190. 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.

191. 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.

192. 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.

193. 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.

194. 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.

195. 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.

196. 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.

197. Better Application Acceptance With LogRocket

Application Acceptance

198. 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.

199. 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.

200. 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

201. 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.

202. 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.

203. 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.

204. 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”

205. 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".

206. 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.

207. 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.

208. 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).

209. 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.

210. 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.

211. 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

212. 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.

213. 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.

214. 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.

215. 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.

216. 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…

217. 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.

218. 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.

219. 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.

220. 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.

221. 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?

222. 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.

223. 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.

224. 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.

225. 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.

226. 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.

227. 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.

228. 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.

229. 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.

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


231. 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.

232. 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.

233. 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.

234. 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.

235. A Comprehensive Guide for Handling Errors in Rust

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

236. 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.

237. 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.

238. 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.

239. Git Basics

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

240. 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.

241. 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.

242. 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.

243. 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

244. 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.

245. Understanding JavaScript Generators And Basic Use-Cases

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

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

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

247. Approaching Unit Testing in iOS Correctly

Why does my application get so buggy after each release?

248. Move Business Logic out of Application Using Hyperon 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?

249. 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".

250. 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.

251. 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.

252. 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.

253. 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.

254. 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.

255. 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.

256. 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:

257. 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

258. 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.

259. 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.

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

Lead Photo by Max Duzij on Unsplash

261. 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.

262. 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.

263. 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.

264. 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?

265. 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

266. 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

267. 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.

268. 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.

269. 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.

270. 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.

271. 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.

272. Object-Oriented Design: Refactoring a REST Connector

In this story we will try to see how to improve a simple REST connector that places a request on an external service through an HTTP POST call and returns the result back from the remote server. The full example can be found here. Following is the source code for our connector (Connector1):

273. 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.

274. 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.

Thank you for checking out the 274 most read stories about Code Quality on HackerNoon.

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