Download Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz
Do you understand why you ought to review this site as well as just what the relationship to reviewing book Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz In this modern era, there are lots of methods to obtain guide as well as they will be much less complicated to do. Among them is by obtaining the publication Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz by online as just what we inform in the web link download. Guide Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz can be a choice considering that it is so appropriate to your need now. To obtain guide on-line is very easy by only downloading them. With this possibility, you can check out guide wherever as well as whenever you are. When taking a train, waiting for listing, as well as hesitating for an individual or various other, you can read this online publication Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz as a buddy once again.
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz
Download Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz
When you are hurried of work target date as well as have no concept to get motivation, Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz book is among your remedies to take. Reserve Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz will provide you the right resource and thing to obtain motivations. It is not only regarding the works for politic business, administration, economics, and various other. Some bought works to make some fiction your jobs likewise require inspirations to overcome the job. As just what you require, this Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz will most likely be your choice.
As we specified previously, the innovation helps us to always identify that life will certainly be constantly simpler. Reading e-book Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz habit is additionally one of the perks to obtain today. Why? Technology could be utilized to offer the e-book Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz in only soft documents system that could be opened every time you desire and all over you need without bringing this Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz prints in your hand.
Those are several of the advantages to take when obtaining this Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz by on the internet. Yet, how is the method to obtain the soft documents? It's very best for you to see this web page since you could obtain the web link page to download and install guide Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz Just click the link given in this post as well as goes downloading. It will certainly not take much time to obtain this publication Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz, like when you require to go for publication store.
This is likewise one of the factors by getting the soft file of this Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz by online. You could not need even more times to spend to visit guide store as well as search for them. Often, you likewise don't locate guide Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz that you are looking for. It will certainly waste the moment. But here, when you see this web page, it will certainly be so simple to obtain as well as download guide Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz It will not take sometimes as we explain in the past. You can do it while doing another thing at home or also in your workplace. So very easy! So, are you question? Just exercise exactly what we provide here and check out Learning Scala: Practical Functional Programming For The JVM, By Jason Swartz just what you like to review!
Why learn Scala? You don’t need to be a data scientist or distributed computing expert to appreciate this object-oriented functional programming language. This practical book provides a comprehensive yet approachable introduction to the language, complete with syntax diagrams, examples, and exercises. You’ll start with Scala's core types and syntax before diving into higher-order functions and immutable data structures.
Author Jason Swartz demonstrates why Scala’s concise and expressive syntax make it an ideal language for Ruby or Python developers who want to improve their craft, while its type safety and performance ensures that it’s stable and fast enough for any application.
- Learn about the core data types, literals, values, and variables
- Discover how to think and write in expressions, the foundation for Scala's syntax
- Write higher-order functions that accept or return other functions
- Become familiar with immutable data structures and easily transform them with type-safe and declarative operations
- Create custom infix operators to simplify existing operations or even to start your own domain-specific language
- Build classes that compose one or more traits for full reusability, or create new functionality by mixing them in at instantiation
- Sales Rank: #193198 in Books
- Brand: Swartz, Jason
- Published on: 2014-12-28
- Released on: 2014-12-18
- Original language: English
- Number of items: 1
- Dimensions: 9.19" h x .58" w x 7.00" l, .0 pounds
- Binding: Paperback
- 256 pages
About the Author
Jason is a Software Engineer in the San Francisco Bay Area, developing Scala applications at Loyal3 and Netflix. Before making the switch to functional programming he managed the developer docs and support team at eBay, wrote advertising and merchandising platforms in Java and built tools and UI prototypes at Apple.
Most helpful customer reviews
14 of 15 people found the following review helpful.
Mostly Type-Along Tutorial-Style
By frankp93
Read a little, type in several lines of code, read some more.
At least three quarters of the book amounts to a language feature survey using the command-line ‘REPL’ (‘interpreter’ for us downtown folk). There’s nothing wrong with that, per se, so long as it fits your learning style. There’s no end-to-end demo app built throughout the book and none of the code remotely approaches anything standalone or utilitarian.
It’s only in the concluding chapters that the author introduces the SBT, the equivalent of a make tool, as well as one of the Scala IDEs but the coverage is far from in-depth.
In a way, the book reminds me of K&R: It presents isolated examples of good quality code designed to illustrate features while it assumes readers have the architectural insight to build-upon and integrate these into useful applications.
Scala is built on top of the JVM and uses many of the same data types as Java. Obviously a Java background is helpful but so is experience with Python or any LISP-derived dynamic language.
A solid C/C++ background is fine and you’ll notice parallels and conceptual borrowings: Scala’s preference for immutable values over variables is essentially a restatement of the C++ maxim ‘use const wherever possible’ for data safety and easier debugging.
I think the book is inappropriate as a first programming text for beginners. Don’t be fooled by the early elementary examples in the data types chapter (i.e. declaring values, variables and performing basic arithmetic on them). The later chapters on collections, classes and objects assume fairly deep familiarity with OO concepts.
Like the better O’Reilly titles, ‘Learning Scala’ is very thorough and well-written, again, with something of a K&R vibe about it (maybe it’s the Fahrenheit/Celsius conversion examples - even the code fonts scream ‘Bell Labs’).
But the language is less terse than K&R, more pleasant to read with even a subtle sense of humor.
In the end the book makes a fairly convincing case for learning Scala as a discipline that can inform and improve the way you code other languages. But for me it doesn’t quite live up to the ‘Practical Functional Programming’ part of its subtitle.
13 of 14 people found the following review helpful.
A Good Book - But Difficult Exercises
By Big Data Paramedic
I have used computer books that go over 500 pages and the very look depresses you. This one is a compact 220 Pages packed with easily understandable information about Scala. Most of you who are looking at buying the book are already software programmers and are looking to expand your Knowledge about Scala; probably because some of your job tasks are going to be done in Scala. You have come to the right place. If you are a newbie or a student, Try starting with Python.
The book has very little history of Scala (One Paragraph), no lame jokes and you have installed necessary tools and your First "Hello World" is on the 5th page itself. The Book takes the developer on a step by step to the next levels , just like many other well written computer books
> First Chapter You write Hello World
> Second Chapter you understand the data types, Variables,Values etc
> That takes you to writing simple conditional if/else type statements
> That is a nice gateway to next chapter writing Functions..I am not going on with it,but you get an idea.
DRAWBACK:
What was frustrating to me was the exercises, which I felt very difficult. I tried to look for answers at the end , or some pointers to how to get it ...No where. It is a learning book and there has to be some answers if I need to refer to. Even if the answers were provided, still there is a disconnect between the level of lessons vs exercise (Write a Centigrade/Fahrenheit conversion formula as an exercise in Chapter2)
SUMMARY:
Scala is a good language to learn. And this book will help. You might need some help every now and then. So find a mentor or a colleague before you begin this journey.
4 of 4 people found the following review helpful.
The best introduction to Scala that I've seen
By Ian K.
Kernighan and Ritchie's book The C Programming Language is the best selling computer science/software book of all time. There are many reasons for the popularity of K&R (as the book has become known). One of those has to do with the structure of the book. Each element of the C programming language is clearly described.
Jason Swartz used a similar approach in his book Learning Scala. He clearly describes the elements of Scala, using the Scala interpreter. Like the challenge of eating an elephant, this allows the reader to learn a complex language, one bite at a time. The organization also makes the book easy to absorb, one chapter at a time, so you can read it in spare moments over a week or two. Each chapter ends with interesting exercises which help solidify what you have learned reading the chapter.
When using a new programming language I always need a reference that I can fall back on ("How do you define an array in Scala?) The organization of Learning Scala also lends itself well to being a reference as you write larger codes.
So why might you want to learn Scala? Scala runs on the Java Virtual Machine which means that you have access to the vast Java libraries from Oracle, Apache and elsewhere. However, Scala is a newer language with less attachment to existing software. This has made the designers free to encompass many new programming language concepts in Scala. The compiled/interpreted nature of Scala has also allowed it to be used in some of the leading edge "big data" frameworks like Spark (Learning Spark: Lightning-Fast Big Data Analysis)
I have been using the R statistics language heavily for the last few years. One of the things that I like in R, which I miss in Java, is the ability to interactively try things out in R. This allows you to interactively experiment as you develop a code. This can shorten development time and help develop more reliable code.
Learning Scala is focused on using Scala interactively. A minor criticism is that there is only tangential discussion of how interactive experimentation can be used in combination with the development of large compiled Scala applications. At least to me, this is a core attraction of Scala.
Jason Swartz uses the intelliJ IDE for development. I had a really bad experience with the licensed version of intelliJ for developing Grails/Groovy applications. I've used Eclipse successfully for Java, Grails and Scala. The Eclipse environment seamlessly supports both compiled and interactive Scala development. From my point of view, this would have been a better choice in the book than intelliJ.
These criticisms are really minor. This is a great book for learning Scala and I highly recommend it.
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz PDF
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz EPub
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz Doc
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz iBooks
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz rtf
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz Mobipocket
Learning Scala: Practical Functional Programming for the JVM, by Jason Swartz Kindle
Tidak ada komentar:
Posting Komentar