Functional programming in java
•Download as PPTX, PDF•
0 likes•555 views
This document discusses functional programming in Java 8. It begins by defining functional programming as having first-class functions without side effects, and notes how the order of execution does not matter. It provides examples of imperative versus functional code in Java. The document argues that functional programming is now more viable due to Java 8 features like lambdas and streams, and that it can provide benefits like clarity, maintenance, fewer bugs, and potential performance gains from parallelization. However, sequential streams do not necessarily outperform loops. Overall, it recommends adopting functional idioms like avoiding side effects and using higher-order functions when applicable.
More Related Content
What's hot
What's hot (20)
Viewers also liked
Viewers also liked (14)
Similar to Functional programming in java
Similar to Functional programming in java (20)
Recently uploaded
Recently uploaded (20)
Functional programming in java
- 1. A FUNCTIONAL APPROACH FOR BETTER AND FASTER JAVA. Jason O’Regan
- 2. OVERVIEW What is Functional Programming? Why Now? Examples of functional code in Java 8 Is it better and faster?
- 3. WHAT IS FUNCTIONAL PROGRAMMING? Different Paradigm
- 4. WHAT IS FUNCTIONAL PROGRAMMING? First Class Citizen
- 5. WHAT IS FUNCTIONAL PROGRAMMING? No Side Effects
- 6. FUNCTIONAL PROGRAMMING EXAMPLE val x = 1 + 2 val y = 2 + 3 -- Side Effect val x = { print("foo"); 1 + 2 } val y = { print("bar"); 2 + 3 }
- 7. WHAT IS FUNCTIONAL PROGRAMMING? Execution Order Does not matter
- 8. IMPERATIVE PROGRAMMING EXAMPLE public class SideEffectClass { private int state = 0; public void doSomething(int arg0) { state += arg0; } }
- 9. WHY FUNCTIONAL PROGRAMMING NOW? Rise of the Machines
- 10. WHY FUNCTIONAL PROGRAMMING NOW?
- 11. WHY FUNCTIONAL PROGRAMMING NOW?
- 12. WHY FUNCTIONAL PROGRAMMING IN JAVA?
- 13. WHY FUNCTIONAL PROGRAMMING IN JAVA?
- 14. WHY FUNCTIONAL PROGRAMMING IN JAVA?
- 15. IMPERATIVE JAVA EXAMPLE private static final int THRESHOLD = 20; private static final double EXCHANGE_RATE = 1.5d; final List<BigDecimal> prices = Arrays.asList(new BigDecimal("11"), new BigDecimal("40"), new BigDecimal("17.5"), new BigDecimal("21"), new BigDecimal("13"), new BigDecimal("22"), new BigDecimal("56")); BigDecimal totalOfPrices = BigDecimal.ZERO; for (BigDecimal price : prices) { if(price.compareTo(BigDecimal.valueOf(THRESHOLD)) > 0){ totalOfPrices = totalOfPrices.add(price.multiply(BigDecimal.valueOf(EXCHANGE_RATE))); } } System.out.println("Total of fx prices: " + totalOfPrices);
- 16. FUNCTIONAL JAVA EXAMPLE final BigDecimal totalOfPrices = prices.stream() .filter(price -> price.compareTo(BigDecimal.valueOf(THRESHOLD)) > 0) .map(price -> price.multiply(BigDecimal.valueOf(EXCHANGE_RATE))) .reduce(BigDecimal.ZERO, BigDecimal::add); System.out.println("Total of fx prices: " + totalOfPrices);
- 19. IS IT BETTER? Less Bugs
- 20. IS IT FASTER?
- 21. IS IT FASTER? Lazy Evaluation of Streams
- 23. FUNCTIONAL JAVA PARALLEL EXAMPLE final BigDecimal totalOfPrices = prices.stream() .parallel() .filter(price -> price.compareTo(BigDecimal.valueOf(THRESHOLD)) > 0) .map(price -> price.multiply(BigDecimal.valueOf(EXCHANGE_RATE))) .reduce(BigDecimal.ZERO, BigDecimal::add); System.out.println("Total of fx prices: " + totalOfPrices);
- 24. IS IT FASTER?
- 25. FUNCTIONAL JAVA PRIMES EXAMPLE 500,000 random integral values, search for the maximum value int m = Integer.MIN_VALUE; for (int i : myList) if (i>m) m=i; int m = myList.stream().reduce(Integer.MIN_VALUE, Math::max); ArrayList, for-loop : 6.55 ms ArrayList, seq. stream: 8.33 ms ArrayList, Parallel 3.35ms
- 26. IS IT FASTER? Sequential streams are no faster than loops. Streams are easier to parallelize.
- 27. IS IT FASTER?
- 28. GOOD PRACTICES
- 32. WHAT’S IN IT FOR ME?
- 33. WHAT’S IN IT FOR ME? Worth the Investment
- 34. RESOURCES
- 35. RESOURCES OO vs FP - http://blog.cleancoder.com/ Parallel Streams and Spliterators - https://thecannycoder.wordpress.com How fast are Java 8 Streams? - Angelika Langer Lambdas and Streams in Java 8 Libraries – Brian Goetz
Editor's Notes
- Check everyone can hear. Quick introduction on myself Java developer for 15 years experience
- This slide tells what is going to be covered in the presentation itself Brief overview of Functional Programming and how it is different to Java. A simple java code example in imperative style and then functional. Examining the pros + cons of doing it this way.
- FP is just a different programming paradigm Have we got many functional programmers here today? Java 8, Scala, Clojure Roots in mathematics What are the facets of FP?
- 1. Nothing to do with civil rights movement 2. Means the language supports passing functions as arguments to other functions.
- Purely functional functions have no side effects. Basically no state modification – e.g. Of arguments or global state – Immutable state. Data is transformed rather than modified. Order of execution
- Side effects example in scala With No side effects – we can evaluate the expressions in any order In example 2 we cannot reverse the order of evaluation
- Execution Order does not matter as there are no side effects in functions. This has an implication with regard to multi-threading
- Java is an imperative language This means it uses statements to reach a certain goal – It change the programming state. Each statement is executed in sequence
- Has side effects Result will be different dependent on the input order called if called multiple times.
- Functional programming has been around for a long time. Lisp was around in late 1950s Bigger, faster machines, multicore platforms – make use of the hardware – parallel processing
- Facilitates the ability to pass functions remotely to operate on data locally. By removing side-effects and mutability – facilitates code distribution over several CPUs – makes concurrent programming easier.
- New languages – make it easier to adopt. It have becomes more mainstream – Twitter, linked In etc.
- Is it just Java jumping on the bandwagon? C# has lambdas, Scala etc – shouldn’t we do something?
- Let give them some nicer syntax like other languages?
- Big question for me as a java developer – is what is in it for me – if I learn this new stuff Let’s See
- Going to give you a simple example written imperatively and then rewrite it in functional style. A Simple example – given a list of prices – convert with the exchange rate and add the ones above a certain threshold. Starts with the mutable variable and loops through the prices and any that pass the threshold – multiplies by the exchange rate and add those to the total. It prints: Total of fx prices: 208.5
- 1. This example uses stream and lambdas from java 8. 2. There is a higher level of abstraction here – which is closer to the requirement and easier to understand 3. Read aloud – filter the prices greater than threshold, map the prices to the exchange rate and add them up. 4. Instead of iterating over prices we invoked stream() method on list which gives access to a special iterator and functions like filter() and map(). 5. Stream: Represents a sequence of values and exposes a set of aggregate operations that allow us to express common manipulations on these values easily and clearly 6. Libraries have been updated to provide convenient ways to obtain stream view. Stream operations chain together into pipelines 6. These functions take a lambda expression(anonymous function)
- More concise and clear –but more succinct. Matches requirements better
- less code to write, read, maintain. Free of low level stuff. - libraries take care of iteration.
- Free of low level stuff. - libraries take care of iteration. Avoided mutation – often a cause of bugs. Personally I have seen a lot of instances of mutable state in Domain objects being a big cause of bugs.
- Less code, faster to develop for coder once you are used to it Less time fixing bugs and maintaining
- Streams use lazy evaluation Intermediate operations like filter /mapping can be thought of as lazy. Facilitates single pass execution on entire pipeline In example you fuse filter + map+ reduce - lazy operations are being applied to aggregates. Each stage takes a stream of input values, performs some transformation on it and passes the values to the next stage in the pipeline. Value producing operations can be thought of as eager Methods like anyMatch or findfirst while eager can use short-circuiting to stop processing once they can determine a final result. Processing streams lazily enables the Java compiler and runtime to optimize how they process streams Good article in Dr Dobbs from Brian Goetz on Lambdas and streams.
- Easier to add concurrency
- 1. The same example – multithreaded. Just added Parallel(). 2. Very fast way of Parallelizing. 3. Brian Goetz – “Our goal is explicit but unobtrusive parallelism” - make it easier but not invisible
- Well 2 articles shine some light on this – cannycoder and how fast are java 8 streams. Neither are conclusive and it all depends on circumstances.
- 1. Example taken from “How fast are Java 8 streams?” Angelika Langer 2. Setup – Some outdated hardware – dualcore with proper warmup. 3. So JIT compiler has had a lot of time to optimise for loops and streams are new, so compiler does not yet perform sophisticated optimizations yet. 4. Also only comparing integers – if the functionality applied to each element is cpu intensive – the difference is likely to be insignificant. 5.
- Streams are sometimes slower than loops – but they can be equally fast, it depends on the circumstances. But sequential streams are no faster than loops. Conclusion : For sequential streams you are going because you like the style and it is easier to maintain Streams are easy to add parallel()
- CannyCoder - Parallel – is faster then non multi-threaded - but custom multi-threading is faster - a lot more error prone though You might also conclude that parallel stream is quicker than sequential. – depends on splitability of the stream source, Another aspect is statefulness of stream – e.g. Distinct() operation. In order to decide if distinct need to compare to each element. Could be significantly slower than sequential. Performance model of streams is not trivial, so you can’t generalize . You need to be informed on how streams work. You need to benchmark your solution.
- A lot of these practices are good practices anyway. Avoid mutability where possible – avoid setters – builders, defensive copies. – see Effective java
- Functions that have side effects impose ordering. Make program more stateless where possible.
- Statements perform actions but don’t return anything, whereas expressions perform actions and return a result Again minimizing statefulness.
- Pass functions as arguments More concise and in line with business requirements. lightweight approach to separating concerns Recommend reading – chapter 4 on designing with Lambdas expressions. Also good book Functional programming patterns in Scala and Clojure
- Writing more concise and expressive code. Code that is easier to maintain. Easier Concurrency. Another tool in the toolbox.
- Invest some time in yourself – it is worth the investment. Will make you a better programmer