- What are the risks and potential benefits of type I piracy?
- What kind of problems can arise from type II piracy?
- How does type III piracy cause trouble?
- What should we watch out for when specifying function arguments?
- How is system performance affected by using abstract function arguments?
- How is system performance affected by using abstract field types for composite types?
- 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
Questions
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.