Scala design patterns :: design modular, clean, and scalable applications by applying proven design patterns in Scala /
Design patterns make developers' lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. In this book, you'll learn about the various features of Scala and will be able to apply well-known, industry-p...
Saved in:
| Main Author: | |
|---|---|
| Format: | Electronic eBook |
| Language: | English |
| Published: |
Birmingham, UK :
Packt Publishing,
2018.
|
| Edition: | Second edition. |
| Subjects: | |
| Online Access: | DE-862 DE-863 |
| Summary: | Design patterns make developers' lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. In this book, you'll learn about the various features of Scala and will be able to apply well-known, industry-proven design patterns in your work. |
| Item Description: | Previous edition published: 2016. |
| Physical Description: | 1 online resource (1 volume) : illustrations |
| ISBN: | 1788472098 9781788472098 |
Staff View
MARC
| LEADER | 00000cam a2200000 i 4500 | ||
|---|---|---|---|
| 001 | ZDB-4-EBA-on1035423272 | ||
| 003 | OCoLC | ||
| 005 | 20250103110447.0 | ||
| 006 | m o d | ||
| 007 | cr unu|||||||| | ||
| 008 | 180511s2018 enka o 000 0 eng d | ||
| 040 | |a UMI |b eng |e rda |e pn |c UMI |d STF |d OCLCF |d TOH |d CEF |d DEBBG |d G3B |d UAB |d RDF |d N$T |d OCLCQ |d OCLCO |d OCLCQ |d OCLCO |d SFB | ||
| 020 | |a 1788472098 | ||
| 020 | |a 9781788472098 |q (electronic bk.) | ||
| 020 | |z 9781788471305 | ||
| 035 | |a (OCoLC)1035423272 | ||
| 037 | |a CL0500000963 |b Safari Books Online | ||
| 050 | 4 | |a QA76.73.S28 | |
| 082 | 7 | |a 005.114 |2 23 | |
| 049 | |a MAIN | ||
| 100 | 1 | |a Nikolov, Ivan, |e author. | |
| 245 | 1 | 0 | |a Scala design patterns : |b design modular, clean, and scalable applications by applying proven design patterns in Scala / |c Ivan Nikolov. |
| 250 | |a Second edition. | ||
| 264 | 1 | |a Birmingham, UK : |b Packt Publishing, |c 2018. | |
| 300 | |a 1 online resource (1 volume) : |b illustrations | ||
| 336 | |a text |b txt |2 rdacontent | ||
| 337 | |a computer |b c |2 rdamedia | ||
| 338 | |a online resource |b cr |2 rdacarrier | ||
| 588 | 0 | |a Online resource; title from title page (Safari, viewed May 10, 2018). | |
| 500 | |a Previous edition published: 2016. | ||
| 505 | 0 | |a Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: The Design Patterns Out There and Setting Up Your Environment -- Design patterns -- Scala and design patterns -- The need for design patterns and their benefits -- Design pattern categories -- Creational design patterns -- The abstract factory design pattern -- The factory method design pattern -- The lazy initialization design pattern -- The singleton design pattern -- The object pool design pattern -- The builder design pattern -- The prototype design pattern -- Structural design patterns -- The adapter design pattern -- The decorator design pattern -- The bridge design pattern -- The composite design pattern -- The facade design pattern -- The flyweight design pattern -- The proxy design pattern -- Behavioral design patterns -- The value object design pattern -- The null object design pattern -- The strategy design pattern -- The command design pattern -- The chain of responsibility design pattern -- The interpreter design pattern -- The iterator design pattern -- The mediator design pattern -- The memento design pattern -- The observer design pattern -- The state design pattern -- The template method design pattern -- The visitor design pattern -- Functional design patterns -- Monoids -- Monads -- Functors -- Scala-specific design patterns -- The lens design pattern -- The cake design pattern -- Pimp my library -- Stackable traits -- The type class design pattern -- Lazy evaluation -- Partial functions -- Implicit injection -- Duck typing -- Memoization -- Choosing a design pattern -- Setting up the development environment -- Installing Scala -- Tips for installing Scala manually -- Tips for installing Scala using SBT -- Scala IDEs -- Dependency management -- SBT -- Maven -- SBT versus Maven -- Summary. | |
| 505 | 8 | |a Chapter 2: Traits and Mixin Compositions -- Traits -- Traits as interfaces -- Mixing in traits with variables -- Traits as classes -- Extending classes -- Extending traits -- Mixin compositions -- Mixing traits in -- Composing -- Composing simple traits -- Composing complex traits -- Composing with self-types -- Clashing traits -- Same signatures and return types -- Same signatures and different return types traits -- Same signatures and return types mixins -- Same signatures and different return types mixins -- Multiple inheritance -- The diamond problem -- The limitations -- Linearization -- Rules of inheritance hierarchies -- Linearization rules -- How linearization works -- Initialization -- Method overriding -- Testing traits -- Using a class -- Mixing the trait in -- Mixing into the test class -- Mixing into the test cases -- Running the tests -- Traits versus classes -- Summary -- Chapter 3: Unification -- Functions and classes -- Functions as classes -- Function literals -- Functions without syntactic sugar -- Increased expressivity -- Algebraic data types and class hierarchies -- ADTs -- Sum ADTs -- Product ADTs -- Hybrid ADTs -- The unification -- Pattern matching -- Pattern matching with values -- Pattern matching for product ADTs -- Modules and objects -- Using modules -- Summary -- Chapter 4: Abstract and Self Types -- Abstract types -- Generics -- Abstract types -- Generics versus abstract types -- Usage advice -- Polymorphism -- Subtype polymorphism -- Parametric polymorphism -- Ad hoc polymorphism -- Adding functions for multiple types -- Self types -- Using self types -- Requiring multiple components -- Conflicting components -- Self types and the cake design pattern -- Self types versus inheritance -- Inheritance leaking functionality -- Summary -- Chapter 5: Aspect-Oriented Programming and Components -- Aspect-oriented programming. | |
| 505 | 8 | |a Understanding application efficiency -- Timing our application without AOP -- Timing our application with AOP -- Components in Scala -- Using Scala's expressive power to build components -- Implementing components -- Self types for components -- Summary -- Chapter 6: Creational Design Patterns -- What are creational design patterns? -- The factory method design pattern -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- The abstract factory -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- Other factory design patterns -- The static factory -- The simple factory -- Factory combinations -- Lazy initialization -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The singleton design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The builder design pattern -- An example class diagram -- A code example -- A Java-like implementation -- Implementation with a case class -- Using generalized type constraints -- Changing the Person class -- Adding generalized type constraints to the required methods -- Using the type-safe builder -- Using require statements -- What it is good for? -- What it is not so good for? -- The prototype design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- Summary -- Chapter 7 : Structural Design Patterns -- Defining structural design patterns -- The adapter design pattern -- Example class diagram -- Code example -- The adapter design pattern with final classes -- The adapter design pattern the Scala way -- What it is good for -- What it is not so good for -- The decorator design pattern. | |
| 505 | 8 | |a Example class diagram -- Code example -- The decorator design pattern the Scala way -- What it is good for -- What it is not so good for -- The bridge design pattern -- Example class diagram -- Code example -- The bridge design pattern the Scala way -- What it is good for -- What it is not so good for -- The composite design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The facade design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The flyweight design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The proxy design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- Summary -- Chapter 8: Behavioral Design Patterns -- Part One -- Defining behavioral design patterns -- The value object design pattern -- An example class diagram -- A code example -- Alternative implementation -- What it is good for -- What it is not so good for -- The null object design pattern -- An example class diagram -- A code example -- What it is good for -- What it is not so good for -- The strategy design pattern -- An example class diagram -- A code example -- The strategy design pattern the Scala way -- What it is good for -- What it is not so good for -- The command design pattern -- An example class diagram -- A code example -- The command design pattern the Scala way -- What it is good for -- What it is not so good for -- The chain of responsibility design pattern -- An example class diagram -- A code example -- The chain of responsibility design pattern the Scala way -- What it is good for -- What it is not so good for -- The interpreter design pattern -- An example class diagram -- A code example -- What it is good for. | |
| 505 | 8 | |a What it is not so good for -- Summary -- Chapter 9: Behavioral Design Patterns -- Part Two -- The iterator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The mediator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The memento design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The observer design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The state design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The template method design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The visitor design pattern -- Example class diagram -- Code example -- The visitor design pattern the Scala way -- What it is good for -- What it is not so good for -- Summary -- Chapter 10: Functional Design Patterns -- the Deep Theory -- Abstraction and vocabulary -- Monoids -- What are monoids? -- Monoids in real life -- Using monoids -- Monoids and foldable collections -- Monoids and parallel computations -- Monoids and composition -- When to use monoids -- Functors -- Functors in real life -- Using our functors -- Monads -- What is a monad? -- The flatMap method -- The unit method -- The connection between map, flatMap, and unit -- The names of the methods -- The monad laws -- Monads in real life -- Using monads -- The Option monad -- A more advanced monad example -- Monad intuition -- Summary -- Chapter 11: Applying What We Have Learned -- The lens design pattern -- Lens example -- Without the lens design pattern -- Immutable and verbose -- Using mutable properties -- With the lens design pattern. | |
| 520 | |a Design patterns make developers' lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. In this book, you'll learn about the various features of Scala and will be able to apply well-known, industry-proven design patterns in your work. | ||
| 650 | 0 | |a Scala (Computer program language) |0 http://id.loc.gov/authorities/subjects/sh2010013203 | |
| 650 | 0 | |a Application software |x Development. |0 http://id.loc.gov/authorities/subjects/sh95009362 | |
| 650 | 6 | |a Scala (Langage de programmation) | |
| 650 | 6 | |a Logiciels d'application |x Développement. | |
| 650 | 7 | |a Application software |x Development |2 fast | |
| 650 | 7 | |a Scala (Computer program language) |2 fast | |
| 966 | 4 | 0 | |l DE-862 |p ZDB-4-EBA |q FWS_PDA_EBA |u https://search.ebscohost.com/login.aspx?direct=true&scope=site&db=nlebk&AN=1789494 |3 Volltext |
| 966 | 4 | 0 | |l DE-863 |p ZDB-4-EBA |q FWS_PDA_EBA |u https://search.ebscohost.com/login.aspx?direct=true&scope=site&db=nlebk&AN=1789494 |3 Volltext |
| 938 | |a EBSCOhost |b EBSC |n 1789494 | ||
| 994 | |a 92 |b GEBAY | ||
| 912 | |a ZDB-4-EBA | ||
| 049 | |a DE-862 | ||
| 049 | |a DE-863 | ||
Record in the Search Index
| DE-BY-FWS_katkey | ZDB-4-EBA-on1035423272 |
|---|---|
| _version_ | 1829095138284011520 |
| adam_text | |
| any_adam_object | |
| author | Nikolov, Ivan |
| author_facet | Nikolov, Ivan |
| author_role | aut |
| author_sort | Nikolov, Ivan |
| author_variant | i n in |
| building | Verbundindex |
| bvnumber | localFWS |
| callnumber-first | Q - Science |
| callnumber-label | QA76 |
| callnumber-raw | QA76.73.S28 |
| callnumber-search | QA76.73.S28 |
| callnumber-sort | QA 276.73 S28 |
| callnumber-subject | QA - Mathematics |
| collection | ZDB-4-EBA |
| contents | Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: The Design Patterns Out There and Setting Up Your Environment -- Design patterns -- Scala and design patterns -- The need for design patterns and their benefits -- Design pattern categories -- Creational design patterns -- The abstract factory design pattern -- The factory method design pattern -- The lazy initialization design pattern -- The singleton design pattern -- The object pool design pattern -- The builder design pattern -- The prototype design pattern -- Structural design patterns -- The adapter design pattern -- The decorator design pattern -- The bridge design pattern -- The composite design pattern -- The facade design pattern -- The flyweight design pattern -- The proxy design pattern -- Behavioral design patterns -- The value object design pattern -- The null object design pattern -- The strategy design pattern -- The command design pattern -- The chain of responsibility design pattern -- The interpreter design pattern -- The iterator design pattern -- The mediator design pattern -- The memento design pattern -- The observer design pattern -- The state design pattern -- The template method design pattern -- The visitor design pattern -- Functional design patterns -- Monoids -- Monads -- Functors -- Scala-specific design patterns -- The lens design pattern -- The cake design pattern -- Pimp my library -- Stackable traits -- The type class design pattern -- Lazy evaluation -- Partial functions -- Implicit injection -- Duck typing -- Memoization -- Choosing a design pattern -- Setting up the development environment -- Installing Scala -- Tips for installing Scala manually -- Tips for installing Scala using SBT -- Scala IDEs -- Dependency management -- SBT -- Maven -- SBT versus Maven -- Summary. Chapter 2: Traits and Mixin Compositions -- Traits -- Traits as interfaces -- Mixing in traits with variables -- Traits as classes -- Extending classes -- Extending traits -- Mixin compositions -- Mixing traits in -- Composing -- Composing simple traits -- Composing complex traits -- Composing with self-types -- Clashing traits -- Same signatures and return types -- Same signatures and different return types traits -- Same signatures and return types mixins -- Same signatures and different return types mixins -- Multiple inheritance -- The diamond problem -- The limitations -- Linearization -- Rules of inheritance hierarchies -- Linearization rules -- How linearization works -- Initialization -- Method overriding -- Testing traits -- Using a class -- Mixing the trait in -- Mixing into the test class -- Mixing into the test cases -- Running the tests -- Traits versus classes -- Summary -- Chapter 3: Unification -- Functions and classes -- Functions as classes -- Function literals -- Functions without syntactic sugar -- Increased expressivity -- Algebraic data types and class hierarchies -- ADTs -- Sum ADTs -- Product ADTs -- Hybrid ADTs -- The unification -- Pattern matching -- Pattern matching with values -- Pattern matching for product ADTs -- Modules and objects -- Using modules -- Summary -- Chapter 4: Abstract and Self Types -- Abstract types -- Generics -- Abstract types -- Generics versus abstract types -- Usage advice -- Polymorphism -- Subtype polymorphism -- Parametric polymorphism -- Ad hoc polymorphism -- Adding functions for multiple types -- Self types -- Using self types -- Requiring multiple components -- Conflicting components -- Self types and the cake design pattern -- Self types versus inheritance -- Inheritance leaking functionality -- Summary -- Chapter 5: Aspect-Oriented Programming and Components -- Aspect-oriented programming. Understanding application efficiency -- Timing our application without AOP -- Timing our application with AOP -- Components in Scala -- Using Scala's expressive power to build components -- Implementing components -- Self types for components -- Summary -- Chapter 6: Creational Design Patterns -- What are creational design patterns? -- The factory method design pattern -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- The abstract factory -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- Other factory design patterns -- The static factory -- The simple factory -- Factory combinations -- Lazy initialization -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The singleton design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The builder design pattern -- An example class diagram -- A code example -- A Java-like implementation -- Implementation with a case class -- Using generalized type constraints -- Changing the Person class -- Adding generalized type constraints to the required methods -- Using the type-safe builder -- Using require statements -- What it is good for? -- What it is not so good for? -- The prototype design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- Summary -- Chapter 7 : Structural Design Patterns -- Defining structural design patterns -- The adapter design pattern -- Example class diagram -- Code example -- The adapter design pattern with final classes -- The adapter design pattern the Scala way -- What it is good for -- What it is not so good for -- The decorator design pattern. Example class diagram -- Code example -- The decorator design pattern the Scala way -- What it is good for -- What it is not so good for -- The bridge design pattern -- Example class diagram -- Code example -- The bridge design pattern the Scala way -- What it is good for -- What it is not so good for -- The composite design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The facade design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The flyweight design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The proxy design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- Summary -- Chapter 8: Behavioral Design Patterns -- Part One -- Defining behavioral design patterns -- The value object design pattern -- An example class diagram -- A code example -- Alternative implementation -- What it is good for -- What it is not so good for -- The null object design pattern -- An example class diagram -- A code example -- What it is good for -- What it is not so good for -- The strategy design pattern -- An example class diagram -- A code example -- The strategy design pattern the Scala way -- What it is good for -- What it is not so good for -- The command design pattern -- An example class diagram -- A code example -- The command design pattern the Scala way -- What it is good for -- What it is not so good for -- The chain of responsibility design pattern -- An example class diagram -- A code example -- The chain of responsibility design pattern the Scala way -- What it is good for -- What it is not so good for -- The interpreter design pattern -- An example class diagram -- A code example -- What it is good for. What it is not so good for -- Summary -- Chapter 9: Behavioral Design Patterns -- Part Two -- The iterator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The mediator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The memento design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The observer design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The state design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The template method design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The visitor design pattern -- Example class diagram -- Code example -- The visitor design pattern the Scala way -- What it is good for -- What it is not so good for -- Summary -- Chapter 10: Functional Design Patterns -- the Deep Theory -- Abstraction and vocabulary -- Monoids -- What are monoids? -- Monoids in real life -- Using monoids -- Monoids and foldable collections -- Monoids and parallel computations -- Monoids and composition -- When to use monoids -- Functors -- Functors in real life -- Using our functors -- Monads -- What is a monad? -- The flatMap method -- The unit method -- The connection between map, flatMap, and unit -- The names of the methods -- The monad laws -- Monads in real life -- Using monads -- The Option monad -- A more advanced monad example -- Monad intuition -- Summary -- Chapter 11: Applying What We Have Learned -- The lens design pattern -- Lens example -- Without the lens design pattern -- Immutable and verbose -- Using mutable properties -- With the lens design pattern. |
| ctrlnum | (OCoLC)1035423272 |
| dewey-full | 005.114 |
| dewey-hundreds | 000 - Computer science, information, general works |
| dewey-ones | 005 - Computer programming, programs, data, security |
| dewey-raw | 005.114 |
| dewey-search | 005.114 |
| dewey-sort | 15.114 |
| dewey-tens | 000 - Computer science, information, general works |
| discipline | Informatik |
| edition | Second edition. |
| format | Electronic eBook |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>11539cam a2200505 i 4500</leader><controlfield tag="001">ZDB-4-EBA-on1035423272</controlfield><controlfield tag="003">OCoLC</controlfield><controlfield tag="005">20250103110447.0</controlfield><controlfield tag="006">m o d </controlfield><controlfield tag="007">cr unu||||||||</controlfield><controlfield tag="008">180511s2018 enka o 000 0 eng d</controlfield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">UMI</subfield><subfield code="b">eng</subfield><subfield code="e">rda</subfield><subfield code="e">pn</subfield><subfield code="c">UMI</subfield><subfield code="d">STF</subfield><subfield code="d">OCLCF</subfield><subfield code="d">TOH</subfield><subfield code="d">CEF</subfield><subfield code="d">DEBBG</subfield><subfield code="d">G3B</subfield><subfield code="d">UAB</subfield><subfield code="d">RDF</subfield><subfield code="d">N$T</subfield><subfield code="d">OCLCQ</subfield><subfield code="d">OCLCO</subfield><subfield code="d">OCLCQ</subfield><subfield code="d">OCLCO</subfield><subfield code="d">SFB</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">1788472098</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9781788472098</subfield><subfield code="q">(electronic bk.)</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="z">9781788471305</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1035423272</subfield></datafield><datafield tag="037" ind1=" " ind2=" "><subfield code="a">CL0500000963</subfield><subfield code="b">Safari Books Online</subfield></datafield><datafield tag="050" ind1=" " ind2="4"><subfield code="a">QA76.73.S28</subfield></datafield><datafield tag="082" ind1="7" ind2=" "><subfield code="a">005.114</subfield><subfield code="2">23</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">MAIN</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Nikolov, Ivan,</subfield><subfield code="e">author.</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Scala design patterns :</subfield><subfield code="b">design modular, clean, and scalable applications by applying proven design patterns in Scala /</subfield><subfield code="c">Ivan Nikolov.</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">Second edition.</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Birmingham, UK :</subfield><subfield code="b">Packt Publishing,</subfield><subfield code="c">2018.</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1 online resource (1 volume) :</subfield><subfield code="b">illustrations</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="a">text</subfield><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="a">computer</subfield><subfield code="b">c</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="a">online resource</subfield><subfield code="b">cr</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="588" ind1="0" ind2=" "><subfield code="a">Online resource; title from title page (Safari, viewed May 10, 2018).</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Previous edition published: 2016.</subfield></datafield><datafield tag="505" ind1="0" ind2=" "><subfield code="a">Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: The Design Patterns Out There and Setting Up Your Environment -- Design patterns -- Scala and design patterns -- The need for design patterns and their benefits -- Design pattern categories -- Creational design patterns -- The abstract factory design pattern -- The factory method design pattern -- The lazy initialization design pattern -- The singleton design pattern -- The object pool design pattern -- The builder design pattern -- The prototype design pattern -- Structural design patterns -- The adapter design pattern -- The decorator design pattern -- The bridge design pattern -- The composite design pattern -- The facade design pattern -- The flyweight design pattern -- The proxy design pattern -- Behavioral design patterns -- The value object design pattern -- The null object design pattern -- The strategy design pattern -- The command design pattern -- The chain of responsibility design pattern -- The interpreter design pattern -- The iterator design pattern -- The mediator design pattern -- The memento design pattern -- The observer design pattern -- The state design pattern -- The template method design pattern -- The visitor design pattern -- Functional design patterns -- Monoids -- Monads -- Functors -- Scala-specific design patterns -- The lens design pattern -- The cake design pattern -- Pimp my library -- Stackable traits -- The type class design pattern -- Lazy evaluation -- Partial functions -- Implicit injection -- Duck typing -- Memoization -- Choosing a design pattern -- Setting up the development environment -- Installing Scala -- Tips for installing Scala manually -- Tips for installing Scala using SBT -- Scala IDEs -- Dependency management -- SBT -- Maven -- SBT versus Maven -- Summary.</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Chapter 2: Traits and Mixin Compositions -- Traits -- Traits as interfaces -- Mixing in traits with variables -- Traits as classes -- Extending classes -- Extending traits -- Mixin compositions -- Mixing traits in -- Composing -- Composing simple traits -- Composing complex traits -- Composing with self-types -- Clashing traits -- Same signatures and return types -- Same signatures and different return types traits -- Same signatures and return types mixins -- Same signatures and different return types mixins -- Multiple inheritance -- The diamond problem -- The limitations -- Linearization -- Rules of inheritance hierarchies -- Linearization rules -- How linearization works -- Initialization -- Method overriding -- Testing traits -- Using a class -- Mixing the trait in -- Mixing into the test class -- Mixing into the test cases -- Running the tests -- Traits versus classes -- Summary -- Chapter 3: Unification -- Functions and classes -- Functions as classes -- Function literals -- Functions without syntactic sugar -- Increased expressivity -- Algebraic data types and class hierarchies -- ADTs -- Sum ADTs -- Product ADTs -- Hybrid ADTs -- The unification -- Pattern matching -- Pattern matching with values -- Pattern matching for product ADTs -- Modules and objects -- Using modules -- Summary -- Chapter 4: Abstract and Self Types -- Abstract types -- Generics -- Abstract types -- Generics versus abstract types -- Usage advice -- Polymorphism -- Subtype polymorphism -- Parametric polymorphism -- Ad hoc polymorphism -- Adding functions for multiple types -- Self types -- Using self types -- Requiring multiple components -- Conflicting components -- Self types and the cake design pattern -- Self types versus inheritance -- Inheritance leaking functionality -- Summary -- Chapter 5: Aspect-Oriented Programming and Components -- Aspect-oriented programming.</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Understanding application efficiency -- Timing our application without AOP -- Timing our application with AOP -- Components in Scala -- Using Scala's expressive power to build components -- Implementing components -- Self types for components -- Summary -- Chapter 6: Creational Design Patterns -- What are creational design patterns? -- The factory method design pattern -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- The abstract factory -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- Other factory design patterns -- The static factory -- The simple factory -- Factory combinations -- Lazy initialization -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The singleton design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The builder design pattern -- An example class diagram -- A code example -- A Java-like implementation -- Implementation with a case class -- Using generalized type constraints -- Changing the Person class -- Adding generalized type constraints to the required methods -- Using the type-safe builder -- Using require statements -- What it is good for? -- What it is not so good for? -- The prototype design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- Summary -- Chapter 7 : Structural Design Patterns -- Defining structural design patterns -- The adapter design pattern -- Example class diagram -- Code example -- The adapter design pattern with final classes -- The adapter design pattern the Scala way -- What it is good for -- What it is not so good for -- The decorator design pattern.</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Example class diagram -- Code example -- The decorator design pattern the Scala way -- What it is good for -- What it is not so good for -- The bridge design pattern -- Example class diagram -- Code example -- The bridge design pattern the Scala way -- What it is good for -- What it is not so good for -- The composite design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The facade design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The flyweight design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The proxy design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- Summary -- Chapter 8: Behavioral Design Patterns -- Part One -- Defining behavioral design patterns -- The value object design pattern -- An example class diagram -- A code example -- Alternative implementation -- What it is good for -- What it is not so good for -- The null object design pattern -- An example class diagram -- A code example -- What it is good for -- What it is not so good for -- The strategy design pattern -- An example class diagram -- A code example -- The strategy design pattern the Scala way -- What it is good for -- What it is not so good for -- The command design pattern -- An example class diagram -- A code example -- The command design pattern the Scala way -- What it is good for -- What it is not so good for -- The chain of responsibility design pattern -- An example class diagram -- A code example -- The chain of responsibility design pattern the Scala way -- What it is good for -- What it is not so good for -- The interpreter design pattern -- An example class diagram -- A code example -- What it is good for.</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">What it is not so good for -- Summary -- Chapter 9: Behavioral Design Patterns -- Part Two -- The iterator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The mediator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The memento design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The observer design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The state design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The template method design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The visitor design pattern -- Example class diagram -- Code example -- The visitor design pattern the Scala way -- What it is good for -- What it is not so good for -- Summary -- Chapter 10: Functional Design Patterns -- the Deep Theory -- Abstraction and vocabulary -- Monoids -- What are monoids? -- Monoids in real life -- Using monoids -- Monoids and foldable collections -- Monoids and parallel computations -- Monoids and composition -- When to use monoids -- Functors -- Functors in real life -- Using our functors -- Monads -- What is a monad? -- The flatMap method -- The unit method -- The connection between map, flatMap, and unit -- The names of the methods -- The monad laws -- Monads in real life -- Using monads -- The Option monad -- A more advanced monad example -- Monad intuition -- Summary -- Chapter 11: Applying What We Have Learned -- The lens design pattern -- Lens example -- Without the lens design pattern -- Immutable and verbose -- Using mutable properties -- With the lens design pattern.</subfield></datafield><datafield tag="520" ind1=" " ind2=" "><subfield code="a">Design patterns make developers' lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. In this book, you'll learn about the various features of Scala and will be able to apply well-known, industry-proven design patterns in your work.</subfield></datafield><datafield tag="650" ind1=" " ind2="0"><subfield code="a">Scala (Computer program language)</subfield><subfield code="0">http://id.loc.gov/authorities/subjects/sh2010013203</subfield></datafield><datafield tag="650" ind1=" " ind2="0"><subfield code="a">Application software</subfield><subfield code="x">Development.</subfield><subfield code="0">http://id.loc.gov/authorities/subjects/sh95009362</subfield></datafield><datafield tag="650" ind1=" " ind2="6"><subfield code="a">Scala (Langage de programmation)</subfield></datafield><datafield tag="650" ind1=" " ind2="6"><subfield code="a">Logiciels d'application</subfield><subfield code="x">Développement.</subfield></datafield><datafield tag="650" ind1=" " ind2="7"><subfield code="a">Application software</subfield><subfield code="x">Development</subfield><subfield code="2">fast</subfield></datafield><datafield tag="650" ind1=" " ind2="7"><subfield code="a">Scala (Computer program language)</subfield><subfield code="2">fast</subfield></datafield><datafield tag="966" ind1="4" ind2="0"><subfield code="l">DE-862</subfield><subfield code="p">ZDB-4-EBA</subfield><subfield code="q">FWS_PDA_EBA</subfield><subfield code="u">https://search.ebscohost.com/login.aspx?direct=true&scope=site&db=nlebk&AN=1789494</subfield><subfield code="3">Volltext</subfield></datafield><datafield tag="966" ind1="4" ind2="0"><subfield code="l">DE-863</subfield><subfield code="p">ZDB-4-EBA</subfield><subfield code="q">FWS_PDA_EBA</subfield><subfield code="u">https://search.ebscohost.com/login.aspx?direct=true&scope=site&db=nlebk&AN=1789494</subfield><subfield code="3">Volltext</subfield></datafield><datafield tag="938" ind1=" " ind2=" "><subfield code="a">EBSCOhost</subfield><subfield code="b">EBSC</subfield><subfield code="n">1789494</subfield></datafield><datafield tag="994" ind1=" " ind2=" "><subfield code="a">92</subfield><subfield code="b">GEBAY</subfield></datafield><datafield tag="912" ind1=" " ind2=" "><subfield code="a">ZDB-4-EBA</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-862</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-863</subfield></datafield></record></collection> |
| id | ZDB-4-EBA-on1035423272 |
| illustrated | Illustrated |
| indexdate | 2025-04-11T08:44:15Z |
| institution | BVB |
| isbn | 1788472098 9781788472098 |
| language | English |
| oclc_num | 1035423272 |
| open_access_boolean | |
| owner | MAIN DE-862 DE-BY-FWS DE-863 DE-BY-FWS |
| owner_facet | MAIN DE-862 DE-BY-FWS DE-863 DE-BY-FWS |
| physical | 1 online resource (1 volume) : illustrations |
| psigel | ZDB-4-EBA FWS_PDA_EBA ZDB-4-EBA |
| publishDate | 2018 |
| publishDateSearch | 2018 |
| publishDateSort | 2018 |
| publisher | Packt Publishing, |
| record_format | marc |
| spelling | Nikolov, Ivan, author. Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / Ivan Nikolov. Second edition. Birmingham, UK : Packt Publishing, 2018. 1 online resource (1 volume) : illustrations text txt rdacontent computer c rdamedia online resource cr rdacarrier Online resource; title from title page (Safari, viewed May 10, 2018). Previous edition published: 2016. Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: The Design Patterns Out There and Setting Up Your Environment -- Design patterns -- Scala and design patterns -- The need for design patterns and their benefits -- Design pattern categories -- Creational design patterns -- The abstract factory design pattern -- The factory method design pattern -- The lazy initialization design pattern -- The singleton design pattern -- The object pool design pattern -- The builder design pattern -- The prototype design pattern -- Structural design patterns -- The adapter design pattern -- The decorator design pattern -- The bridge design pattern -- The composite design pattern -- The facade design pattern -- The flyweight design pattern -- The proxy design pattern -- Behavioral design patterns -- The value object design pattern -- The null object design pattern -- The strategy design pattern -- The command design pattern -- The chain of responsibility design pattern -- The interpreter design pattern -- The iterator design pattern -- The mediator design pattern -- The memento design pattern -- The observer design pattern -- The state design pattern -- The template method design pattern -- The visitor design pattern -- Functional design patterns -- Monoids -- Monads -- Functors -- Scala-specific design patterns -- The lens design pattern -- The cake design pattern -- Pimp my library -- Stackable traits -- The type class design pattern -- Lazy evaluation -- Partial functions -- Implicit injection -- Duck typing -- Memoization -- Choosing a design pattern -- Setting up the development environment -- Installing Scala -- Tips for installing Scala manually -- Tips for installing Scala using SBT -- Scala IDEs -- Dependency management -- SBT -- Maven -- SBT versus Maven -- Summary. Chapter 2: Traits and Mixin Compositions -- Traits -- Traits as interfaces -- Mixing in traits with variables -- Traits as classes -- Extending classes -- Extending traits -- Mixin compositions -- Mixing traits in -- Composing -- Composing simple traits -- Composing complex traits -- Composing with self-types -- Clashing traits -- Same signatures and return types -- Same signatures and different return types traits -- Same signatures and return types mixins -- Same signatures and different return types mixins -- Multiple inheritance -- The diamond problem -- The limitations -- Linearization -- Rules of inheritance hierarchies -- Linearization rules -- How linearization works -- Initialization -- Method overriding -- Testing traits -- Using a class -- Mixing the trait in -- Mixing into the test class -- Mixing into the test cases -- Running the tests -- Traits versus classes -- Summary -- Chapter 3: Unification -- Functions and classes -- Functions as classes -- Function literals -- Functions without syntactic sugar -- Increased expressivity -- Algebraic data types and class hierarchies -- ADTs -- Sum ADTs -- Product ADTs -- Hybrid ADTs -- The unification -- Pattern matching -- Pattern matching with values -- Pattern matching for product ADTs -- Modules and objects -- Using modules -- Summary -- Chapter 4: Abstract and Self Types -- Abstract types -- Generics -- Abstract types -- Generics versus abstract types -- Usage advice -- Polymorphism -- Subtype polymorphism -- Parametric polymorphism -- Ad hoc polymorphism -- Adding functions for multiple types -- Self types -- Using self types -- Requiring multiple components -- Conflicting components -- Self types and the cake design pattern -- Self types versus inheritance -- Inheritance leaking functionality -- Summary -- Chapter 5: Aspect-Oriented Programming and Components -- Aspect-oriented programming. Understanding application efficiency -- Timing our application without AOP -- Timing our application with AOP -- Components in Scala -- Using Scala's expressive power to build components -- Implementing components -- Self types for components -- Summary -- Chapter 6: Creational Design Patterns -- What are creational design patterns? -- The factory method design pattern -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- The abstract factory -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- Other factory design patterns -- The static factory -- The simple factory -- Factory combinations -- Lazy initialization -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The singleton design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The builder design pattern -- An example class diagram -- A code example -- A Java-like implementation -- Implementation with a case class -- Using generalized type constraints -- Changing the Person class -- Adding generalized type constraints to the required methods -- Using the type-safe builder -- Using require statements -- What it is good for? -- What it is not so good for? -- The prototype design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- Summary -- Chapter 7 : Structural Design Patterns -- Defining structural design patterns -- The adapter design pattern -- Example class diagram -- Code example -- The adapter design pattern with final classes -- The adapter design pattern the Scala way -- What it is good for -- What it is not so good for -- The decorator design pattern. Example class diagram -- Code example -- The decorator design pattern the Scala way -- What it is good for -- What it is not so good for -- The bridge design pattern -- Example class diagram -- Code example -- The bridge design pattern the Scala way -- What it is good for -- What it is not so good for -- The composite design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The facade design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The flyweight design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The proxy design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- Summary -- Chapter 8: Behavioral Design Patterns -- Part One -- Defining behavioral design patterns -- The value object design pattern -- An example class diagram -- A code example -- Alternative implementation -- What it is good for -- What it is not so good for -- The null object design pattern -- An example class diagram -- A code example -- What it is good for -- What it is not so good for -- The strategy design pattern -- An example class diagram -- A code example -- The strategy design pattern the Scala way -- What it is good for -- What it is not so good for -- The command design pattern -- An example class diagram -- A code example -- The command design pattern the Scala way -- What it is good for -- What it is not so good for -- The chain of responsibility design pattern -- An example class diagram -- A code example -- The chain of responsibility design pattern the Scala way -- What it is good for -- What it is not so good for -- The interpreter design pattern -- An example class diagram -- A code example -- What it is good for. What it is not so good for -- Summary -- Chapter 9: Behavioral Design Patterns -- Part Two -- The iterator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The mediator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The memento design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The observer design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The state design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The template method design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The visitor design pattern -- Example class diagram -- Code example -- The visitor design pattern the Scala way -- What it is good for -- What it is not so good for -- Summary -- Chapter 10: Functional Design Patterns -- the Deep Theory -- Abstraction and vocabulary -- Monoids -- What are monoids? -- Monoids in real life -- Using monoids -- Monoids and foldable collections -- Monoids and parallel computations -- Monoids and composition -- When to use monoids -- Functors -- Functors in real life -- Using our functors -- Monads -- What is a monad? -- The flatMap method -- The unit method -- The connection between map, flatMap, and unit -- The names of the methods -- The monad laws -- Monads in real life -- Using monads -- The Option monad -- A more advanced monad example -- Monad intuition -- Summary -- Chapter 11: Applying What We Have Learned -- The lens design pattern -- Lens example -- Without the lens design pattern -- Immutable and verbose -- Using mutable properties -- With the lens design pattern. Design patterns make developers' lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. In this book, you'll learn about the various features of Scala and will be able to apply well-known, industry-proven design patterns in your work. Scala (Computer program language) http://id.loc.gov/authorities/subjects/sh2010013203 Application software Development. http://id.loc.gov/authorities/subjects/sh95009362 Scala (Langage de programmation) Logiciels d'application Développement. Application software Development fast Scala (Computer program language) fast |
| spellingShingle | Nikolov, Ivan Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: The Design Patterns Out There and Setting Up Your Environment -- Design patterns -- Scala and design patterns -- The need for design patterns and their benefits -- Design pattern categories -- Creational design patterns -- The abstract factory design pattern -- The factory method design pattern -- The lazy initialization design pattern -- The singleton design pattern -- The object pool design pattern -- The builder design pattern -- The prototype design pattern -- Structural design patterns -- The adapter design pattern -- The decorator design pattern -- The bridge design pattern -- The composite design pattern -- The facade design pattern -- The flyweight design pattern -- The proxy design pattern -- Behavioral design patterns -- The value object design pattern -- The null object design pattern -- The strategy design pattern -- The command design pattern -- The chain of responsibility design pattern -- The interpreter design pattern -- The iterator design pattern -- The mediator design pattern -- The memento design pattern -- The observer design pattern -- The state design pattern -- The template method design pattern -- The visitor design pattern -- Functional design patterns -- Monoids -- Monads -- Functors -- Scala-specific design patterns -- The lens design pattern -- The cake design pattern -- Pimp my library -- Stackable traits -- The type class design pattern -- Lazy evaluation -- Partial functions -- Implicit injection -- Duck typing -- Memoization -- Choosing a design pattern -- Setting up the development environment -- Installing Scala -- Tips for installing Scala manually -- Tips for installing Scala using SBT -- Scala IDEs -- Dependency management -- SBT -- Maven -- SBT versus Maven -- Summary. Chapter 2: Traits and Mixin Compositions -- Traits -- Traits as interfaces -- Mixing in traits with variables -- Traits as classes -- Extending classes -- Extending traits -- Mixin compositions -- Mixing traits in -- Composing -- Composing simple traits -- Composing complex traits -- Composing with self-types -- Clashing traits -- Same signatures and return types -- Same signatures and different return types traits -- Same signatures and return types mixins -- Same signatures and different return types mixins -- Multiple inheritance -- The diamond problem -- The limitations -- Linearization -- Rules of inheritance hierarchies -- Linearization rules -- How linearization works -- Initialization -- Method overriding -- Testing traits -- Using a class -- Mixing the trait in -- Mixing into the test class -- Mixing into the test cases -- Running the tests -- Traits versus classes -- Summary -- Chapter 3: Unification -- Functions and classes -- Functions as classes -- Function literals -- Functions without syntactic sugar -- Increased expressivity -- Algebraic data types and class hierarchies -- ADTs -- Sum ADTs -- Product ADTs -- Hybrid ADTs -- The unification -- Pattern matching -- Pattern matching with values -- Pattern matching for product ADTs -- Modules and objects -- Using modules -- Summary -- Chapter 4: Abstract and Self Types -- Abstract types -- Generics -- Abstract types -- Generics versus abstract types -- Usage advice -- Polymorphism -- Subtype polymorphism -- Parametric polymorphism -- Ad hoc polymorphism -- Adding functions for multiple types -- Self types -- Using self types -- Requiring multiple components -- Conflicting components -- Self types and the cake design pattern -- Self types versus inheritance -- Inheritance leaking functionality -- Summary -- Chapter 5: Aspect-Oriented Programming and Components -- Aspect-oriented programming. Understanding application efficiency -- Timing our application without AOP -- Timing our application with AOP -- Components in Scala -- Using Scala's expressive power to build components -- Implementing components -- Self types for components -- Summary -- Chapter 6: Creational Design Patterns -- What are creational design patterns? -- The factory method design pattern -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- The abstract factory -- An example class diagram -- A code example -- Scala alternatives -- What it is good for? -- What it is not so good for? -- Other factory design patterns -- The static factory -- The simple factory -- Factory combinations -- Lazy initialization -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The singleton design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- The builder design pattern -- An example class diagram -- A code example -- A Java-like implementation -- Implementation with a case class -- Using generalized type constraints -- Changing the Person class -- Adding generalized type constraints to the required methods -- Using the type-safe builder -- Using require statements -- What it is good for? -- What it is not so good for? -- The prototype design pattern -- An example class diagram -- A code example -- What it is good for? -- What it is not so good for? -- Summary -- Chapter 7 : Structural Design Patterns -- Defining structural design patterns -- The adapter design pattern -- Example class diagram -- Code example -- The adapter design pattern with final classes -- The adapter design pattern the Scala way -- What it is good for -- What it is not so good for -- The decorator design pattern. Example class diagram -- Code example -- The decorator design pattern the Scala way -- What it is good for -- What it is not so good for -- The bridge design pattern -- Example class diagram -- Code example -- The bridge design pattern the Scala way -- What it is good for -- What it is not so good for -- The composite design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The facade design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The flyweight design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The proxy design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- Summary -- Chapter 8: Behavioral Design Patterns -- Part One -- Defining behavioral design patterns -- The value object design pattern -- An example class diagram -- A code example -- Alternative implementation -- What it is good for -- What it is not so good for -- The null object design pattern -- An example class diagram -- A code example -- What it is good for -- What it is not so good for -- The strategy design pattern -- An example class diagram -- A code example -- The strategy design pattern the Scala way -- What it is good for -- What it is not so good for -- The command design pattern -- An example class diagram -- A code example -- The command design pattern the Scala way -- What it is good for -- What it is not so good for -- The chain of responsibility design pattern -- An example class diagram -- A code example -- The chain of responsibility design pattern the Scala way -- What it is good for -- What it is not so good for -- The interpreter design pattern -- An example class diagram -- A code example -- What it is good for. What it is not so good for -- Summary -- Chapter 9: Behavioral Design Patterns -- Part Two -- The iterator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The mediator design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The memento design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The observer design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The state design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The template method design pattern -- Example class diagram -- Code example -- What it is good for -- What it is not so good for -- The visitor design pattern -- Example class diagram -- Code example -- The visitor design pattern the Scala way -- What it is good for -- What it is not so good for -- Summary -- Chapter 10: Functional Design Patterns -- the Deep Theory -- Abstraction and vocabulary -- Monoids -- What are monoids? -- Monoids in real life -- Using monoids -- Monoids and foldable collections -- Monoids and parallel computations -- Monoids and composition -- When to use monoids -- Functors -- Functors in real life -- Using our functors -- Monads -- What is a monad? -- The flatMap method -- The unit method -- The connection between map, flatMap, and unit -- The names of the methods -- The monad laws -- Monads in real life -- Using monads -- The Option monad -- A more advanced monad example -- Monad intuition -- Summary -- Chapter 11: Applying What We Have Learned -- The lens design pattern -- Lens example -- Without the lens design pattern -- Immutable and verbose -- Using mutable properties -- With the lens design pattern. Scala (Computer program language) http://id.loc.gov/authorities/subjects/sh2010013203 Application software Development. http://id.loc.gov/authorities/subjects/sh95009362 Scala (Langage de programmation) Logiciels d'application Développement. Application software Development fast Scala (Computer program language) fast |
| subject_GND | http://id.loc.gov/authorities/subjects/sh2010013203 http://id.loc.gov/authorities/subjects/sh95009362 |
| title | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / |
| title_auth | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / |
| title_exact_search | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / |
| title_full | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / Ivan Nikolov. |
| title_fullStr | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / Ivan Nikolov. |
| title_full_unstemmed | Scala design patterns : design modular, clean, and scalable applications by applying proven design patterns in Scala / Ivan Nikolov. |
| title_short | Scala design patterns : |
| title_sort | scala design patterns design modular clean and scalable applications by applying proven design patterns in scala |
| title_sub | design modular, clean, and scalable applications by applying proven design patterns in Scala / |
| topic | Scala (Computer program language) http://id.loc.gov/authorities/subjects/sh2010013203 Application software Development. http://id.loc.gov/authorities/subjects/sh95009362 Scala (Langage de programmation) Logiciels d'application Développement. Application software Development fast Scala (Computer program language) fast |
| topic_facet | Scala (Computer program language) Application software Development. Scala (Langage de programmation) Logiciels d'application Développement. Application software Development |
| work_keys_str_mv | AT nikolovivan scaladesignpatternsdesignmodularcleanandscalableapplicationsbyapplyingprovendesignpatternsinscala |