Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone
  • Android

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Kindle-Preis: EUR 20,74
inkl. MwSt.

Diese Aktionen werden auf diesen Artikel angewendet:

Einige Angebote können miteinander kombiniert werden, andere nicht. Für mehr Details lesen Sie bitte die Nutzungsbedingungen der jeweiligen Promotion.

An Ihren Kindle oder ein anderes Gerät senden

An Ihren Kindle oder ein anderes Gerät senden

Facebook Twitter Pinterest <Einbetten>
Functional Programming Patterns in Scala and Clojure: Write Lean Programs for the JVM von [Bevilacqua-Linn, Michael]
Anzeige für Kindle-App

Functional Programming Patterns in Scala and Clojure: Write Lean Programs for the JVM Kindle Edition

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
EUR 20,74

August-Aktion: Englische eBooks stark reduziert
Entdecken Sie unsere Auswahl an englischen eBooks aus verschiedenen Genres für je 1,99 EUR. Die aktuelle Aktion läuft noch bis 31. August 2016.



""This book is an absolute gem and should be required reading for anybody looking to transition from OO to FP. It is an extremely well-built safety rope for those crossing the bridge between two very different worlds. Consider this mandatory reading.""--Colin Yates, technical team leader QFI Consulting, LLP

""This book sticks to the meat and potatoes of what functional programming can do for the object-oriented JVM programmer. The functional patterns are sectioned in the back of the book separate from the functional replacements of the object-oriented patterns, making the book handy reference material. As a Scala programmer, I even picked up some new tricks along the read.""--Justin James, developer, Full Stack Apps

""This book is good for those who have dabbled a bit in Clojure or Scala but are not really comfortable with it; the ideal audience is seasoned OO programmers looking to adopt a functional style, as it gives those programmers a guide for transitioning away from the patterns they are comfortable with.""--Rod Hilton, Java developer and PhD candidate at the University of Colorado


Solve real-life programming problems with a fraction of the code that pure object-oriented programming requires. Use Scala and Clojure to solve in-depth problems with two sets of patterns: object-oriented patterns that become more concise with functional programming, and natively functional patterns. Your code will be more declarative, with fewer bugs and lower maintenance costs.

Functional languages have their own patterns that enable you to solve problems with less code than object-oriented programming alone. This book introduces you, the experienced Java programmer, to Scala and Clojure: practical, production-quality languages that run on the JVM and interoperate with existing Java. By using both the statically typed, type-inferred Scala and the dynamically typed, modern Lisp Clojure, you'll gain a broad understanding of functional programming.

For each pattern, you'll first see the traditional object-oriented solution, and then dig into the functional replacements in both Scala and Clojure. These patterns are common in the functional world and deserve to become part of your problem-solving toolkit. On the object-oriented side, you'll see many common patterns, such as Command, Strategy, and Null Object. On the functional side, you'll learn core functional patterns such as Memoization, Lazy Sequence, and Tail Recursion.

Each pattern helps you solve a common programming problem. Working through them gives you a set of patterns you can use to solve problems you come across while writing programs. Finally, you'll learn how to work your existing Java code into new Scala or Clojure projects. You can start off small, adding functional code little by little, so you can complement your existing knowledge with Scala and Clojure as these languages gain popularity on the JVM.

What You Need

Clojure 1.5 and Scala 2.10.Optionally, Eclipse with plugins.


  • Format: Kindle Edition
  • Dateigröße: 734 KB
  • Seitenzahl der Print-Ausgabe: 250 Seiten
  • ISBN-Quelle für Seitenzahl: 1937785475
  • Gleichzeitige Verwendung von Geräten: Keine Einschränkung
  • Verlag: Pragmatic Bookshelf; Auflage: 1 (23. Oktober 2013)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Word Wise: Nicht aktiviert
  • Verbesserter Schriftsatz: Nicht aktiviert
  • Durchschnittliche Kundenbewertung: Schreiben Sie die erste Bewertung
  • Amazon Bestseller-Rang: #115.533 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?


Es gibt noch keine Kundenrezensionen auf
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern

Die hilfreichsten Kundenrezensionen auf (beta) 3.7 von 5 Sternen 9 Rezensionen
8 von 9 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Challenging and clever 20. Januar 2014
Von Thomas Adkins - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
I like the approach of this book in that it uses a simple web server as its primary example. I find this very meaningful for my work, as much of my work has a networking component. I also like how it starts off with an imperative piece of code that is very similar to the way I, as an imperative programmer of many years, might have done it myself. The authors then take the problem apart from a functional perspective.

I think it is very important to avoid leading readers using only examples which are easily handled with a functional approach. This book achieves this with challenging material. I was surprised that I could not simply read the book and gain a rapid understanding, but had to go and really do the exercises with the author. I am told by a number of experts that this is typical for imperative-minded programmers. But I really want to learn functional programming, so I'm glad I purchased this book!
9 von 9 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen This is not functional programming book 24. August 2014
Von potix2 - Veröffentlicht auf
Format: Kindle Edition Verifizierter Kauf
This is not functional programming book. This book is written for developers that be used to object-oriented programming and interested in functional programming. The first half is rewriting object-oriented design pattern by functional idioms but it's not functional style programming. The last half is about functional programming techniques(i.e. tail recursion, lazy sequence). If you want to learn functional style programming, I couldn't recommend it. You should read another great books like "Scala for the impatient", "Functional programming in scala", "The Joy of Clojure" and so on.
8 von 9 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Not worth the price 23. Mai 2014
Von Zach Klippenstein - Veröffentlicht auf
Format: Kindle Edition Verifizierter Kauf
Can't believe I paid almost $20 for this. The explanations are repetitive and written in a very boring prose. The code examples are hugely oversimplified, and are neither practical nor interesting. Anyone with a half-decent understanding of these patterns could have thought them up, and most could probably do better. The Scala code is often not idiomatic (e.g. using Vectors instead of lists, constructed without the :: constructor). I can't speak for the Clojure, I'm not as familiar with the language.

For one of the more interesting patterns, Memoization, after showing a completely naïve Scala implementation that ignores generics doesn't even try to demonstrate how to correctly use the type system, and instead just hard-codes the specific types being used in the example, I was really curious about what the Clojure code would look like. Instead, he just says there's a standard function to do it. I'm glad it was mentioned, but I would expect a $20 book would at least compare implementations.

I've read blogs that are more in-depth, better-written, and have more useful code examples than this drivel. Don't buy.
2.0 von 5 Sternen Not worth the money 10. August 2015
Von Ramin - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
If you are a complete newbie in FP you might get "something" out of this book. However, the book has many errors and the highlight of that is the cake pattern. At the end he finishes that discussion with "However, this will get us another compiler error...", without clarifying what the next step is. I believe this book approaches the functional programming in a wrong (and simplistic) way.
5.0 von 5 Sternen This books if great for anyone with OO background and covers how to ... 25. Dezember 2014
Von Yevgen Polyak - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
This books if great for anyone with OO background and covers how to apply the OO patterns everybody loves :) in functional fasion. However, when you do functional programming those patterns will be very natural to you.

Functional patterns part is also great. It covers lazy evaluation, mutual recurcion and many others.

You will not find avdanced Scala techniques in this book, but again, very good read for somewhat familiar with Scala syntax and willing to learn how to actally apply functional style patterns in their everyday programming.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.
click to open popover