Página inicialGruposDiscussãoMaisZeitgeist
Pesquise No Site
Este site usa cookies para fornecer nossos serviços, melhorar o desempenho, para análises e (se não estiver conectado) para publicidade. Ao usar o LibraryThing, você reconhece que leu e entendeu nossos Termos de Serviço e Política de Privacidade . Seu uso do site e dos serviços está sujeito a essas políticas e termos.
Hide this

Resultados do Google Livros

Clique em uma foto para ir ao Google Livros

Functional Programming in Scala de Paul…
Carregando...

Functional Programming in Scala (edição: 2014)

de Paul Chiusano (Autor), Rúnar Bjarnason (Autor)

MembrosResenhasPopularidadeAvaliação médiaConversas
813266,297 (4.35)Nenhum(a)
Summary Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the Technology Functional programming (FP) is a style of software development emphasizing functions that don't depend on program state. Functional code is easier to test and reuse, simpler to parallelize, and less prone to bugs than other code. Scala is an emerging JVM language that offers strong support for FP. Its familiar syntax and transparent interoperability with Java make Scala a great place to start learning FP. About the Book Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to their everyday work. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming. This book assumes no prior experience with functional programming. Some prior exposure to Scala or Java is helpful. What's Inside Functional programming concepts The whys and hows of FP How to write multicore programs Exercises and checks for understanding About the Authors Paul Chiusano and Rúnar Bjarnason are recognized experts in functional programming with Scala and are core contributors to the Scalaz library. Table of Contents PART 1 INTRODUCTION TO FUNCTIONAL PROGRAMMING What is functional programming? Getting started with functional programming in Scala Functional data structures Handling errors without exceptions Strictness and laziness Purely functional state PART 2 FUNCTIONAL DESIGN AND COMBINATOR LIBRARIES Purely functional parallelism Property-based testing Parser combinators PART 3 COMMON STRUCTURES IN FUNCTIONAL DESIGN Monoids Monads Applicative and traversable functors PART 4 EFFECTS AND I/O External effects and I/O Local effects and mutable state Stream processing and incremental I/O… (mais)
Membro:dmiserak
Título:Functional Programming in Scala
Autores:Paul Chiusano (Autor)
Outros autores:Rúnar Bjarnason (Autor)
Informação:Manning Publications (2014), Edition: 1st, 320 pages
Coleções:Sua biblioteca
Avaliação:
Etiquetas:Nenhum(a)

Detalhes da Obra

Functional Programming in Scala de Paul Chiusano

Nenhum(a)
Carregando...

Registre-se no LibraryThing tpara descobrir se gostará deste livro.

Ainda não há conversas na Discussão sobre este livro.

Exibindo 3 de 3
It's clear that a lot of love for the subject went into the making of the book. I thought I knew functional programming pretty well but I was humbled and learnt a lot. The additional notes on the fpinscala wiki all well worth the read. I still have a lot of fascinating things to follow up! ( )
  steshaw | Dec 29, 2016 |
It is safe to say that “Functional Programming in Scala” by Chiusano and Bjarnason can be considered the most advanced Scala programming book published so far (in a sense, it can be compared to SICP.). Half of one of my bookshelves is occupied by Scala books, including Scala in Depth, but none of them takes the concept of functional programming as serious as this book, and pushes it to its limits that much. This, in turn, means that most of the Java programmers (including very senior ones), as well as Scala programmers with some experience should prepare themselves to feel very much like a newbie again.

But why the need for such a book, and what’s all that noise about functional programming? Here is my favorite description of functional programming given by Tony Morris : “Supposing a program composed of parts A, B, C, D, and a requirement for program of parts A, B, C, and E. The effort required to construct this program should be proportional to the size of E. The extent to which this is true is the extent to which one achieves the central thesis of Functional Programming. Identifying independent program parts requires very rigorous cognitive discipline and correct concept formation. This can be very (very) difficult after exposure to sloppy thinking habits. Composable programs are easier to reason about. We may (confidentally) determine program behaviour by determining the behaviour of sub-programs -> fewer bugs. Composable programs scale indefinitely, by composing more and more sub-programs. There is no distinction between a ‘small’ and a ‘large’ application; only ‘smaller than’ or ‘greater than’.”

The description above not only points at the core idea of functional programming and why that is important, as well as useful, but also draws attention to the fact that getting used to functional programming design can be difficult for people who are not used to thinking that way. Fortunately, “Functional Programming in Scala” is here to fill a huge void in that respect.

The book can be considered one of its kind, not only because of its strong logical foundations, starting from first principles and rigorously following them to their consequences, but also for its pedagogical approach. Even though it is aimed at practicing programmers and not academics, every chapter includes a lot of exercises arranged in a very nice developmental manner. But make no mistake, this also means that you cannot simply read that book, you can only study it. This, in turn, means that the only way to read the book is to run your favorite Scala coding environment, grab the exercises’ source code (and in case you are stuck, hints, as well as answers) from https://github.com/fpinscala/fpinscala, and start solving the exercise by implementing the required functions and other stubs. Moreover, you should do yourself a favor and also take into account the extra reading at https://github.com/fpinscala/fpinscala/wiki.

Depending on your level of Scala, e.g. if you have successfully completed the Coursera course titled “Functional Programming Principles in Scala” by Odersky, you can finish the first few chapters and exercises relatively quickly, but I would suggest to take your time after the first few chapters, 1-2 weeks per chapter will probably be an adequate pace for experienced programmers.

I can recommend this book to serious, curious, brave,and open-minded developers who target JVM by using Scala, and want less duplication, less boilerplate and much more powerful abstractions that are also easier to reason about, and who are ready to invest time to slowly digest the material by doing exercises instead of trying to quickly skim the text. ( )
  EmreSevinc | Sep 13, 2014 |
This book should be required reading for anyone wanting to really learn and understand Scala. It's not that the book will necessarily give you mastery of the language -- only time and experience gained through writing lots of code can do that, though they help by giving the reader lots of good exercises. But it will alter your view of the language and very likely teach you a new way of approaching problems. The authors are both expert Scala engineers with deep understanding of the principles of functional programming. Their approach is illuminating, in particular, in showing how you can apply the type system and referential transparency to solve problems using very generalizable patterns.

Addendum to my earlier posting of this, initially very brief, review:

First, it's worth noting that this book in no way requires you to learn or use Scalaz, though both authors are contributors to that library. It will teach you what you need to better understand Scalaz, but it also leaves a lot out. For example, the current pre-release draft of the book doesn't even mention type classes. In my opinion, this is a good thing. There are other books, such as [a:Joshua Suereth|4849384|Joshua Suereth|https://www.goodreads.com/assets/nophoto/user/u_50x66-d9f6a4a5badfda0f69e70cc94d962125.png]'s fantastic [b:Scala in Depth|11353552|Scala in Depth|Joshua Suereth|https://d202m5krfqbpi5.cloudfront.net/books/1367918492s/11353552.jpg|16283389], that do a very good job of this already. And covering this material here would only take away from the core of what this book attempts to teach.

Finally, I should note that I was both a technical reviewer of earlier drafts and did the final technical proofreading. So hold me responsible for any errors that slipped through!! Well, not really! ;~) I was (well, will be) compensated for both of these (a free book in the first case and a small monetary amount in the second), but I can tell you truthfully that in no way did this influence my review of this book. If anything, my experience proofreading this gave me an interesting insight into the book. Having tech reviewed and proofread many other books, I was floored by how few technical errors (remember, I was not reviewing their language or grammar) I was able to find. I personally believe this may demonstrate something interesting about the diligent effort the authors put into this book.

Additional notes:

This book is a good one to work through with others, particularly given the exercise driven nature of it. At Janrain, where I am currently employed, we started a study group to work through it. We initially planned a week per chapter, but found even this was overly aggressive at times. It's best to find the rate that works for the group and adjust as needed.

As I mention in one of my comments below to my friend and coworker Sean, this is probably nto the best book to use as an introduction to Scala. The authors do a good job of introducing the features you need to work through the book (though I did see a few places where they leave the reader to find more on her own), it won't give you the breadth you really need to become proficient. That said, if you do choose to pick up a book, such as [b:Scala for the Impatient|11335855|Scala for the Impatient|Cay S. Horstmann|https://d202m5krfqbpi5.cloudfront.net/books/1348110005s/11335855.jpg|16264400], you can certainly work through both in tandem if you're really in a hurry.
( )
  tlockney | Sep 7, 2014 |
Exibindo 3 de 3
sem resenhas | adicionar uma resenha

» Adicionar outros autores (2 possíveis)

Nome do autorFunçãoTipo de autorObra?Status
Paul Chiusanoautor principaltodas as ediçõescalculado
Bjarnason, Rúnarautor principaltodas as ediçõesconfirmado
Você deve entrar para editar os dados de Conhecimento Comum.
Para mais ajuda veja a página de ajuda do Conhecimento Compartilhado.
Título canônico
Título original
Títulos alternativos
Data da publicação original
Pessoas/Personagens
Lugares importantes
Eventos importantes
Filmes relacionados
Premiações
Epígrafe
Dedicatória
Primeiras palavras
Citações
Últimas palavras
Aviso de desambiguação
Editores da Publicação
Autores Resenhistas (normalmente na contracapa do livro)
Idioma original
CDD/MDS canônico
Canonical LCC

Referências a esta obra em recursos externos.

Wikipédia em inglês

Nenhum(a)

Summary Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the Technology Functional programming (FP) is a style of software development emphasizing functions that don't depend on program state. Functional code is easier to test and reuse, simpler to parallelize, and less prone to bugs than other code. Scala is an emerging JVM language that offers strong support for FP. Its familiar syntax and transparent interoperability with Java make Scala a great place to start learning FP. About the Book Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to their everyday work. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming. This book assumes no prior experience with functional programming. Some prior exposure to Scala or Java is helpful. What's Inside Functional programming concepts The whys and hows of FP How to write multicore programs Exercises and checks for understanding About the Authors Paul Chiusano and Rúnar Bjarnason are recognized experts in functional programming with Scala and are core contributors to the Scalaz library. Table of Contents PART 1 INTRODUCTION TO FUNCTIONAL PROGRAMMING What is functional programming? Getting started with functional programming in Scala Functional data structures Handling errors without exceptions Strictness and laziness Purely functional state PART 2 FUNCTIONAL DESIGN AND COMBINATOR LIBRARIES Purely functional parallelism Property-based testing Parser combinators PART 3 COMMON STRUCTURES IN FUNCTIONAL DESIGN Monoids Monads Applicative and traversable functors PART 4 EFFECTS AND I/O External effects and I/O Local effects and mutable state Stream processing and incremental I/O

Não foram encontradas descrições de bibliotecas.

Descrição do livro
Resumo em haiku

Capas populares

Links rápidos

Avaliação

Média: (4.35)
0.5
1
1.5
2
2.5
3 1
3.5 1
4 5
4.5
5 6

É você?

Torne-se um autor do LibraryThing.

 

Sobre | Contato | LibraryThing.com | Privacidade/Termos | Ajuda/Perguntas Frequentes | Blog | Loja | APIs | TinyCat | Bibliotecas Históricas | Os primeiros revisores | Conhecimento Comum | 163,167,169 livros! | Barra superior: Sempre visível