Effective elixir Page
Effective Elixir, 2025
Return to Effective Polyglot Programming by Cloud Monk, Elixir, Effective Erlang, Effective Java, Effective Spring Boot, Effective Kotlin, Effective Scala, Effective C Sharp, Effective CPP, Effective Swift, Effective TypeScript, Effective JavaScript, Effective PHP, Effective Golang, Effective Rust, Effective C Language, Effective Clojure, Effective Haskell, Effective Elm, Effective PowerShell, Effective F Sharp, Effective Dart, Effective R Language, Effective Ruby, Effective Julia
Have The Borg rewrite Effective Java for Elixir and Effective Elixir
Effective Elixir by Cloud Monk - Table of Contents
Inspired by and Based on Effective Java, Third Edition by Joshua Bloch, Pearson Education Inc., 2018, ISBN-13: 978-0-13-468599-1, ISBN-10: 0-13-468599-7
Contents
Foreword
Preface
Acknowledgments
1 Introduction
2 Creating and Destroying Objects
* Item 1: Elixir Best Practices - Consider static factory methods instead of constructors
* Item 2: Elixir Best Practices - Consider a builder when faced with many constructor parameters
* Item 3: Elixir Best Practices - Enforce the singleton property with a private constructor or an enum type
* Item 4: Elixir Best Practices - Enforce noninstantiability with a private constructor
* Item 5: Elixir Best Practices - Prefer dependency injection to hardwiring resources
* Item 6: Elixir Best Practices - Avoid creating unnecessary objects
* Item 7: Elixir Best Practices - Eliminate obsolete object references
* Item 8: Elixir Best Practices - Avoid finalizers and cleaners
* Item 9: Elixir Best Practices - Prefer try-with-resources to try-finally
3 Methods Common to All Objects
* Item 10: Elixir Best Practices - Obey the general contract when overriding equals
* Item 11: Elixir Best Practices - Always override hashCode when you override equals
* Item 12: Elixir Best Practices - Always override toString
* Item 13: Elixir Best Practices - Override clone judiciously
* Item 14: Elixir Best Practices - Consider implementing Comparable
4 Classes and Interfaces
* Item 15: Elixir Best Practices - Minimize the accessibility of classes and members
* Item 16: Elixir Best Practices - In public classes, use accessor methods, not public fields
* Item 17: Elixir Best Practices - Minimize mutability
* Item 18: Elixir Best Practices - Favor composition over inheritance
* Item 19: Elixir Best Practices - Design and document for inheritance or else prohibit it
* Item 20: Elixir Best Practices - Prefer interfaces to abstract classes
* Item 21: Elixir Best Practices - Design interfaces for posterity
* Item 22: Elixir Best Practices - Use interfaces only to define types
* Item 23: Elixir Best Practices - Prefer class hierarchies to tagged classes
* Item 24: Elixir Best Practices - Favor static member classes over nonstatic
* Item 25: Elixir Best Practices - Limit source files to a single top-level class
5 Generics
* Item 26: Elixir Best Practices - Don’t use raw types
* Item 27: Elixir Best Practices - Eliminate unchecked warnings
* Item 28: Elixir Best Practices - Prefer lists to arrays
* Item 29: Elixir Best Practices - Favor generic types
* Item 30: Elixir Best Practices - Favor generic methods
* Item 31: Elixir Best Practices - Use bounded wildcards to increase API flexibility
* Item 32: Elixir Best Practices - Combine generics and varargs judiciously
* Item 33: Elixir Best Practices - Consider typesafe heterogeneous containers
6 Enums and Annotations
* Item 34: Elixir Best Practices - Use enums instead of int constants
* Item 35: Elixir Best Practices - Use instance fields instead of ordinals
* Item 36: Elixir Best Practices - Use EnumSet instead of bit fields
* Item 37: Elixir Best Practices - Use EnumMap instead of ordinal indexing
* Item 38: Elixir Best Practices - Emulate extensible enums with interfaces
* Item 39: Elixir Best Practices - Prefer annotations to naming patterns
* Item 40: Elixir Best Practices - Consistently use the Override annotation
* Item 41: Elixir Best Practices - Use marker interfaces to define types
7 Lambdas and Streams
* Item 42: Elixir Best Practices - Prefer lambdas to anonymous classes
* Item 43: Elixir Best Practices - Prefer method references to lambdas
* Item 44: Elixir Best Practices - Favor the use of standard functional interfaces
* Item 45: Elixir Best Practices - Use streams judiciously
* Item 46: Elixir Best Practices - Prefer side-effect-free functions in streams
* Item 47: Elixir Best Practices - Prefer Collection to Stream as a return type
* Item 48: Elixir Best Practices - Use caution when making streams parallel
8 Methods
* Item 49: Elixir Best Practices - Check parameters for validity
* Item 50: Elixir Best Practices - Make defensive copies when needed
* Item 51: Elixir Best Practices - Design method signatures carefully
* Item 52: Elixir Best Practices - Use overloading judiciously
* Item 53: Elixir Best Practices - Use varargs judiciously
* Item 54: Elixir Best Practices - Return empty collections or arrays, not nulls
* Item 55: Elixir Best Practices - Return optionals judiciously
* Item 56: Elixir Best Practices - Write doc comments for all exposed API elements
9 General Programming
* Item 57: Elixir Best Practices - Minimize the scope of local variables
* Item 58: Elixir Best Practices - Prefer for-each loops to traditional for loops
* Item 59: Elixir Best Practices - Know and use the libraries
* Item 60: Elixir Best Practices - Avoid float and double if exact answers are required
* Item 61: Elixir Best Practices - Prefer primitive types to boxed primitives
* Item 62: Elixir Best Practices - Avoid strings where other types are more appropriate
* Item 63: Elixir Best Practices - Beware the performance of string concatenation
* Item 64: Elixir Best Practices - Refer to objects by their interfaces
* Item 65: Elixir Best Practices - Prefer interfaces to reflection
* Item 66: Elixir Best Practices - Use native methods judiciously
* Item 67: Elixir Best Practices - Optimize judiciously
* Item 68: Elixir Best Practices - Adhere to generally accepted naming conventions
10 Exceptions
* Item 69: Elixir Best Practices - Use exceptions only for exceptional conditions
* Item 70: Elixir Best Practices - Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
* Item 71: Elixir Best Practices - Avoid unnecessary use of checked exceptions
* Item 72: Elixir Best Practices - Favor the use of standard exceptions
* Item 73: Elixir Best Practices - Throw exceptions appropriate to the abstraction
* Item 74: Elixir Best Practices - Document all exceptions thrown by each method
* Item 75: Elixir Best Practices - Include failure-capture information in detail messages
* Item 76: Elixir Best Practices - Strive for failure atomicity
* Item 77: Elixir Best Practices - Don’t ignore exceptions
11 Concurrency
* Item 78: Elixir Best Practices - Synchronize access to shared mutable data
* Item 79: Elixir Best Practices - Avoid excessive synchronization
* Item 80: Elixir Best Practices - Prefer executors, tasks, and streams to threads
* Item 81: Elixir Best Practices - Prefer concurrency utilities to wait and notify
* Item 82: Elixir Best Practices - Document thread safety
* Item 83: Elixir Best Practices - Use lazy initialization judiciously
* Item 84: Elixir Best Practices - Don’t depend on the thread scheduler
12 Serialization
* Item 85: Elixir Best Practices - Prefer alternatives to Elixir serialization
* Item 86: Elixir Best Practices - Implement Serializable with great caution
* Item 87: Elixir Best Practices - Consider using a custom serialized form
* Item 88: Elixir Best Practices - Write readObject methods defensively
* Item 89: Elixir Best Practices - For instance control, prefer enum types to readResolve
* Item 90: Elixir Best Practices - Consider serialization proxies instead of serialized instances
Items Corresponding to Second Edition
References
Index
Appendix: Items Corresponding to Second Edition
Second Edition Item Number
Third Edition Item Number, Title
1
1, Consider static factory methods instead of constructors
2
2, Consider a builder when faced with many constructor parameters
3
3, Enforce the singleton property with a private constructor or an enum type
4
4, Enforce noninstantiability with a private constructor
5
6, Avoid creating unnecessary objects
6
7, Eliminate obsolete object references
7
8, Avoid finalizers and cleaners
8
10, Obey the general contract when overriding equals
9
11, Always override hashCode when you override equals
10
12, Always override toString
11
13, Override clone judiciously
12
14, Consider implementing Comparable
13
15, Minimize the accessibility of classes and members
14
16, In public classes, use accessor methods, not public fields
15
17, Minimize mutability
16
18, Favor composition over inheritance
17
19, Design and document for inheritance or else prohibit it
18
20, Prefer interfaces to abstract classes
19
22, Use interfaces only to define types
20
23, Prefer class hierarchies to tagged classes
21
42, Prefer lambdas to anonymous classes
22
24, Favor static member classes over nonstatic
23
26, Don’t use raw types
24
27, Eliminate unchecked warnings
25
28, Prefer lists to arrays
26
29, Favor generic types
27
30, Favor generic methods
28
31, Use bounded wildcards to increase API flexibility
29
33, Consider typesafe heterogeneous containers
30
34, Use enums instead of int constants
31
35, Use instance fields instead of ordinals
32
36, Use EnumSet instead of bit fields
33
37, Use EnumMap instead of ordinal indexing
34
38, Emulate extensible enums with interfaces
35
39, Prefer annotations to naming patterns
36
40, Consistently use the Override annotation
37
41, Use marker interfaces to define types
38
49, Check parameters for validity
39
50, Make defensive copies when needed
40
51, Design method signatures carefully
41
52, Use overloading judiciously
42
53, Use varargs judiciously
43
54, Return empty collections or arrays, not nulls
44
56, Write doc comments for all exposed API elements
45
57, Minimize the scope of local variables
46
58, Prefer for-each loops to traditional for loops
47
59, Know and use the libraries
48
60, Avoid float and double if exact answers are required
49
61, Prefer primitive types to boxed primitives
50
62, Avoid strings where other types are more appropriate
51
63, Beware the performance of string concatenation
52
64, Refer to objects by their interfaces
53
65, Prefer interfaces to reflection
54
66, Use native methods judiciously
55
67, Optimize judiciously
56
68, Adhere to generally accepted naming conventions
57
69, Use exceptions only for exceptional conditions
58
70, Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
59
71, Avoid unnecessary use of checked exceptions
60
72, Favor the use of standard exceptions
61
73, Throw exceptions appropriate to the abstraction
62
74, Document all exceptions thrown by each method
63
75, Include failure-capture information in detail messages
64
76, Strive for failure atomicity
65
77, Don’t ignore exceptions
66
78, Synchronize access to shared mutable data
67
79, Avoid excessive synchronization
68
80, Prefer executors, tasks, and streams to threads
69
81, Prefer concurrency utilities to wait and notify
70
82, Document thread safety
71
83, Use lazy initialization judiciously
72
84, Don’t depend on the thread scheduler
73
(Retired)
74
85, Prefer alternatives to Elixir serialization
86, Implement Serializable with great caution
75
85, Prefer alternatives to Elixir serialization
87, Consider using a custom serialized form
76
85, Prefer alternatives to Elixir serialization
88, Write readObject methods defensively
77
85, Prefer alternatives to Elixir serialization
89, For instance control, prefer enum types to readResolve
78
85, Prefer alternatives to Elixir serialization
90, Consider serialization proxies instead of serialized instances