Functional Thinking
Functional Programming using Java, Clojure and Scala
Publisher: O'Reilly Media
Final Release Date: April 2013
Run time: 3 hours 46 minutes

Learning the syntax of a new language is easy, but learning to think under a different paradigm is difficult. This video from renowned software architect Neal Ford helps you transition from a Java-writing imperative programmer to a functional programmer, using Java, Clojure and Scala as examples.

Rather than focus on specific language features, Functional Thinking looks at a variety of common practices in OOP languages and then shows you how to solve the same problems using a functional language. For instance, you know how to achieve code-reuse in Java via mechanisms such as inheritance and polymorphism. Code reuse is also possible in functional languages, using high-order functions, composition, and multi-methods.

Ford encourages you to value results over steps, so you can begin to think like a functional programmer. Expect your mind to be bent, but you’ll finish with a much better understanding of both the syntax and semantics of functional languages. This video is ideal for any experienced programmer.

Topics include:

  • Shifting Paradigms: Filter, map, reduce
  • Ceding control: Currying and partial application; recursion
  • Evolution: Memoization; closures
  • Nailgun-driven development: Concurrency, Function composition, coupling vs. composition, functional data structures, monads
  • Bendability: Dispatch, meta-programming, DSLs, macros
  • Why you should care
Table of Contents
Product Details
About the Author
Recommended for You
Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews
oreillyFunctional Thinking
 
4.5

(based on 17 reviews)

Ratings Distribution

  • 5 Stars

     

    (10)

  • 4 Stars

     

    (5)

  • 3 Stars

     

    (2)

  • 2 Stars

     

    (0)

  • 1 Stars

     

    (0)

100%

of respondents would recommend this to a friend.

Pros

  • Easy to understand (16)
  • Helpful examples (15)
  • Accurate (8)
  • Well-written (4)
  • Concise (3)

Cons

    Best Uses

    • Intermediate (12)
    • Novice (8)
    • Student (7)
    • Expert (4)
      • Reviewer Profile:
      • Developer (15)

    Reviewed by 17 customers

    Sort by

    Displaying reviews 1-10

    Back to top

    Previous | Next »

     
    3.0

    Not completely worth the money

    By Rastko

    from Serbia

    About Me Developer

    Verified Buyer

    Pros

    • Concise
    • Easy to understand
    • Helpful examples

    Cons

    • Not comprehensive enough
    • Too basic

    Best Uses

      Comments about oreilly Functional Thinking:

      I expected a bit more from these videos.
      Well, looks like Mr Ford has gathered all his stuff, specifically teaching sessions he gave recently and compiled them into couple of other teacning sessions (some of those videos are available on youtube).

       
      5.0

      Great overview and introduction into FP

      By MrSafferty

      from London, UK

      About Me Developer

      Verified Buyer

      Pros

      • Accurate
      • Easy to understand
      • Helpful examples
      • Well-written

      Cons

        Best Uses

        • Expert
        • Intermediate

        Comments about oreilly Functional Thinking:

        I like Neal Fords style of teaching - he's knowlageable and able to convey new ideas in an approachable manner.

        I have years of OO experience and found that this series covers a number of new core FP ideas well - I'd definately recommend it.

        (1 of 1 customers found this review helpful)

         
        5.0

        Functional Thinking is... functional

        By Jim S.

        from Seattle, WA

        About Me Developer

        Verified Reviewer

        Pros

        • Accurate
        • Concise
        • Easy to understand
        • Helpful examples

        Cons

          Best Uses

          • Expert
          • Intermediate
          • Novice
          • Student

          Comments about oreilly Functional Thinking:

          I've reviewed Neal Ford's "Functional Thinking" video series as part of O'Reilly's bloggers program and I must say it is one of the best videos I've seen.

          I'm familiar with functional programming techniques from other languages, but I wish I had originally learned some of the concepts from this video. For example, when Neal gives an example of currying versus partial application, I felt like any developer I know would fully understand the difference between the two (not an easy feat).

          Neal covers quite a bit of ground in this video, and he does it in a way that is easy to follow and clearly understand. One of the things I liked best about this video series is how examples are given in a format of first demonstrating code in an object-oriented Java snippet followed by a transitional snippet that is somewhat more functional, then a final fully functional example in one or more functional languages.

          That said, I also think this video series could have done without all of the Clojure examples. It was nice to see Groovy, Scala, and some functional Java examples. I feel like the content matter would have been a little more effective to someone unfamiliar with functional programming without the common shock of trying to discern a Lisp-style language.

          I especially enjoyed Neal's discussion about the paradigm shift from object-oriented programming to more functional programming. He is able to support this with concrete examples of functional concepts like map/fold, functional data structures, preferring composition over inheritance, and a lot more that I think any developer of any experience level would benefit from watching.

          I'd recommend this video series to everyone interested in functional programming.

          (1 of 1 customers found this review helpful)

           
          5.0

          Excellent!

          By Jason Irwin

          from Washington, DC

          About Me Developer

          Verified Reviewer

          Pros

          • Easy to understand
          • Helpful examples
          • Well-written

          Cons

          • Too short

          Best Uses

          • Expert
          • Intermediate

          Comments about oreilly Functional Thinking:

          Functional Thinking by Neil Ford of Thoughtworks is another great series in the O'Reilly video library. As I've come to expect from O'Reilly videos, the production quality, picture and audio are excellent. The content is also pretty great. The key to this title is in the name - Functional Thinking. The aim of these videos isn't to teach a specific functional programming language, and you won't be fluent in a specific language as a result of watching them. Instead, the focus is on thinking a little bit differently. As Mr. Ford emphasizes: learning functional programming isn't comparable to learning a new language - it is a new way of thinking. This is a very important distinction and one i'm glad that the author made.

          I'd recommend this title for seasoned developers who are new to the functional programming world. The videos seem intended for use by those already schooled in object-oriented paradigm and detail numerous mechanisms employed by functional languages, why they are beneficial and how such mechanisms are permeating into existing mainstream (traditionally object-oriented) languages. The series does not focus on one specific language (though as suggested by the course title Java is often used as the base OOP language for comparison purposes) with Mr. Ford leveraging examples from Gradle, Clojure and Scala to illustrate his points. A little Java knowledge won't go astray - but developers with experience in any OOP language should be able to follow along.

          The author clearly has a deep understanding of content and is very engaging throughout (I was also impressed at his ability to answer random/difficult questions from the audience). He makes the content extremely accessible and does a great job of explaining constructs available in functional programming that don't necessarily exist in other languages (first class functions, closures, etc.). To do so, he provides simple examples in OOP languages and iteratively refactors them into their functional counterparts. Along the way he explains the history and the thought process behind the designs of the constructs being discussed.

          I learned a lot from this video series, not only about the benefits of specific functional constructs, but also issues with some OOP concepts that I have for a long time taken for granted (for instance, coupling introduced by polymorphism and limitations to dispatch mechanisms). You won't be able to write your first program using a functional programming language as a result of watching this course. However, you may just think differently about how you code. I highly recommend this series.

          (5 of 5 customers found this review helpful)

           
          3.0

          Functional program appreciation for java

          By Mark

          from Portland, OR

          Verified Reviewer

          Pros

          • Easy to understand
          • Engaging

          Cons

          • No real world examples
          • Not Enough Depth

          Best Uses

          • Expert Java
          • Novice Functional

          Comments about oreilly Functional Thinking:

          Neal Ford is an good teacher and the format of a small seminar with 6 students makes it more intimate and engaging than just a talking head or a conference speaker.

          The lectures follow very closely a series of blog posts that Neal Ford made on the www.ibm.com/developerworks website. I found it very useful to go to the blog pages when a topic went by faster than I could comprehend it.

          These lectures are essentially a sales talk for functional programing aimed at Java programmers.

          He emphasizes that functional thinking can be done in a number of languages and presents examples that run on the JVM: Java, Groovy, Clojure and (just barely) Scala. But this is definitely not a course on how to program in any of these languages.

          I confirmed his assertion that the techniques are independent of language by coding most of the exercises in Python.

          Having said that its the functional thinking not the language, his target audience is Java programmers. Most of the examples are in Java: sometimes Java is enhanced with the Functional Java or Totally Lazy libraries.

          The examples often show how to achieve a result using a functional approach in Java. It frequently quickly becomes apparent that doing functional things in a different language would be much easier. Ford often switches to showing how much easier it is in Groovy.

          Despite the title "Functional Thinking: Functional Programming using Java, Clojure and Scala", I was disappointed to find that there is practically nothing about Scala in the lectures. And what there is, is not done well. The students in the seminar point out that several of the few Scala examples have errors or are non-idiomatic Scala. In addition one of the Scala examples, one discussing "Some/None", is not in Scala at all: it is in Java.

          More true to the title are the examples in Clojure. Ford repeatedly plugs the strengths of Clojure.

          The best part of the series are the two examples where he starts with a program written in Java and through a series of simplifying transformations ends up with a dramatically simpler and cleaner program in Clojure.

          I suspect that he has cheated a bit by picking examples that look particularly good using the functional approach. The Clojure code looks clean and simple partly because of the functional style, but also partly because the Clojure code doesn't have any type checking or declaration of public/private methods or error trapping and Clojure just happens to have a relevant built in function.

          As I said earlier Ford is consistantly pro functional. He never alludes to any problems or traps that the novice getting into functional programming should be aware of.

          For example Ford repeatedly emphasized that one of the main advantages of functional programming is that you can reason about the code because a function always returns the same result when given the same input. However, he gives an example of using closure which creates a counter. The counter gives a different value each time it is called. He never gives any guidance on whether this counter is consistant or messes up the much touted ability to think about the code in a functional way.

          The length of the course constrained him to present only toy examples (for instance calculating prime numbers). This lack of real world examples means you don't get a feel for how well the functional approach would work in real applications which have to treat bad data and other exceptional conditions.

          The whole lecture on Functional Data Types was showing how to implement a data structure called "Either" or sometimes "Option" or "Some". This is intended to be used in place of throwing exceptions. But there was no real explanation of how you use this data structure to do error handling. A comment on the Neal Ford's IBM Developerworks blog questions his use of this technique, but Ford didn't rebut this attack.

          In summary, this "Functional Thinking" series of videos would be better titled "Functional Thinking Appreciation". In this they succeed: I now appreciate funtional thinking. To really learn to think functionally I will need to go elsewhere.

           
          5.0

          Very good introduction to FP concepts

          By David

          from France

          About Me Developer, Sys Admin

          Verified Reviewer

          Pros

          • Accurate
          • Easy to understand
          • Helpful examples

          Cons

            Best Uses

            • Intermediate
            • Novice
            • Student

            Comments about oreilly Functional Thinking:

            The multiplication of processors and the need to simplify sharing processes between them is driving a functional programming revival.
            Neal Ford does a very good job at presenting Functional Programming concepts, where they shine and how they defer from Object Programming.
            Although all examples are implemented in JVM languages (Java, Groovy and Clojure) it is rather easy to translate them to other functional languages.
            I highly recommend these videos to any programmer.

            (1 of 1 customers found this review helpful)

             
            4.0

            Great intro to functional programming

            By D Witherspoon

            from Colorado Springs, CO

            About Me Developer

            Verified Reviewer

            Pros

            • Accurate
            • Easy to understand
            • Helpful examples

            Cons

              Best Uses

              • Intermediate
              • Novice
              • Student

              Comments about oreilly Functional Thinking:

              Neal Ford does a great job of explaining concepts and presenting solutions that are more functional based thinking and pointing out some of the problems in object oriented thinking. He does a great job in presenting solutions in Java, Groovy, Scala, and Clojure, but don't expect to get a detailed tutorial of these languages since that is no the focus of these videos. If you want to learn about functional programming, the benefits of it, benefits of other concepts like immutable objects, and get a little exposure to a few functional programming languages. Then this is a great collection of videos for you to watch. If you are a die hard object oriented and Java developer and don't want to hear about any possible issues with this paradigm, then you might not want to watch, since he does provide some criticism of both of these. If you can open your mind an accept another persons point on things, then I would recommend seeing things through the functional programming eyes.

              The Functional Thinking video collection does a great job of quickly covering some major topics in functional programming. Some of the areas that I really enjoyed were the use of filter and map, meta-programming, functional data structures, and overall the bendability of functional languages. He presents the idea that functional languages are more focused on the language bending to solve the problem vs bending the problem to fit the language. I think this is a very interesting idea and makes me more interested in learning about Scala or Clojure. I agree that in Java it seems that you have to write a lot of code that is not helping solve the problem, but more building the framework to solve the problem in. I also agree that we should look at approaching the solution to the problem by seeing what language is the best fit and we can do that since all of the languages will run within the same JVM. I forget the term that he used to describe this idea, but agree with him completely on this concept.

              Overall if you are looking for an introduction into why functional programming has been and will continue to gain traction, this is a good collection of videos for you to watch. Keep in mind that this is more of an introduction and you cannot explain everything in under 4 hours of lecture. But I would be that you do walk away thinking about implementing some of the concepts in your Java code, like immutability, favor composition over inheritance, and/or get you really excited for lambda functions that should be coming in Java 8.

               
              5.0

              Vey well covered

              By tushar

              from CA

              About Me Designer, Developer

              Verified Reviewer

              Pros

              • Accurate
              • Easy to understand
              • Helpful examples

              Cons

                Best Uses

                • Intermediate
                • Novice

                Comments about oreilly Functional Thinking:

                Functional Thinking: Functional Programming using Java, Clojure and Scala. Neal Ford is a fantastic teacher. He explains the concepts of Functional Programming in very lucid manner. He explains closure and its usage with very ease.

                The quote "functional is more a way of thinking than a tool set" summarizes the intent of the whole effort. In this video Neal summarizes functional paradigm for java developers. He covers closure, immutability, higher order functions, laziness, Pure Functions, Recursion, Strict Evaluation and others.

                Neal also covers few of the examples using Java, Groovy, Scala, and Closure

                • Neal lists few of the advantages of functional programming:
                Language Evolution: Functional programming is next paradigm after OOP which is affecting all major languages.
                • Immutability of objects frees up the developers from ever changing state of object which enhances productivity.

                This video is an excellent medium for those who want to explore function paradigm.

                 
                5.0

                A better way to think

                By Mark Lai

                from Sacramento, CA

                Verified Reviewer

                Pros

                • Easy to understand
                • Fantastic Teacher
                • Helpful examples

                Cons

                  Best Uses

                  • Intermediate

                  Comments about oreilly Functional Thinking:

                  Functional Thinking: Functional Programming using Java, Clojure and Scala. Neal Ford is a fantastic teacher in this video. He succinctly explains what closure means and how it works better than any articles I've seen on the web.

                  The quote "functional is more a way of thinking than a tool set" summarizes the intent of the video. Neal covers various functional programming topics such as currying, memoization, laziness, and shows examples in Clojure, Scala, Groovy, and even Java (to a point). Then he continues to demonstrate how functional helps express your code better than imperative programming, and can be more natural language structured than verbose boilerplate code.

                  Borrowing a couple of quotes from Michael Feathers:
                  "OO makes code understandable by encapsulating moving parts."
                  "FP makes code understandable by minimizing moving parts."
                  This video is a good guide in achieving the desired results using functional thinking in the problem domain, and not be mired down in the steps from language limitations.

                   
                  4.0

                  Functional Thinking by Neal Ford, O'Reil

                  By Krzysztof Ropiak

                  from Gdańsk

                  About Me Developer

                  Verified Reviewer

                  Pros

                  • Easy to understand

                  Cons

                    Best Uses

                    • Intermediate
                    • Novice
                    • Student

                    Comments about oreilly Functional Thinking:

                    Neal Ford in his video presents functional programming's foundations and principles as he believes that this paradigm is going to dominate software development as mainstream technologies are including its features more and more.

                    He believes that learning syntax of new programming language is easy, so instead teaches you about new way of thinking. Examples of code that are shown in the video present those ideas in languages like Groovy, Closure, Scala or even Java. But the speaker doesn't really try to give you comprehensive lesson about syntax of these languages. He discusses the basics of the paradigm that stands behind that new syntax.

                    Topics that are covered in the video include background of functional programming: immutability, higher order functions, laziness and other topics. There are also points when speaker contrasts new principles with object oriented design. I particularly liked the part where Neal teaches you that functional programming is about separating "how" and "what" needs to be done, so that you can make "how" part the problem of someone else. The lesson I learned is that you can use functional programming to minimize number things you need to worry about.

                    I feel that people that would benefit the most of watching this video are software developers that have already experience in object oriented technologies like Java or .NET and want to learn new concepts whose role is getting larger and larger in programming. If a developer is new to functional thinking I can definitely recommend him Neal's video .

                    Displaying reviews 1-10

                    Back to top

                    Previous | Next »

                     
                    Buy 2 Get 1 Free Free Shipping Guarantee
                    Buying Options
                    Immediate Access - Go Digital what's this?
                    Video: $99.99
                    (Streaming, Downloadable)