Stoop 436-strategy
•Download as PPT, PDF•
0 likes•353 views
The document discusses the strategy design pattern, which defines a family of algorithms, encapsulates each in a separate class, and defines the same interface so they can be interchangeable. The strategy pattern allows algorithms to vary independently from clients that use them by assigning responsibility for a task to various strategy classes. This improves flexibility by making algorithms easily replaceable at runtime and reduces complexity in client classes. The key participants are a strategy interface, concrete strategy classes that implement it, and a context class that maintains a reference to a strategy and delegates work to it.
Report
Share
Report
Share
Recommended
2. data types, variables and operators
This document discusses data types, variables, operators, and other fundamental programming concepts in Python. It aims to teach readers how to analyze problems, design solutions, and implement programs to solve problems like computing loan payments given loan details. Some key topics covered include using variables to store values, writing expressions and assignment statements, numeric operators like addition and multiplication, and type conversion functions. Examples are provided throughout to demonstrate concepts like computing areas with variables, evaluating expressions, and displaying the current time.
Stoop ed-lod
The document discusses coupling and the Law of Demeter principle, which states that objects should only communicate with their immediate neighbors. Following this principle leads to code with looser coupling, better encapsulation, and easier substitution of components. The document provides examples of correct and incorrect ways to follow the Law of Demeter when sending messages to instance variables, arguments, self, and newly created objects. It also discusses some exceptions like collections, as well as considerations around using accessors instead of direct instance variable access. Overall it emphasizes designing objects with complete interfaces that protect encapsulation.
Stoop 414-smalltalk elementsofdesign
This document discusses various elements of object-oriented design, including instance initialization, enforcing instance creation interfaces, instance and class methods/variables, class initialization, and other design patterns and principles. It provides examples and recommendations for properly initializing instances, creating robust creation interfaces, sharing state between classes and instances, and avoiding common anti-patterns. The document also includes a case study on the Scanner class in Smalltalk to illustrate some of these concepts.
Stoop ed-dual interface
This document discusses the concept of dual interfaces in object-oriented design, where a class has two types of clients - external clients and subclasses. It notes that making fields private prevents subclasses from accessing or modifying them directly, so protected accessors should be provided instead to empower subclasses while preventing direct field access by external clients. This dual interface approach benefits classes by controlling field access for clients but empowering subclasses.
07 bestpractice
This document discusses various best practice patterns for object-oriented programming in Smalltalk, including:
1. Naming conventions for classes, methods, variables and parameters to clearly indicate their purpose and role.
2. Using delegation to share implementation between classes without inheritance. Delegation patterns include simple delegation, self delegation, and reversing methods.
3. Double dispatch and method objects for handling multiple cases through message passing rather than conditionals.
4. Lazy initialization, caching, and conversion methods to optimize performance of expensive computations.
5. Patterns for collections, intervals and streams including comparing and ordering objects.
8 - OOP - Smalltalk Model
The document discusses Smalltalk's object model, which has a pure and minimal design. It notes that Smalltalk uses a single inheritance hierarchy, with public methods and protected instance variables. Everything is an object, including classes, which are also instances of classes. This leads to a simple and unified method lookup approach - methods are looked up within the class of the receiving object.
Stoop ed-unit ofreuse
This document discusses using hook and template methods to improve code reuse in object-oriented programs. Hook methods provide places where subclasses can insert specialized behavior, while template methods provide reusable context. Examples show hook methods like printOn: and postCopy that subclasses can override to customize object printing and copying behavior. Template methods like printString and copy provide reusable context by calling the hook methods. This approach allows code to be reused while still allowing customization in subclasses.
Stoop 450-s unit
Unit testing involves writing small tests for individual units or classes of code to ensure specified behaviors are maintained. Tests should be written incrementally and even before code is written. When bugs are discovered, write tests to demonstrate the bug before fixing. Tests act as documentation and provide confidence when refactoring code. Common unit testing frameworks like SUnit and JUnit provide tools for writing, running, and collecting test results. Tests should be repeatable, require no human intervention, and change less often than the code being tested.
Recommended
2. data types, variables and operators
This document discusses data types, variables, operators, and other fundamental programming concepts in Python. It aims to teach readers how to analyze problems, design solutions, and implement programs to solve problems like computing loan payments given loan details. Some key topics covered include using variables to store values, writing expressions and assignment statements, numeric operators like addition and multiplication, and type conversion functions. Examples are provided throughout to demonstrate concepts like computing areas with variables, evaluating expressions, and displaying the current time.
Stoop ed-lod
The document discusses coupling and the Law of Demeter principle, which states that objects should only communicate with their immediate neighbors. Following this principle leads to code with looser coupling, better encapsulation, and easier substitution of components. The document provides examples of correct and incorrect ways to follow the Law of Demeter when sending messages to instance variables, arguments, self, and newly created objects. It also discusses some exceptions like collections, as well as considerations around using accessors instead of direct instance variable access. Overall it emphasizes designing objects with complete interfaces that protect encapsulation.
Stoop 414-smalltalk elementsofdesign
This document discusses various elements of object-oriented design, including instance initialization, enforcing instance creation interfaces, instance and class methods/variables, class initialization, and other design patterns and principles. It provides examples and recommendations for properly initializing instances, creating robust creation interfaces, sharing state between classes and instances, and avoiding common anti-patterns. The document also includes a case study on the Scanner class in Smalltalk to illustrate some of these concepts.
Stoop ed-dual interface
This document discusses the concept of dual interfaces in object-oriented design, where a class has two types of clients - external clients and subclasses. It notes that making fields private prevents subclasses from accessing or modifying them directly, so protected accessors should be provided instead to empower subclasses while preventing direct field access by external clients. This dual interface approach benefits classes by controlling field access for clients but empowering subclasses.
07 bestpractice
This document discusses various best practice patterns for object-oriented programming in Smalltalk, including:
1. Naming conventions for classes, methods, variables and parameters to clearly indicate their purpose and role.
2. Using delegation to share implementation between classes without inheritance. Delegation patterns include simple delegation, self delegation, and reversing methods.
3. Double dispatch and method objects for handling multiple cases through message passing rather than conditionals.
4. Lazy initialization, caching, and conversion methods to optimize performance of expensive computations.
5. Patterns for collections, intervals and streams including comparing and ordering objects.
8 - OOP - Smalltalk Model
The document discusses Smalltalk's object model, which has a pure and minimal design. It notes that Smalltalk uses a single inheritance hierarchy, with public methods and protected instance variables. Everything is an object, including classes, which are also instances of classes. This leads to a simple and unified method lookup approach - methods are looked up within the class of the receiving object.
Stoop ed-unit ofreuse
This document discusses using hook and template methods to improve code reuse in object-oriented programs. Hook methods provide places where subclasses can insert specialized behavior, while template methods provide reusable context. Examples show hook methods like printOn: and postCopy that subclasses can override to customize object printing and copying behavior. Template methods like printString and copy provide reusable context by calling the hook methods. This approach allows code to be reused while still allowing customization in subclasses.
Stoop 450-s unit
Unit testing involves writing small tests for individual units or classes of code to ensure specified behaviors are maintained. Tests should be written incrementally and even before code is written. When bugs are discovered, write tests to demonstrate the bug before fixing. Tests act as documentation and provide confidence when refactoring code. Common unit testing frameworks like SUnit and JUnit provide tools for writing, running, and collecting test results. Tests should be repeatable, require no human intervention, and change less often than the code being tested.
15 - Streams
This document discusses streams in Smalltalk. Streams allow traversal of collections and can be internal or external. Internal streams are associated with Smalltalk collections, while external streams interact with files or other collection-like objects. The document describes the stream classes like read streams, write streams, peekable streams, and positionable streams. It provides examples of using streams to read, write, insert and retrieve elements.
Stoop sed-class initialization
The document discusses class initialization in object-oriented programming. It explains that class initialization is used to initialize class variables and instance variables when a class is loaded. The class initialization method, which in Squeak is named 'initialize', is automatically called by the system at load time or can be explicitly called by the programmer. It provides an example of a Date class initialization method that initializes various class variables with data like month names and numbers of days in each month.
12 virtualmachine
This document discusses virtual machines and their implementation. It begins with an introduction to virtual machines, noting that they provide an abstract computing architecture that supports programming languages in a hardware-independent way. It then outlines the main components of a virtual machine, including the heap store, interpreter, automatic memory management, and threading system. The document dives into more detail on each of these components and also discusses optimizations that can be performed. It concludes by noting that while virtual machines provide benefits like platform independence, there is an overhead to their execution.
Stoop ed-inheritance composition
The document discusses different approaches to structuring code for a text formatting editor, including inheritance, composition, and delegation. It notes some drawbacks of inheritance like difficulty changing policies at runtime and responsibility not being clear. Composition is recommended instead as it allows changing strategies at runtime, has clear responsibility between components, and avoids code bloat. Delegation to other objects using strategies is given as an example implementation.
10 reflection
Reflection allows programs to examine and modify their own structure and behavior at runtime. The document discusses introspection, which allows observing an object's state, and intercession, which enables modifying execution state. It covers reification, representing runtime concepts as objects, and how this enables metaprogramming to manipulate a running system. Key topics are reflective capabilities in various languages, structural versus behavioral reflection, and how reflection is implemented using metaobjects and metaclasses.
11 bytecode
This document provides an overview of working with bytecode in Pharo. It discusses:
- The Pharo compiler and how it translates code to an abstract syntax tree (AST), intermediate representation (IR), and finally bytecode.
- Generating bytecode using the IRBuilder tool, which allows defining bytecode instructions like stack operations, jumps, sends, and accessing variables.
- Parsing and interpreting bytecode using the InstructionStream hierarchy, which allows analyzing, printing, and decompiling bytecode.
10 - OOP - Inheritance (a)
This document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend existing behavior from their ancestors. Method lookup starts by searching the class of the receiver, then traversing up the inheritance hierarchy if not found. The keyword super sends a message starting the lookup in the superclass of the method's class rather than the receiver's class, allowing overridden methods to invoke the superclass implementation.
Stoop 440-adaptor
The document discusses the adapter design pattern, which allows classes with incompatible interfaces to work together. The adapter pattern involves a target interface that clients expect, an adaptee with a different interface that needs adapting, and an adapter class that converts the adaptee's interface to the target interface. The adapter acts as a bridge between the adaptee and target, allowing the adaptee's functionality to be accessed by clients through the target interface.
10 - OOP - Inheritance (b)
The document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend the behavior of their ancestors. Method lookup starts by searching the class of the receiver, and if not found proceeds to search superclasses. The keyword super represents the receiver but changes the starting point of method lookup to the superclass of the method containing the super expression. This allows methods to invoke behaviors defined in their parent classes.
08 refactoring
This document provides an overview of refactoring and design patterns. It begins with some principles of object-oriented design like the open-closed principle. It then defines refactoring as changing code without altering external behavior to improve structure. Common code smells that indicate needs for refactoring are described, like duplicated code. The document outlines the Law of Demeter and provides examples of violations. It concludes by introducing design patterns and focusing on the singleton pattern.
5 - OOP - Smalltalk in a Nutshell (c)
Smalltalk has a uniform object model where everything is an object. There is only one mechanism of message passing between objects. Inheritance is single between classes. Classes are also objects that are instances of other metaclasses. Method lookup follows a single mechanism by looking for methods in the class of the receiver.
14 - Exceptions
Exception handling in Smalltalk involves catching exceptions using an "on:do:" block. The document discusses the standardization of exceptions in 1996, the predefined exception classes like Error and Notification, and how to catch, signal, and handle exceptions in code. It also covers exception sets, the exception environment, and different ways exceptions can be handled or exited from including resume, return, retry, and resignalAs:.
Stoop 416-lsp
This document discusses the Liskov Substitution Principle (LSP) using simple Bag and Set data types as examples. It shows that while a Bag and Set may have similar interfaces, with both accepting put and count messages, a Set cannot be substituted for a Bag or vice versa without violating the contracts of functions defined for those types. Specifically, passing a Set to a function expecting a Bag could result in an unexpected return value, breaking the function. Similarly, passing a Bag to a function expecting a Set could return a value greater than the promised return of 1. Therefore, according to LSP, neither Bag nor Set can be considered subtypes of the other.
Stoop ed-frameworks
This document discusses frameworks and compares them to libraries. Frameworks define the overall architecture and flow of a program, while libraries are called by a program to extend their functionality. Frameworks work by calling methods defined in subclasses, following a predefined interaction and flow. Libraries are called by a program and return control back to the program. Frameworks rely on inheritance to allow customization through subclassing, while libraries are customized through composition.
Stoop 303-advanced blocks
The document discusses lexical scoping and returning values in blocks in Smalltalk. It explains that variables in blocks are bound in the context where the block is defined, not where it is evaluated. Continuation blocks can return values to the method that activated the home context. Returning from blocks requires care, as returning from within a block actually returns from the enclosing method. Examples demonstrate block evaluation, scoping, and using continuation blocks to return values or escape block evaluation.
Stoop 301-internal objectstructureinvw
The document discusses the internal structure of objects in VisualWorks Smalltalk. It describes three ways that classes can be created: as non-indexable pointers, indexable pointers, and indexable non-pointers. The formatting of classes in stored in the format instance variable of Behavior objects. This determines whether a class uses pointers, is indexable, fixed, or uses bits to store instances. The size of individual objects depends on factors like whether they are pointers, indexable, and their class and instance variable sizes.
Stoop 423-smalltalk idioms
This document provides guidance on various Smalltalk coding idioms through examples and explanations. It discusses topics such as:
- Using constructor methods to ensure valid object creation
- Defining comparison methods like <= consistently
- Writing query methods instead of exposing internal state
- Structuring methods to perform single identifiable tasks
- Implementing delegation to share behavior without inheritance
- Commenting methods to explain intent not obvious in code
The overall message is to think carefully about interface and implementation choices to write clear, well-structured Smalltalk code based on idioms that have proven useful.
12 - Conditions and Loops
This document discusses core concepts in Smalltalk including conditionals, loops, collections, common object behavior, and copying objects. It covers boolean logic and conditional expressions, the collection hierarchy with 80+ classes including Array, OrderedCollection, Dictionary, and Set. Common methods for collections like do:, select:, collect: are also summarized, as well as printing, reading, copying and notifying objects in the programming environment.
Stoop 400 o-metaclassonly
1. The document discusses the 7 points of metaclasses: every object is an instance of a class, every class inherits from Object, every class is an instance of a metaclass, the metaclass hierarchy parallels the class hierarchy, every metaclass inherits from Class and Behavior, every metaclass is an instance of Metaclass, and the metaclass of Metaclass is an instance of Metaclass.
Factory method & strategy pattern
The document describes the Factory Method design pattern. It defines an interface for creating an object, but lets subclasses decide which class to instantiate. This allows a class to instantiate a derivation of another class without knowing the exact class. The document provides an example of using the Factory Method pattern to create different types of database connections at runtime depending on the database type.
Stata Programming Cheat Sheet
Stata cheat sheet: programming. Co-authored with Tim Essam (linkedin.com/in/timessam). See all cheat sheets at http://bit.ly/statacheatsheets. Updated 2016/06/04
More Related Content
Viewers also liked
15 - Streams
This document discusses streams in Smalltalk. Streams allow traversal of collections and can be internal or external. Internal streams are associated with Smalltalk collections, while external streams interact with files or other collection-like objects. The document describes the stream classes like read streams, write streams, peekable streams, and positionable streams. It provides examples of using streams to read, write, insert and retrieve elements.
Stoop sed-class initialization
The document discusses class initialization in object-oriented programming. It explains that class initialization is used to initialize class variables and instance variables when a class is loaded. The class initialization method, which in Squeak is named 'initialize', is automatically called by the system at load time or can be explicitly called by the programmer. It provides an example of a Date class initialization method that initializes various class variables with data like month names and numbers of days in each month.
12 virtualmachine
This document discusses virtual machines and their implementation. It begins with an introduction to virtual machines, noting that they provide an abstract computing architecture that supports programming languages in a hardware-independent way. It then outlines the main components of a virtual machine, including the heap store, interpreter, automatic memory management, and threading system. The document dives into more detail on each of these components and also discusses optimizations that can be performed. It concludes by noting that while virtual machines provide benefits like platform independence, there is an overhead to their execution.
Stoop ed-inheritance composition
The document discusses different approaches to structuring code for a text formatting editor, including inheritance, composition, and delegation. It notes some drawbacks of inheritance like difficulty changing policies at runtime and responsibility not being clear. Composition is recommended instead as it allows changing strategies at runtime, has clear responsibility between components, and avoids code bloat. Delegation to other objects using strategies is given as an example implementation.
10 reflection
Reflection allows programs to examine and modify their own structure and behavior at runtime. The document discusses introspection, which allows observing an object's state, and intercession, which enables modifying execution state. It covers reification, representing runtime concepts as objects, and how this enables metaprogramming to manipulate a running system. Key topics are reflective capabilities in various languages, structural versus behavioral reflection, and how reflection is implemented using metaobjects and metaclasses.
11 bytecode
This document provides an overview of working with bytecode in Pharo. It discusses:
- The Pharo compiler and how it translates code to an abstract syntax tree (AST), intermediate representation (IR), and finally bytecode.
- Generating bytecode using the IRBuilder tool, which allows defining bytecode instructions like stack operations, jumps, sends, and accessing variables.
- Parsing and interpreting bytecode using the InstructionStream hierarchy, which allows analyzing, printing, and decompiling bytecode.
10 - OOP - Inheritance (a)
This document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend existing behavior from their ancestors. Method lookup starts by searching the class of the receiver, then traversing up the inheritance hierarchy if not found. The keyword super sends a message starting the lookup in the superclass of the method's class rather than the receiver's class, allowing overridden methods to invoke the superclass implementation.
Stoop 440-adaptor
The document discusses the adapter design pattern, which allows classes with incompatible interfaces to work together. The adapter pattern involves a target interface that clients expect, an adaptee with a different interface that needs adapting, and an adapter class that converts the adaptee's interface to the target interface. The adapter acts as a bridge between the adaptee and target, allowing the adaptee's functionality to be accessed by clients through the target interface.
10 - OOP - Inheritance (b)
The document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend the behavior of their ancestors. Method lookup starts by searching the class of the receiver, and if not found proceeds to search superclasses. The keyword super represents the receiver but changes the starting point of method lookup to the superclass of the method containing the super expression. This allows methods to invoke behaviors defined in their parent classes.
08 refactoring
This document provides an overview of refactoring and design patterns. It begins with some principles of object-oriented design like the open-closed principle. It then defines refactoring as changing code without altering external behavior to improve structure. Common code smells that indicate needs for refactoring are described, like duplicated code. The document outlines the Law of Demeter and provides examples of violations. It concludes by introducing design patterns and focusing on the singleton pattern.
5 - OOP - Smalltalk in a Nutshell (c)
Smalltalk has a uniform object model where everything is an object. There is only one mechanism of message passing between objects. Inheritance is single between classes. Classes are also objects that are instances of other metaclasses. Method lookup follows a single mechanism by looking for methods in the class of the receiver.
14 - Exceptions
Exception handling in Smalltalk involves catching exceptions using an "on:do:" block. The document discusses the standardization of exceptions in 1996, the predefined exception classes like Error and Notification, and how to catch, signal, and handle exceptions in code. It also covers exception sets, the exception environment, and different ways exceptions can be handled or exited from including resume, return, retry, and resignalAs:.
Stoop 416-lsp
This document discusses the Liskov Substitution Principle (LSP) using simple Bag and Set data types as examples. It shows that while a Bag and Set may have similar interfaces, with both accepting put and count messages, a Set cannot be substituted for a Bag or vice versa without violating the contracts of functions defined for those types. Specifically, passing a Set to a function expecting a Bag could result in an unexpected return value, breaking the function. Similarly, passing a Bag to a function expecting a Set could return a value greater than the promised return of 1. Therefore, according to LSP, neither Bag nor Set can be considered subtypes of the other.
Stoop ed-frameworks
This document discusses frameworks and compares them to libraries. Frameworks define the overall architecture and flow of a program, while libraries are called by a program to extend their functionality. Frameworks work by calling methods defined in subclasses, following a predefined interaction and flow. Libraries are called by a program and return control back to the program. Frameworks rely on inheritance to allow customization through subclassing, while libraries are customized through composition.
Stoop 303-advanced blocks
The document discusses lexical scoping and returning values in blocks in Smalltalk. It explains that variables in blocks are bound in the context where the block is defined, not where it is evaluated. Continuation blocks can return values to the method that activated the home context. Returning from blocks requires care, as returning from within a block actually returns from the enclosing method. Examples demonstrate block evaluation, scoping, and using continuation blocks to return values or escape block evaluation.
Stoop 301-internal objectstructureinvw
The document discusses the internal structure of objects in VisualWorks Smalltalk. It describes three ways that classes can be created: as non-indexable pointers, indexable pointers, and indexable non-pointers. The formatting of classes in stored in the format instance variable of Behavior objects. This determines whether a class uses pointers, is indexable, fixed, or uses bits to store instances. The size of individual objects depends on factors like whether they are pointers, indexable, and their class and instance variable sizes.
Stoop 423-smalltalk idioms
This document provides guidance on various Smalltalk coding idioms through examples and explanations. It discusses topics such as:
- Using constructor methods to ensure valid object creation
- Defining comparison methods like <= consistently
- Writing query methods instead of exposing internal state
- Structuring methods to perform single identifiable tasks
- Implementing delegation to share behavior without inheritance
- Commenting methods to explain intent not obvious in code
The overall message is to think carefully about interface and implementation choices to write clear, well-structured Smalltalk code based on idioms that have proven useful.
12 - Conditions and Loops
This document discusses core concepts in Smalltalk including conditionals, loops, collections, common object behavior, and copying objects. It covers boolean logic and conditional expressions, the collection hierarchy with 80+ classes including Array, OrderedCollection, Dictionary, and Set. Common methods for collections like do:, select:, collect: are also summarized, as well as printing, reading, copying and notifying objects in the programming environment.
Stoop 400 o-metaclassonly
1. The document discusses the 7 points of metaclasses: every object is an instance of a class, every class inherits from Object, every class is an instance of a metaclass, the metaclass hierarchy parallels the class hierarchy, every metaclass inherits from Class and Behavior, every metaclass is an instance of Metaclass, and the metaclass of Metaclass is an instance of Metaclass.
Viewers also liked (20)
Similar to Stoop 436-strategy
Factory method & strategy pattern
The document describes the Factory Method design pattern. It defines an interface for creating an object, but lets subclasses decide which class to instantiate. This allows a class to instantiate a derivation of another class without knowing the exact class. The document provides an example of using the Factory Method pattern to create different types of database connections at runtime depending on the database type.
Stata Programming Cheat Sheet
Stata cheat sheet: programming. Co-authored with Tim Essam (linkedin.com/in/timessam). See all cheat sheets at http://bit.ly/statacheatsheets. Updated 2016/06/04
Stata cheatsheet programming
This document provides a summary of programming commands and techniques in Stata. It discusses loops, macros, scalars, matrices, and accessing estimation results. Key commands covered include foreach, forvalues, levelsof, return, ereturn, estimates, matrix, scalar, global. The document is intended as a cheat sheet for common Stata programming tasks.
Csharp generics
Generics allow classes and methods to work with any data type by using substitute parameters for the data types. This delays specifying the actual data type until the class or method is used. The document provides an example of a generic class MyGenericArray that can store and retrieve values of any data type. It also demonstrates a generic method Swap that can swap values of any data type and a generic delegate that handles methods with a type parameter.
What's New in DITA 1.3
What’s new in DITA 1.3?
by Yas Etessam, DITA Consultant and Leigh White, DITA Specialist at IXIASOFT
Come and learn about the new proposed DITA 1.3 features. Leigh and Yas will provide an overview of the new architectural features including extensions to the DITA core vocabulary, Online Help vocabularies, scoped keys, branched filtering and enhancements to the Learning and Training, Troubleshooting and Table specializations.
Anais Dotis-Georgiou & Faith Chikwekwe [InfluxData] | Top 10 Hurdles for Flux...
This document discusses top hurdles for Flux beginners and provides solutions. It covers 10 hurdles: 1) Overlooking UI tools for writing Flux, 2) Misunderstanding annotated CSVs, 3) Data layout design leading to high cardinality, 4) Storing wrong data in InfluxDB, 5) Confusion about projecting multiple aggregations, 6) Unfamiliarity with common Flux packages and functions, 7) Unawareness of performance optimizations, 8) Improper use of schema mutations, 9) Knowing when to write custom tasks, and 10) Not understanding when and why to downsample data. For each hurdle, it provides explanations and code examples to illustrate solutions.
PATTERNS04 - Structural Design Patterns
An introduction to structural design patterns in object orientation. Suitable for intermediate to advanced computing students and those studying software engineering.
R studio
This document provides an overview and introduction to using the statistical software R. It outlines R's interface, workspace, help system, packages, input/output functions, and how to reuse results. It also discusses downloading and installing R, basic functions and syntax, data manipulation techniques like sorting and merging, creating graphs, and performing statistical analyses such as t-tests, regression, ANOVA, and multiple comparisons. The document recommends several tutorials that provide more in-depth information on using R for statistical modeling, data analysis, and graphics.
Anything but simple Mathematica
Wolfram Research created Mathematica, one of the most powerful computer algebra systems, to fulfill Stephen Wolfram's vision of a universal mathematical kernel. Mathematica allows analytical and numerical calculations, 2D and 3D graphics, and includes a powerful programming language. While initially designed for mathematical applications, Mathematica is now used for simulation, modeling, visualization, documentation, and more.
Design patterns
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This allows different variants of an algorithm to be used by an object through composition rather than inheritance. The Strategy pattern was illustrated using different line breaking strategies that could be used by a Composition class, with each strategy implemented in its own class that inherits from an abstract Strategy interface. This provides flexibility to choose different line breaking algorithms without changing the Composition class.
4 R Tutorial DPLYR Apply Function
- Apply functions in R are used to apply a specified function to each column or row of R objects. Common apply functions include apply(), lapply(), sapply(), tapply(), vapply(), and mapply().
- The dplyr package is a powerful R package for data manipulation. It provides verbs like select(), filter(), arrange(), mutate(), and summarize() to work with tabular data.
- Functions like apply(), lapply(), sapply() apply a function over lists or matrices. Arrange() reorders data, mutate() adds new variables, and summarize() collapses multiple values into single values.
Mis presentation
This document provides an introduction and overview of Graphite-Tattle, an open source tool for self-service alerting and dashboards for Graphite and Ganglia. It discusses key concepts like checks, subscriptions, alerts and dashboards. It also covers installation requirements and steps, configuration, usage of clean URLs for dashboards, integrating HTTP authentication, the motivation for its creation and goals for Graphite-Tattle.
Stoop ed-some principles
The document discusses several principles of software design including:
1) The open-closed principle which states that code should be open for extension but closed for modification.
2) The dependency inversion principle which states that high level modules should not depend on low level modules and both should depend on abstractions.
3) The interface segregation principle which states that dependencies should depend on the smallest possible interface to avoid "fat" interfaces.
4) The acyclic dependency principle which states that dependency structures between packages should not contain cyclic dependencies.
An Introduction to MATLAB with Worked Examples
Basic introduction. Contains several worked examples to practice. Convenient index is provided to locate example code.
Design Pattern(decorator design pattern) and anti pattern
The Decorator pattern allows behavior to be added to individual objects dynamically at runtime without affecting other objects. This provides a flexible alternative to subclassing for extension. The pattern attaches additional responsibilities to an object dynamically through the composition of objects. For example, borders, scrollbars or other behaviors could be added to a text view component through multiple Decorator classes rather than requiring a large number of subclasses through inheritance. While this adds flexibility, Decorators are not identical to the component from an object identity perspective.
SICP_2.5 일반화된 연산시스템
The document describes a generic arithmetic system that allows uniform access to number packages with different data representations. It defines generic arithmetic procedures like add, sub, mul, and div that apply the corresponding operation for the specific number package. A scheme-number package for integer arithmetic is also installed. Generic tags are attached to values to identify their representation, and a mapping table is used to dispatch operations to appropriate handler procedures based on tags.
Reproducibility with R
This document discusses ways to make R code more reproducible through cleaner coding practices, functional programming, and collaboration tools. It recommends:
1. Writing cleaner code through descriptive names, spacing, and documentation.
2. Functionalizing code by defining reusable functions to avoid repetition and improve flexibility.
3. Using pipes to chain together functions and solve complex problems through simple pieces.
4. Outsourcing functions to external files and version controlling code with Git and GitHub to enable collaboration.
Introduction To TensorFlow | Deep Learning Using TensorFlow | TensorFlow Tuto...
In this TensorFlow tutorial, you will be learning all the basics of TensorFlow and how to create a Deep Learning Model. It includes the following topics:
1. Deep Learning vs Machine Learning
2. What is TensorFlow?
3. TensorFlow Use-Case
Android App Development - 11 Lists, grids, adapters, dialogs and toasts
The document discusses different Android UI components including list views, grid views, adapters, dialogs, and toasts. It explains that list views and grid views display data from arrays or cursors using adapters. Adapters define how data is inserted and each element is displayed. Common adapter classes include ArrayAdapter, SimpleAdapter, and CursorAdapter. Dialogs create popup windows to prompt users for input. Standard dialogs include AlertDialog, DatePickerDialog, and ProgressDialog. Toasts briefly display short non-interactive messages on screen.
Factory method, strategy pattern & chain of responsibilities
The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. It provides a way to delegate instantiation to subclasses by defining a factory method that returns an object of a product class. The Strategy pattern defines a family of algorithms, puts each of them in a separate class, and makes their objects interchangeable. Context uses a Strategy object to perform an algorithm without knowing its concrete class. The Proxy pattern provides a surrogate or placeholder for another object to control access to it. It protects the real subject object and controls its access.
Similar to Stoop 436-strategy (20)
Anais Dotis-Georgiou & Faith Chikwekwe [InfluxData] | Top 10 Hurdles for Flux...
Anais Dotis-Georgiou & Faith Chikwekwe [InfluxData] | Top 10 Hurdles for Flux...
Design Pattern(decorator design pattern) and anti pattern
Design Pattern(decorator design pattern) and anti pattern
Introduction To TensorFlow | Deep Learning Using TensorFlow | TensorFlow Tuto...
Introduction To TensorFlow | Deep Learning Using TensorFlow | TensorFlow Tuto...
Android App Development - 11 Lists, grids, adapters, dialogs and toasts
Android App Development - 11 Lists, grids, adapters, dialogs and toasts
Factory method, strategy pattern & chain of responsibilities
Factory method, strategy pattern & chain of responsibilities
More from The World of Smalltalk
05 seaside canvas
The document describes brush hierarchies and attributes for canvas and tags in HTML. It defines hierarchies for canvas, brushes and tags. It lists the factory selector, brush class and attribute accessors for various tag brushes. This includes div, fieldset, form inputs, buttons, tables and other tags. It provides the classes and methods to represent and manipulate these elements when building HTML documents.
99 questions
This document provides an overview of the key concepts in the Smalltalk programming language. It discusses how Smalltalk is a fully reflective, dynamic object-oriented programming environment. Smalltalk uses a simple uniform object model that allows for live, dynamic and interactive software development. The document outlines various Smalltalk basics like syntax, standard classes, coding idioms, debugging practices, design patterns and more. It also covers advanced topics like reflection and how the Smalltalk meta-model is reified through reflection.
13 traits
This document provides an overview of traits in programming. It discusses the limitations of single and multiple inheritance, as well as mixins. Traits are introduced as a way to share behavior across class hierarchies without these issues. Key points about traits are that they provide methods but no state, and classes have full control over trait composition. The document also presents a case study on refactoring stream classes using traits for improved reuse and design. It concludes with discussion on the implementation of traits in Pharo and potential future directions.
09 metaclasses
1. The document discusses metaclasses in Smalltalk and provides 7 key points about their structure and relationships.
2. Every class is an instance of a metaclass, and the metaclass hierarchy parallels the class hierarchy. The metaclass of every class inherits from Class.
3. Metaclasses inherit from Class and Behavior. The Metaclass represents metaclass behavior and its sole instance is the metaclass of every class.
06 debugging
The document provides guidance on debugging in Smalltalk. It discusses common syntactic, semantic, and encapsulation errors. It also covers debugging patterns such as using print statements, tests, inspectors, breakpoints, and debuggers to debug code. The document emphasizes that the debugger, inspector, browser, and message name finder are useful debugging tools and that tests are important to prevent regressions when debugging. It also notes some best practices like avoiding modifying collections during iteration, using accessors to encapsulate state, and not referencing class names directly.
05 seaside
This document provides an overview of the Seaside web application framework. It discusses key Seaside concepts like components, control flow, composition, and more. The document contains lecture notes on Seaside, including roadmaps, explanations of concepts, code examples, and screenshots.
04 idioms
This document discusses Smalltalk coding idioms and best practices. It covers topics like:
- Using cascades and the "yourself" message to chain messages to the same receiver.
- Distributing responsibilities across many small, carefully named methods to promote reuse and maintainability.
- Techniques for initializing objects, establishing class invariants, and representing instance creation.
- Debugging techniques like printing an object's state.
The document provides code examples and explanations for common patterns in Smalltalk, such as initializing instance variables, creating collection objects, and defining constructor and accessor methods. It is intended as a guide for writing well-structured and maintainable Smalltalk code.
03 standardclasses
The document discusses Smalltalk standard classes. It covers the Object class which defines common behavior for all objects. Number classes are described, including automatic coercion between types. Strings and arrays are also covered, including literal and regular array creation. Variable types like global, instance, and block variables are explained. Control structures are implemented through message passing and blocks. Various collection classes are introduced at the end.
02 basics
Smalltalk is an object-oriented programming language where everything is an object and communication is done through message passing. The document discusses Smalltalk basics including its syntax, variables, methods, blocks, control structures and more. It provides a roadmap for learning Smalltalk and examples to illustrate Smalltalk concepts.
01 intro
This document provides an introduction to the Smalltalk programming language and environment. It outlines the course schedule and goals, which include learning about Smalltalk's history and object-oriented model, as well as concepts like classes, metaclasses, reflection, and advanced design patterns. The document discusses Smalltalk's origins at Xerox PARC and the key ideas it was influenced by. It also describes Smalltalk's pure object model where everything is an object that communicates through message passing. Finally, it provides an overview of the Smalltalk development environment and tools like the browser, debugger, and inspector.
Stoop sed-smells
This document discusses several basic design principles and smells:
- A class should have a single responsibility and minimize access to its data.
- Inheritance should represent an "is-a" relationship, not be used for implementation convenience.
- Methods should not expose implementation details and overuse of conversions should be avoided.
- Missing information should be handled gracefully rather than raising errors.
- Nil values should be avoided by returning empty collections instead.
- Objects rather than strings or tuples should be used to represent data.
- The tell-don't-ask principle of using polymorphism rather than conditionals on types should be followed.
- Encapsulation should be maintained by not overusing accessors and
Stoop sed-sharing ornot
The document discusses the design of the Scanner class in Smalltalk. It summarizes that the Scanner class has an instance variable (typeTable) and a class variable (TypeTable) that both refer to the type table object. The class variable TypeTable is used to initialize the type table once, while each scanner instance uses its own typeTable variable that can be customized if needed. This allows the type table to be shared and initialized only once, while also allowing instances to customize it if they want via copying the table.
Stoop sed-class initialization
The document discusses class initialization in object-oriented programming. It explains that class initialization is used to initialize class variables and instance variables when a class is loaded. The class initialization method, typically named "initialize", is automatically called by the system and can be used to set up default values for properties that are shared across all class instances. The document provides an example Date class that defines various class variables for storing things like month names and days in a month, and initializes these values in its Date class>>initialize method.
Stoop metaclasses
The document discusses metaclasses in Smalltalk. Some key points:
1. Every class is an instance of a metaclass. The metaclass hierarchy parallels the class hierarchy.
2. Metaclasses inherit from Class and Behavior. Every metaclass is an instance of Metaclass.
3. The metaclass of Metaclass is also an instance of Metaclass, completing the metaclass hierarchy.
Stoop ed-subtyping subclassing
This document discusses the differences between subclassing and subtyping in object-oriented design. It explains that subclassing is using inheritance primarily for code reuse, even if the subclass interface is not compatible with the superclass interface. Subtyping uses inheritance to reuse interface specifications so that subclasses are substitutable for their superclasses. The document recommends favoring subtyping over subclassing for reusable software since it leads to more understandable class relationships based on interfaces rather than implementation.
Stoop ed-class forreuse
This document discusses principles of object-oriented design, including:
1. Parametrizing code to avoid hardcoding constants and allow runtime changes without recompilation.
2. Defining behavior independently of state through abstract state and message layers.
3. Dividing programs into short, single-purpose methods to improve readability, reuse, and maintenance.
More from The World of Smalltalk (16)
Recently uploaded
Driving Business Innovation: Latest Generative AI Advancements & Success Story
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
Columbus Data & Analytics Wednesdays - June 2024
Columbus Data & Analytics Wednesdays, June 2024 with Maria Copot 20
20240607 QFM018 Elixir Reading List May 2024
Everything I found interesting about the Elixir programming ecosystem in May 2024
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on integration of Salesforce with Bonterra Impact Management.
Interested in deploying an integration with Salesforce for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
みなさんこんにちはこれ何文字まで入るの？40文字以下不可とか本当に意味わからないけどこれ限界文字数書いてないからマジでやばい文字数いけるんじゃないの？えこ...
ここ3000字までしか入らないけどタイトルの方がたくさん文字入ると思います。
Programming Foundation Models with DSPy - Meetup Slides
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Skybuffer SAM4U tool for SAP license adoption
Manage and optimize your license adoption and consumption with SAM4U, an SAP free customer software asset management tool.
SAM4U, an SAP complimentary software asset management tool for customers, delivers a detailed and well-structured overview of license inventory and usage with a user-friendly interface. We offer a hosted, cost-effective, and performance-optimized SAM4U setup in the Skybuffer Cloud environment. You retain ownership of the system and data, while we manage the ABAP 7.58 infrastructure, ensuring fixed Total Cost of Ownership (TCO) and exceptional services through the SAP Fiori interface.
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
HCL Notes and Domino License Cost Reduction in the World of DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
AI 101: An Introduction to the Basics and Impact of Artificial Intelligence
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
TrustArc Webinar - 2024 Global Privacy Survey
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Recently uploaded (20)
Driving Business Innovation: Latest Generative AI Advancements & Success Story
Driving Business Innovation: Latest Generative AI Advancements & Success Story
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Nordic Marketo Engage User Group_June 13_ 2024.pptx
Nordic Marketo Engage User Group_June 13_ 2024.pptx
みなさんこんにちはこれ何文字まで入るの？40文字以下不可とか本当に意味わからないけどこれ限界文字数書いてないからマジでやばい文字数いけるんじゃないの？えこ...
みなさんこんにちはこれ何文字まで入るの？40文字以下不可とか本当に意味わからないけどこれ限界文字数書いてないからマジでやばい文字数いけるんじゃないの？えこ...
Programming Foundation Models with DSPy - Meetup Slides
Programming Foundation Models with DSPy - Meetup Slides
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift.pdf
HCL Notes and Domino License Cost Reduction in the World of DLAU
HCL Notes and Domino License Cost Reduction in the World of DLAU
AI 101: An Introduction to the Basics and Impact of Artificial Intelligence
AI 101: An Introduction to the Basics and Impact of Artificial Intelligence
Stoop 436-strategy
- 1. Stéphane Ducasse 1 Stéphane Ducasse stephane.ducasse@inria.fr http://stephane.ducasse.free.fr/ Strategy
- 2. S.Ducasse 2 Strategy Define a family of algorithms, encapsulate each in a separate class and define each class with the same interface so that they can be interchangeable. Also Know as Policy
- 3. S.Ducasse 3 Strategy Intent Define a family of algorithms, encapsulate each in a separate class and define each class with the same interface so that they can be interchangeable.
- 4. S.Ducasse 4 Motivation Many algorithms exist for breaking a stream into lines. Hardwiring them into the classes that requires them has the following problems: Clients get more complex Different algorithms can be used at different times Difficult to add new algorithms at run-time
- 5. S.Ducasse 5 Code Smells Composition>>repair formatting == #Simple ifTrue: [ self formatWihtSimpleAlgo] ifFalse: [ formatting == #Tex ifTrue: [self formatWithTex] ....]
- 6. S.Ducasse 6 Alternative Composition>>repair | selector | selector := (‘formatWith, formatting) asSymbol. self perform: selector Still your class gets complex...
- 7. S.Ducasse 7 Inheritance? May not be the solution since: - you have to create objects of the right class - it is difficult to change the policy at run-time - you can get an explosion of classes bloated with the use of a functionality and the functionalities. - no clear identification of responsibility
- 9. S.Ducasse 9 When Many related classes differ only in their behavior You have variants of an algorithm (space/time) An algorithm uses data that the clients does not have to know
- 11. S.Ducasse 11 Participants Strategy (Compositor) declares an interface common to all concrete strategies Concrete Strategies implement algorithm Context configure with concrete strategy maintains a reference to the concrete strategy may define an interface to let the strategy access data
- 12. S.Ducasse 12 Collaborations (i) Strategy and Context interact to implement the chosen algorithm. A context may pass all data required by the algorithm to the strategy when the algorithm is called GraphVisualizer>>graphIt .... grapher plot: data using: graphPane pen Grapher>>plot: data using: aPen
- 13. S.Ducasse 13 Context passes itself as argument Also know as self-delegation... GraphVisualizer>>graphIt grapher plotFor: self BartChartGrapher>>plotFor: aGraphVisualizer |data| data := aGraphVisualizer data ....
- 14. S.Ducasse 14 BackPointer Grapher class>>for: aGraphVisualizer ^ self new graphVisualizer: aGraphVisualizer BartChartGrapher>>plot ... graphVisualizer data.. graphVisualizer pen Grapher (Strategy) points directly to GraphVisualizer (Context), so sharing strategy between different context may be difficult, if sharing is needed then use self-delegation
- 15. S.Ducasse 15 Collaboration (ii) “A context forwards requests from its clients to its strategy. Clients usually create and pass a ConcreteStrategy object to the context; thereafter, clients interact with the context exclusively.“ GOF Not sure that the client has to choose...
- 16. S.Ducasse 16 Consequences Define a family of pluggable algorithms Eliminates conditional statements Clients can choose between several implementations Clients must be aware of the different strategies Increase the number of objects Communication overhead between client and strategies Weaken encapsulation of the client
- 17. S.Ducasse 17 Domain-Specific Objects as Strategies Strategies do not have to be limited to one single algorithm They may represent domain specific knowledge Mortgage FixedRateMortgage OneYear...
- 18. S.Ducasse 18 Known Uses ImageRenderer inVW: “a technique to render an image using a limited palette” ImageRenderer NearestPaint OrderedDither ErrorDiffusion View-Controller a view instance uses a controller object to handle and respond to user input via mouse or keyboard. Controllers can be changed at run-time