A design pattern is a general repeatable solution to a commonly occurring problem in software design. They make your code scalable, robust and easy for developers to learn. The three categories - Creational, Structural and Behavioral. A major look through of the Scala specific design patterns such as the Lens pattern, duck typing, memoization, etc. These patterns let you explore the features of Scala and use a design pattern using those features which can help you solve your different use cases.

1. Presented By: Vidisha Gupta (Software Consultant @ Knoldus)
Design Patterns
In Scala

2. Agenda
01 What are Design Patterns?
02
Why do we need design
patterns?
03 Categories of design
patterns
04 Scala Specific Design
Patterns
Demo
60
6
0404
0
5

3. What are Design Patterns?
Design pattern is a general reusable
solution to a commonly occurring
problem in software design within a
given context.
Design patterns are formalized best
practices that the programmer can
use to solve common problems when
designing an application or system.

4. Example -
Interface Printer{
void print(String text);
}
Class InkjetPrinter implements Printer {
void print(String text){
// spray ink to the paper, roll the paper etc.
}
}
Printer ticketPrinter = new InkjetPrinter();
Printer ticketPrinter = PrinterFactory.createPrinter("Laser");

5. What do we need design patterns?
● Scalable
● Stable
● Highly cohesive modules
● Minimal coupling
● Communication between
designers more efficient
● Give the developer a selection
of tried and tested solutions to
work with
● Language neutral

6. Categories of Design Patterns

7. Creational Design Pattern
The creational patterns aim to separate a system from how its
objects are created, composed, and represented. They increase
the system's flexibility in terms of the what, who, how, and when of
object creation.
The main ideas behind the creational design patterns are as
follows:
● Knowledge encapsulation about the concrete classes
● Hiding details about the actual creation and how objects are
combined

8. Structural Design Pattern
Design patterns that ease the design by identifying a simple
way to realize relationships among entities.
The main features of structural design patterns include the
following:
● The use of composition to combine the implementations of
multiple objects
● Help build a large system made of various components by
maintaining a high level of flexibility

9. Behavioral Design Pattern
Design patterns that identify common communication patterns
among objects and realize these patterns.
The main features of behavioral design patterns are as follows:
● What is being described is a process or flow
● The flows are simplified and made understandable
● They accomplish tasks that would be difficult or impossible to
achieve with objects

10. Scala Specific Design Patterns
● The Lens Pattern
● Duck Typing
● Memoization
● Pimp Library
● Stackable Traits
● The cake pattern
● Lazy evaluation
● The type class design pattern
● Partial functions
● Implicit Injection

11. The Lens Pattern
A Lens is an abstraction from
functional programming which
helps to deal with a problem of
updating complex immutable
nested objects.

12. Available implementations
There are several implementations in scala:
● scalaz.Lens - if you already have scalaz in a project and
you are not bothered to write some code in order to define
lens
● Quicklens - easy to use and powerful enough to deal with
the described problem
● Sauron - very similar to Quicklens and has a less size but
also has less functionality
● Monocle - a powerful library which can help if there is
necessity to use lots of lens in a code.

13. Duck Typing
● Duck Typing is a way of
programming in which an object
passed into a function or method
supports all method signatures
and attributes expected of that
object at run time.
● It allows developers to write
code that requires the callers to
have some specific methods (but
not implement an interface)

14. Pimp my Library
● It provides a way to write
extension methods for libraries,
which we cannot modify.
● It also helps to achieve better
code readability.
● Less boiler plate code than
adhoc version

15. Stackable Traits
● Stackable traits is the Scala way to
implement the decorator design
pattern.
● It involves decoration for the
purpose of class composition
instead of object composition.
● Stackable traits decorate the core
traits at compile time, similar to the
way decorator objects modify core
objects at run time in the decorator
pattern.

16. Memoization
Memoization is an optimization
technique of caching the output of
an expensive function for a
particular input and then returning
the cached result if the function is
called again with the same input
parameters.

17. References
● https://github.com/nikolovivan/scala-design-
patterns/tree/master/functional-design-patterns
● https://learning.oreilly.com/library/view/scala-design-
patterns/9781788471305/341918fe-9b85-4246-b062-
a17e9fa17b38.xhtml

18. Thank You !