Behavioral patterns refer to how objects are designed to collaborate and communicate with each other. There are 11 GoF patterns from the OOP paradigm. We will cover all of them here with some interesting hands-on examples.
Behavioral patterns
by Stefan Karpinski, Tom Kwong
Hands-On Design Patterns and Best Practices with Julia
- Title Page
- Copyright and Credits
- Dedication
- About Packt
- Foreword
- Contributors
- Preface
- Section 1: Getting Started with Design Patterns
- Design Patterns and Related Principles
- Section 2: Julia Fundamentals
- Modules, Packages, and Data Type Concepts
- Technical requirements
- The growing pains of developing applications
- Working with namespaces, modules, and packages
- Managing package dependencies
- Designing abstract and concrete types
- Working with parametric types
- Conversion between data types
- Summary
- Questions
- Designing Functions and Interfaces
- Technical requirements
- Designing functions
- Understanding Multiple Dispatch
- Leveraging parametric methods
- Working with interfaces
- Summary
- Questions
- Macros and Metaprogramming Techniques
- Technical requirements
- Understanding the need for metaprogramming
- Working with expressions
- Developing macros
- Using generated functions
- Summary
- Questions
- Section 3: Implementing Design Patterns
- Reusability Patterns
- Technical requirements
- The delegation pattern
- The holy traits pattern
- The parametric type pattern
- Summary
- Questions
- Performance Patterns
- Technical requirements
- The global constant pattern
- Benchmarking performance with global variables
- Enjoying the speed of global constants
- Annotating variables with type information
- Understanding why constants help performance
- Passing global variables as function arguments
- Hiding a variable inside a global constant 
- Turning to some real-life examples
- Considerations
- The struct of arrays pattern
- The shared array pattern
- Introducing a risk management use case
- Preparing data for the example
- Overview of a high-performance solution
- Populating data in the shared array
- Analyzing data directly on a shared array
- Understanding the overhead of parallel processing
- Configuring system settings for shared memory usage
- Ensuring worker processes have access to code and data 
- Avoiding race conditions among parallel processes
- Working with the constraints of shared arrays
- The memoization pattern
- Introducing the Fibonacci function
- Improving the performance of the Fibonacci function
- Automating the construction of a memoization cache
- Understanding the constraint with generic functions
- Supporting functions that take multiple arguments
- Handling mutable data types in the arguments
- Memoizing generic functions with macros
- Turning to real-life examples
- Considerations
- Utilizing the Caching.jl package
- The barrier function pattern
- Summary
- Questions
- Maintainability Patterns
- Technical requirements
- Sub-module pattern
- Understanding when sub-module is needed
- Understanding afferent and efferent coupling
- Organizing sub-modules
- Referencing symbols and functions between modules and sub-modules
- Removing bidirectional coupling
- Considering splitting into top-level modules
- Understanding the counterarguments of using sub-modules
- Keyword definition pattern
- Code generation pattern
- Domain-specific language pattern
- Summary
- Questions
- Robustness Patterns
- Miscellaneous Patterns
- Technical requirements
- Singleton type dispatch pattern
- Stubbing/Mocking pattern
- Functional pipes pattern
- Summary
- Questions
- Anti-Patterns
- Technical requirements
- Piracy anti-pattern
- Narrow argument types anti-pattern
- Considering various options for argument types
- Option 1 – Vectors of Float64 values
- Option 2 – Vectors of instances of Number
- Option 3 – Vectors of type T where T is a subtype of Number
- Option 4 – Vectors of type S and T where S and T are subtypes of Number
- Option 5 – Arrays of type S and type T where S and T are subtypes of Number
- Option 6 – Abstract arrays
- Option 7 – Duck typing
- Summarizing all options
- Evaluating performance
- Considering various options for argument types
- Nonconcrete field types anti-pattern
- Summary
- Questions
- Traditional Object-Oriented Patterns
- Section 4: Advanced Topics
- Inheritance and Variance
- Assessments
- Other Books You May Enjoy
Behavioral patterns
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.