Code Smells in Elixir - CODE BEAM EU 2023

Code smells are indicators of potential design problems in software code. They can impact maintainability, readability, and overall code quality.

While code smells have been extensively studied in object-oriented programming languages, their applicability and identification in functional programming languages like Elixir remain a fascinating area of exploration.

In this talk, we will dive into the world of Elixir and uncover code smells that may arise in its codebase. We will explore the traditional code smells (including the newly cataloged Elixir-specific code smells), discuss their impact on Elixir applications, and provide practical insights into refactoring techniques to eliminate them.

Transcript

1. CODE SMELLS IN ELIXIR CODE BEAM EU 2023
2. ELAINE NAOMI WATANABE twitter.com/elaine_nw speakerdeck.com/elainenaomi linkedin.com/in/elainenaomi B.Sc. in Computer Engineering M.Sc. in Computer Science Senior Software Engineer @ TheRealReal Yesterday 11°C Berlin Germany GMT+2 Last Saturday 23°C São Paulo Brazil GMT-3
3. https://speakerdeck.com/elainenaomi
4. CODE SMELLS
5. Code smells are sub-optimal design choices that can degrade different aspects of code quality Yamashita, Aiko, and Steve Counsell. "Code smells as system-level indicators of maintainability: An empirical study." Journal of Systems and Software 86.10 (2013): 2639-2653.
6. They are indicators of software design flaws that could potentially affect maintenance Yamashita, Aiko, and Steve Counsell. "Code smells as system-level indicators of maintainability: An empirical study." Journal of Systems and Software 86.10 (2013): 2639-2653.
7. Alternative Classes with Different Interfaces Loops Lazy Element Speculative Generality Temporary Field Message Chains Middle Man Insider Trading Large Class Data Class Refused Bequest Comments Mysterious Name Duplicated Code Long Function Long Parameter List Global Data Mutable Data Divergent Change Shotgun Surgery Feature Envy Data Clumps Primitive Obsession Repeated Switches 2018
8. REFACTORING
10. https://martinfowler.com/books/refactoring.html https://en.wikipedia.org/wiki/Code_refactoring REFACTORING A controlled technique for improving the design of an existing code base.
11. Small behavior-preserving transformations
12. CATALOG OF REFACTORINGS Replace Inline Code with Function Call Replace Loop with Pipeline Replace Nested Conditional with Guard Clauses Replace Parameter with Query Replace Primitive with Object Replace Query with Parameter Replace Subclass with Delegate Replace Superclass with Delegate Replace Temp with Query Replace Type Code with Subclasses Separate Query from Modifier Slide Statements Split Loop Split Phase Split Variable Substitute Algorithm Change Function Declaration Change Reference to Value Change Value to Reference Collapse Hierarchy Combine Functions into Class Combine Functions into Transform Consolidate Conditional Expression Decompose Conditional Encapsulate Collection Encapsulate Record Encapsulate Variable Extract Class Extract Function Extract Superclass Extract Variable Hide Delegate Inline Class Inline Function Inline Variable Introduce Assertion Introduce Parameter Object Introduce Special Case Move Field Move Function Move Statements into Function Move Statements to Callers Parameterize Function Preserve Whole Object Pull Up Constructor Body Pull Up Field Pull Up Method Push Down Field Push Down Method Remove Dead Code Remove Flag Argument Remove Middle Man Remove Setting Method Remove Subclass Rename Field Rename Variable Replace Command with Function Replace Conditional with Polymorphism Replace Constructor with Factory Function Replace Derived Variable with Query Replace Function with Command https://refactoring.com/catalog/ 2018
13. Identify a code smell To fix now? Apply refactoring Run tests Yes No Finish
14. HISTORY 💾
15. 22 Code smells 72 Refactoring techniques 1999
16. Mainly focused on object-oriented programming languages
17. So, is it not an issue for functional programming languages?
18. So, is it not an issue for functional programming languages?
19. OOP + FP 2018 18+ years later 24 code smells 61 refactoring techniques
20. Erlang/OTP Code Smells
22. Elixir Code Smells
23. Prof. Marco Tulio Valente Prof. Lucas Francisco da Matta Vegi Federal University of Minas Gerais (UFMG) Belo Horizonte, Minas Gerais, Brazil
24. https://homepages.dcc.ufmg.br/~mtov/pub/2022-icpc-era.pdf
25. Elixir Brasil: Code Smells, Refactoring and Elixir (in Portuguese) https://www.youtube.com/watch?v=3-1PCurON4Q https://speakerdeck.com/elainenaomi/elixir-brasil-2020-code-smells-refactoring-e-elixir One of my talks was part of the data sources analyzed in the grey literature review
26. https://homepages.dcc.ufmg.br/~mtov/pub/2023-emse-code-smells-elixir.pdf
27. The Elixir Community Contribution https://doi.org/10.1007/s10664-023-10343-6
28. https://github.com/lucasvegi/Elixir-Code-Smells
29. https://doi.org/10.1007/s10664-023-10343-6
30. CODE SMELLS IN ELIXIR
31. TRADITIONAL CODE SMELLS
32. EXAMPLE #1 Duplicated Code
33. defmodule ShoppingCart do def calculate_shipping(zip_code, subscription) do if (Enum.member?([3, 4], subscription.id)) do 0 else 10.0 * Location.calculate(zip_code) end end def apply_discount(total, subscription) do if (Enum.member?([3, 4], subscription.id)) do total * 0.9 else total end end end
34. defmodule ShoppingCart do def calculate_shipping(zip_code, subscription) do if (Enum.member?([3, 4], subscription.id)) do 0 else 10.0 * Location.calculate(zip_code) end end def apply_discount(total, subscription) do if (Enum.member?([3, 4], subscription.id)) do total * 0.9 else total end end end Duplicated business rule
36. Rewriting with pattern matching…
37. defmodule ShoppingCart do def calculate_shipping(_zip_code, %{id: 3}), do: 0.0 def calculate_shipping(_zip_code, %{id: 4}), do: 0.0 def calculate_shipping(zip_code, _), do: 10.0 * Location.calculate(zip_code) def apply_discount(total, %{id: 3}), do: total * 0.95 def apply_discount(total, %{id: 4}), do: total * 0.9 def apply_discount(total, _), do: total end
38. defmodule ShoppingCart do def calculate_shipping(_zip_code, %{id: 3}), do: 0.0 def calculate_shipping(_zip_code, %{id: 4}), do: 0.0 def calculate_shipping(zip_code, _), do: 10.0 * Location.calculate(zip_code) def apply_discount(total, %{id: 3}), do: total * 0.95 def apply_discount(total, %{id: 4}), do: total * 0.9 def apply_discount(total, _), do: total end Enum.member?([3, 4], subscription.id) Duplicated business rule
40. Applying a refactoring…
41. defmodule Subscription do defstruct [:id, :shipping_tax, :discount_rate] def available_subscriptions do [ %Subscription{id: 3, shipping_tax: 0.0, discount_rate: 0.95}, %Subscription{id: 4, shipping_tax: 0.0, discount_rate: 0.9} ] end end Encapsulating the rules, centralizing them in one single place
42. defmodule ShoppingCart do def calculate_shipping(_zip_code, %{id: 3}), do: 0.0 def calculate_shipping(_zip_code, %{id: 4}), do: 0.0 def calculate_shipping(zip_code, _), do: 10.0 * Location.calculate(zip_code) def apply_discount(total, %{id: 3}), do: total * 0.95 def apply_discount(total, %{id: 4}), do: total * 0.9 def apply_discount(total, _), do: total end
43. defmodule ShoppingCart do def calculate_shipping(_, %Subscription{shipping_tax: shipping_tax}), do: shipping_tax def calculate_shipping(zip_code, _), do: 10.0 * Location.calculate(zip_code) def apply_discount(total, %Subscription{discount_rate: discount_rate}), do: total * discount_rate def apply_discount(total, _), do: total end Now, the subscription type is transparent for this module
44. EXAMPLE #2 Long Parameter List
45. defmodule User do def create_user( name, email, password, username, status, active?, admin? ) do # ... end end
46. defmodule User do def create_user( name, email, password, username, status, active?, admin? ) do # ... end end
47. Applying a refactoring…
48. defmodule User do def create_user( name, email, password, username, status, active?, admin? ) do # ... end end
49. defmodule User do def create_user(user) do # ... end end It can be a map %{}
50. defmodule User do def create_user(%User{} = user) do # ... end end or a new struct :)
51. defmodule User do def create_user(%User{} = user) do # ... end end new_user = %User{ name: "Elaine", email: "teste@teste.com", password: "123", username: "elainenaomi", status: 1, active?: true, admin?: false } User.create_user(new_user)
52. ELIXIR-SPECIFIC CODE SMELLS
53. EXAMPLE #1 Using exceptions for control-flow
54. defmodule Report do def print_status(value) do if is_integer(value) do #... "Result..." else raise RuntimeError, message: "Invalid argument. It is not integer!" end end end
55. defmodule Report do def print_status(value) do if is_integer(value) do #... "Result..." else raise RuntimeError, message: "Invalid argument. It is not integer!" end end end
56. defmodule Client do # Client forced to use exceptions for control-flow. def status(arg) do try do value = Report.print_status(arg) "All good! #{value}." rescue e in RuntimeError -> reason = e.message "Uh oh! #{reason}." end end end
57. defmodule Client do # Client forced to use exceptions for control-flow. def status(arg) do try do value = Report.print_status(arg) "All good! #{value}." rescue e in RuntimeError -> reason = e.message "Uh oh! #{reason}." end end end
58. Applying a refactoring…
59. defmodule Report do def print_status(value) do if is_integer(value) do #... "Result..." else raise RuntimeError, message: "Invalid argument. It is not integer!" end end end
60. defmodule Report do def print_status(value) do if is_integer(value) do #... {:ok, "Result..."} else {:error, "Invalid argument. It is not integer!" end end end Error Monad
61. defmodule Client do # Client forced to use exceptions for control-flow. def status(arg) do try do value = Report.print_status(arg) "All good! #{value}." rescue e in RuntimeError -> reason = e.message "Uh oh! #{reason}." end end end
62. defmodule Client do # Client forced to use exceptions for control-flow. def status(arg) do case Report.print_status(arg) do {:ok, value} -> "All good! #{value}." {:error, reason} -> "Uh oh! #{reason}." end end end
63. EXAMPLE #2 Complex Extractions in Clauses
64. def drive(%User{name: name, age: age}) when age >= 18 do "#{name} can drive" end def drive(%User{name: name, age: age}) when age < 18 do "#{name} cannot drive" end Extracting values for further usage and pattern/guard checking
65. Applying a refactoring…
66. def drive(%User{age: age} = user) when age >= 18 do %User{name: name} = user "#{name} can drive" end def drive(%User{age: age} = user) when age < 18 do %User{name: name} = user "#{name} cannot drive" end Extracting only pattern/guard-related variables
67. def drive(%User{age: age} = user) when age >= 18 do "#{user.name} can drive" end def drive(%User{age: age} = user) when age < 18 do "#{user.name} cannot drive" end Using dot notation for accessing struct properties
68. Elixir 1.16 will contain the complete catalog of code smells in Elixir They will be called "anti-patterns"
69. https://hexdocs.pm/elixir/main/what-anti-patterns.html
70. Anti-pattern structure Name Unique, To facilitate communication Problem How it can harm code quality What impacts it can have for developers Example Code + textual description Refactoring Suggested changes to improve code quality
71. Anti-pattern structure Name Unique, To facilitate communication Problem How it can harm code quality What impacts it can have for developers Example Code + textual description Refactoring Suggested changes to improve code quality
73. IN PROGRESS
74. Catalog of Refactorings
75. https://homepages.dcc.ufmg.br/~mtov/pub/2023-icsme-nier-elixir.pdf
76. Elixir Community ++ Research with Elixir
77. https://github.com/lucasvegi/Elixir-Refactorings
78. <call for community>
79. WHAT'S NEXT?
80. Tooling
81. Not all code smells are detectable by automating tools
82. hexdocs.pm/credo Improving
83. Developer’s experience and system’s knowledge play an important role in the identification of some smells. F. Palomba, G. Bavota, M. Di Penta, R. Oliveto and A. De Lucia, "Do They Really Smell Bad? A Study on Developers' Perception of Bad Code Smells," 2014 IEEE International Conference on Software Maintenance and Evolution, Victoria, BC, Canada, 2014, pp. 101-110, doi: 10.1109/ICSME.2014.32.
84. A.I.? GH Copilot ChatGPT etc.
85. Metrics?
86. Cyclomatic complexity
88. ABC Software Metric
90. WRAPPING UP
91. History Traditional and Elixir-specific code smells Impact of code smells over time Refactoring techniques
92. Code smells != Bugs
93. Code smells → Potential design flaws
94. It's about the impact on the software maintenance and evolvability
95. Understability and changeability matter
96. Understability and changeability matter If you'd like to scale your team
97. Understability and changeability matter If you wish to take time off :)
98. Research indicates that almost 60% of programmers’ time is spent understanding code, rather than writing code. From The Programmer's Brain - Felienne Hermans
99. Automated tests + Refactoring =
100. https://martinfowler.com/bliki/TestCoverage.html
101. https://martinfowler.com/articles/practical-test-pyramid.html
102. To keep in mind: you don't need to fix ALL code smells
104. Prefer duplication over the wrong abstraction Sandi Metz https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction
105. Refactoring != Revolution
106. It's all about accumulative improvements
107. https://martinfowler.com/bliki/DesignStaminaHypothesis.html design payoff line no design good design cumulative functionality time
108. Developer productivity Product evolvability Quality of end-product Self-improvement etc "Do developers care about code smells? An exploratory survey" A. Yamashita and L. Moonen, 2013 doi: 10.1109/WCRE.2013.6671299.
109. #
110. Legacy code in Elixir
111. How is your codebase in Elixir?
112. Is it EASY TO CHANGE?
113. speakerdeck.com/elainenaomi elainenaomi.dev Muito obrigada illustrations from undraw.co translation: thank you so much! Don't forget to check and participate in the discussions about the catalog of refactorings