paint-brush
110 Stories To Learn About Refactoringby@learn
222 reads

110 Stories To Learn About Refactoring

by Learn RepoJune 2nd, 2023
Read on Terminal Reader
tldt arrow

Too Long; Didn't Read

Learn everything you need to know about Refactoring via these 110 free HackerNoon stories.

People Mentioned

Mention Thumbnail
Mention Thumbnail
featured image - 110 Stories To Learn About Refactoring
Learn Repo HackerNoon profile picture

Let's learn about Refactoring via these 110 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.

1. An Essential Guide to Legacy Code

In this guide, you'll learn what is legacy code, its characteristics, tools, and the best practices for working effectively with legacy code and technical debt.

2. 7 VS Code Extensions for Frontend Developers

As a developer, you’re always looking for cutting-edge tools, tricks, and extensions. Here are 7 tools that'll improve your productivity and efficiency.

3. Differences Between Includes and Joins in Ruby on Rails

Many of us know about includes, joins but sometimes we confuse about their usage. As I was experimenting with code refactoring in one of my projects, there I have tried these things. So I thought I can share these findings with you guys.

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

5. 5 VERY common code smells and how to fix them

5 easy wins to refactor even the worst legacy code

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

7. Front End Refactored — Components with Vue

The more I learn about coding, the more inspired I get about how creative and revolutionary some of these ideas are. From the readability of Ruby, to a world of hashes in Javascript, these ideas keep renewing the way we think and evolve the tech world all the time.

8. 5 Best VS Code Extensions for Refactoring that Every Dev Should Know

If you’re looking at ways to clean up our code, reduce complexity and improve functionality - these refactoring extensions will help you move faster.

9. 5 Best VS Code Extensions to Help Organise Your Code in 2021

Use these 6 VS Code extensions that help devs get organised and work effectively.

10. Dealing with a Large Undocumented Codebase

I was recently asked to answer the somewhat vague question, “How do you interact with a large undocumented code base?”

11. Using JSON Mapping to Work with APIs of Various Image Services

Using JSON Mapping to Work with APIs of Various Image Services. This approach is applicable to any other services that are similar in type of returned results.

12. I Wrote More than 90 Articles in 2021 and Here is What I Learned in a Nutshell

This article summarizes my experience as a writer during the pandemic year 2021

13. Get Rid Of Technical Debt In 10 VS Code Extensions

Many engineering teams get stuck and cannot ship quality software fast because of technical debt. The best engineering teams I've talked to use the right tools.

14. Y2K22: The Problem that Caused Millions of Emails Worldwide to go Undelivered

The Y2K22 Bug is the consequence o very bad software design

15. How to Find the Stinky Parts of Your Code [Part XVI]

The most beautiful code, the most beautiful functions, and the most beautiful programs are sometimes not there at all.

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

17. "Declarative Programming Languages are the Future," Maximiliano Contieri

Maximiliano Contieri from Germany has been nominated for a 2020 Noonie in the Software Development Awards Category for Hacker Noon Contributor of the Year - REFACTORING.

18. Kill Technical Debt Before it Kills Your Project

19. How to Find the Stinky Parts of Your Code [Part XVII]

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

20. Why Aren't You Using Aliases in Webpack Config?

Are you Developer doing FrontEnd? Are you using Webpack?

21. A Brief Intro to Legacy Code

Let's talk about legacy code and its refactoring

22. DeepMind's AlphaCode Won't Steal Your Job Either

Another new fancy AI tool. We keep getting closer to the singularity. But not on programming.

23. Why You Must Start Refactoring Your Codebase Today

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

24. Refactoring: Remove Setters #CodeSmell

Warning: Setters Considered Smelly

25. Is Technical Debt Actually Bad Debt?

Release early, release often — just don’t forget to refactor ;)

26. A Refactoring Guide for Ruby on Rails

“Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live” — John F. Woods

27. How to Find the Stinky Parts of Your Code [Part XXXII]

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

28. Simplify Node.js Route Handlers With Middleware A How-To Guide

I recently came across a route handler that was 2k LOK (lines of code). This possibly happened due to lack of rules and guidelines in place. I tried to understand the control flow, but 3 mouse scrolls down I was forgetting where I have started and what it's all about. Just a hint (not actual project code):

29. TDD Conference 2021: Opening Ceremony by Alex Bunardzic

Alex is a software engineering veteran with over 30 years of hands-on professional experience. He is a staunch advocate of Extreme Programming and TDD.

30. How to Find The Stinky Parts of Your Code [Part XIII]

We see several symptoms and situations that make us doubt the quality of our development.

31. Practical Tips for Refactoring on Compose

In this article, I want to share my practice and tips about refactoring on Compose.

32. How to Find the Stinky Parts of Your Code [Part XXI]

Code smells are a classic. It smells because there are likely many instances where it could be edited or improved.

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

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

35. Code Trashing Symptom

There are a set of skills and qualities which make the ideal software developer we are all searching to be or searching for to employ. However, right now I am going to emphasize the importance of a quality that is mostly found in senior developers.

36. How to Find the Stinky Parts of Your Code [Part XXVI]

How to debug your code the easy way

37. How to Find The Stinky Parts of Your Code [Part XIV]

More smells on the way.

38. How to Find The Stinky Parts of Your Code [Part XV]

We see several symptoms and situations that make us doubt the quality of our development. Most of these smells are just hints of something that might be wrong.

39. "Don't outsource your self-esteem" - Maximiliano Contieri, 2020 Noonie Nominee for Refactoring

The 2020 Noonies are here and they are both much greener and much bigger than last year. Among the 2,000+ deserving humans nominated across 5 categories for over 200 award titles, we discovered Maximiliano Contieri from Argentina, who’s has been nominated for in the Software Development category. Without further ado, we present to you, our big techy world, from the perspective of Maximiliano .

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

41. Let's Stop Calling them 'Bugs' - Software Quality is Our Responsibility

The term Bug sounds like an excuse out of our scope infecting our systems. It is not. Software quality is under our control. It is our responsibility to deliver

42. How to Find the Stinky Parts of Your Code [Part XVIII]

More code smells incoming

43. How to Find the Stinky Parts of Your Code [Part XXV]

The smell of code smells is a classic, but you should look at it more carefully if you want to improve your code smell.

44. 6 Practices Of How To Use Linters For Reducing Technical Debt

Technical debt is a common term in software engineering management. It has been the target of debates for many years. The name comes from a financial analogy because some people defend that developers buy time by shipping faster (and with lower-than-expected quality).

45. 8 Things I've Learned Working on a Huge Legacy Codebase

"Let's limit the scope of this." is your new motto :-) Start learning the codebase by fixing bugs.

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

47. How to Find the Stinky Parts of Your Code [Part XXII]

Most of these smells are just hints of something that might be wrong. They are not required fixed per se… (You should look into it though.)

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

49. How to Find the Stinky Parts of Your Code [Part XXVII]

Identifying smells in your code and debugging the easy way.

50. How to Find the Stinky Parts of Your Code [Part XXIII]

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

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

52. How to Find the Stinky Parts of Your Code [Part XXXI]

Beginners are afraid to remove code. And many seniors too.

53. A Hacker Tried to Steal $566M by Exploiting a Code Smell, Here's How

Yesterday, 2022 Oct 7th one of the larger blockchains had to be halted. This news was shocking since most blockchains are decentralized by definition.

54. How to Find the Stinky Parts of Your Code [Part XXXIII]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

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

56. Nude Models - Part I : Setters

Ye olde Reliable Data Structures and Their Controversial (Write) Access.

57. Technical Debt: An Interview with Adam, Co-founder of CodeScene & Alex, CEO of Stepsize

I interviewed Adam Tornhill, CTO & Co-founder of CodeScene, about technical debt: what is it, why is it important, and how to manage it effectively?

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

Originally published at Managing Technical Debt.

59. On Abstraction, Complexitity, and Refactoring Factor in Data Science

Code is dependent on data and models, and therefore on the abstractions used in them, so refactoring is inevitable today. Why? Usually, refactoring means change

60. How to Find the Stinky Parts of Your Code [Part XXIV]

Most of these smells are just hints of something that might be wrong. They are not required fixed per se… (You should look into it though.)

61. How to Find The Stinky Parts of Your Code (Part VII)

We see several symptoms and situations that make us doubt the quality of our development.

62. 4 Tips on How to Refactor Code in Visual Studio Code

This article looks at how you can refactor your code using Visual Studio Code (VS Code) and Visual Studio Code plugins.

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

64. 4 Ways Software Engineers Organize Their TODOs

TODOs are a tricky subject for developers. Many codebases are guilty of having TODOs linger around while nobody knows who’s responsible for a TODO or even has the required context to tackle it. Yet, should we feel ashamed for our lingering TODOs?

65. Approaching Problems like a Software Engineer

During a recent, mock technical interview, I was given the following problem to solve.

66. Refactor Your Work Life — From Home 😉

TL;DR: It's time to spring clean your work-life, and make space for joy. Get rid of extraneous work, add a bit of mindfulness, and the WFH world is yours. You can do this regardless of who you are, but if you are the CEO or in a managerial position, the imperative is much higher.

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

68. Is Low-Code the Solution to Technical Debt?

Low-code is a means to develop applications with visual, intent-driven development tools reducing the need to create lines of custom code.

69. Creating a Wordle with TDD in Javascript

We keep practicing this amazing Kata and learning. You can follow the steps!

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

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

72. How to Find The Stinky Parts of Your Code [Part XII]

More code smells for your reading pleasure

73. Do Not Refactor Code That is Not Yet Working: Beautiful Code is Working Code

Excessive concern about the beauty of the source code can compromise the outcome of a project.

74. "Everyone Will [Soon] Build Software With No Code" - Alex Omeyer

Alex Omeyer from the United States has been nominated for TWO 2020 Noonies in the Future Heroes and Development award categories. Without further ado, we present to you, this big techy world, from the perspective of Alex - right after this ad break:

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

76. Hooked on React's Array Destructuring Pattern

The other day I was reading up on the legendary React God Dan Ambrov’s great but very un-TLDR post on useEffect.

77. Building a Wordle Game Using Test-Driven Development in 25 Minutes

Developing a complete word game is very easy with TDD

78. How to Find the Stinky Parts of Your Code (Part I)

The code smells bad. Let’s see how to change the aromas. In this series, we will see several symptoms and situations that make us doubt the quality of our developments. We will present possible solutions. Most of these smells are just hints of something that might be wrong. They are not rigid rules.

79. Nude Models - Part II : Getters

Ye olde Reliable Data Structures and Their Controversial (Read) Access.

Using objects as data structures is an established practice that generates many problems associated with the maintainability and evolution of software. It misuses brilliant concepts that were stated five decades ago. In this second part we will reflect on the reading access of these objects.

80. Complex Refactoring With Roslyn Compilers

Let’s imagine the monolith project with an enormous code base that has been developed for a couple of decades (unbelievable, right?). This project is probably going to have a myriad of features and a considerable (hopefully!) number of automated tests covering the verification of our priceless features on multiple levels. All the way up the famous, or infamous, depending on who’re you gonna ask, testing pyramid from the unit foundation down below to the end-to-end peak high above.

81. 400+ Thought-Provoking Software Engineering Quotes

The most complete curated collection of software and programming quotes

82. 10 Ways To Refactor Your Python Code

10 Ways to refactor Python code to make it more Pythonic

83. How to Get Rid of Annoying IFs Forever

Why the first instruction we learn to program should be the last to use.

84. Technical Debt and How to Prioritize It: An Interview with Adam Tornhill

Last week we hosted a webinar where I interviewed Adam Tornhill, CTO & Co-founder of CodeScene, about technical debt: what is it, why is it important, and how to manage it effectively.

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

86. How to Find the Stinky Parts of Your Code (Part II)

There are more code smells. Let’s keep changing the aromas. We see several symptoms and situations that make us doubt the quality of our development. Let's look at some possible solutions.

87. The Early Velocity Trap

With much of the DevOps stack having matured and good practices becoming more mainstream, the need for quality in software has quickly become a central issue

88. What is Code Refactoring? - Use Cases, Applications, and Benefits

The importance of code refactoring is immeasurable since its purpose is to simplify the code for better performance. ⚡Use all the benefits now.

89. Refactor: You Keep Using That Word…

I stumbled upon a thread recently where the question was posed, “What are some common mistakes when refactoring code?”

90. How to Find the Stinky Parts of Your Code (Part IV)

Are we done on code smells? Guess not.

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

92. How to Find The Stinky Parts of Your Code (Part VI)

Are we tired with code smells? Not yet!

93. What Exactly Is A Name: The Quest [Part I]

We all agree: a good name is always the most important thing. Let’s find them.

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

95. How to Squeeze Test Driven Development on Legacy Systems

We all love T.D.D. We know its benefits, we have read a thousand tutorials on how to build a system using this technique. But this not feasible for currently legacy systems.

96. How to Find the Stinky Parts of Your Code (Part V)

Are we done on code smells? Probably never!

97. Maxi Contieri on Clean Code, Refactoring, and Test-Driven Development

I blog about clean code, refactoring and TDD. I have been working on the industry for the past 25 years

98. How to Find The Stinky Parts of Your Code (Part VIII)

Yet more code smells? Plenty of!

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

100. Refactoring CryptoJS in Modern ECMAScript

Repository: entronad/crypto-es

101. How to Find The Stinky Parts of Your Code [Part XI]

This another code smell chapter

102. How to Find the Stinky Parts of Your Code (Part III)

There are yet more code smells. Let’s keep changing the aromas. We see several symptoms and situations that make us doubt the quality of our development.

103. How To Upgrade Your Codebase To Python 3 from Python 2.x

Is your team still using Python 2? If you’re not sure, now is a really good time to check. In April, the Python team released version 2.7.18, and it will be the last version of Python 2.x. If security vulnerabilities or other bugs are discovered going forward, they will NOT be fixed. To ensure that your software is secure and functioning properly, it’s imperative to develop a plan for migrating to Python 3. Numerous strategies can be found online. This post outlines an approach that we recommend you take.

104. Refactoring using Functional Programming

What

105. Programming as Theory Building

Building models and solutions in software is not just about programming. We will review Peter Naur's classic paper.

106. How to Find The Stinky Parts of Your Code (Part X)

More code smells. No joke. We see several symptoms and situations that make us doubt the quality of our development.

107. How to Find The Stinky Parts of Your Code (Part IX)

Yet more code smells? Aren't them enough?

108. How to Decouple a Legacy System

An exercise improving legacy code

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

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

Thank you for checking out the 110 most read stories about Refactoring on HackerNoon.

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