The document discusses introducing polyglot and functional programming concepts to Java developers. It explains that while Java is a powerful language, other JVM languages can offer advantages like more rapid development, concise coding, and taking advantage of non-object oriented and dynamic approaches. It provides examples of using functional concepts like map and filter to more declaratively operate on collections of data in a Java program. The document suggests exposing developers to these concepts through libraries and by experimenting with other JVM languages.

1. The Well-Grounded Java Developer
Polyglot & Functional Programming

2. This is still not an Oracle legal slide
2

3. Why Polyglot & Functional?
• The WGJD wants to code rapidly
• The WGJD wants to code concisely
• The WGJD wants to take advantage of:
- The JVM
- Non Object-Orientated approaches
- Dynamic language approaches
• Polyglot and functional languages exist on the JVM
- The JVM is no longer tied to Java the language

4. Why Java is not a Golden Hammer
• Recompilation is laborious
• Static typing can be inflexible
- Can lead to long refactoring times
• Deployment is a heavyweight process
- JRebel can mitigate this for web apps
• Java's syntax is not a natural fit for producing DSLs

5. Java is a conservative language
• New language features take a while to arrive in Java
• This is deliberate
• Languages that move quickly can “repent at leisure”
- There are some Scala features which everyone now regrets
• Non-Java languages are a test-bed for features
- A good place to learn and experiment

6. Language Zoology
• Interpreted vs. Compiled
- Interpreted source code is executed as-is
- Compiled code is converted to machine code before
execution
• Dynamic vs. static
- Dynamic variables can have different types at different times
- Dynamic types are only resolved at execution time
- Static types can be resolved much earlier
• Imperative vs. functional
- OO and Procedural are both imperative styles
- Imperative: Code operates on Data
- Functional: Code & Data are one and the same

7. Languages on the JVM
• Over 200! Falling into several broad groupings
• Language re-implementations
- JRuby, Jython
• Attempted Java killers
- Fantom, Ceylon, Xtend, Scala
• Dynamic languages
- Groovy, Rhino, Clojure
• Academic
- Ioke, Seph

8. Polyglot Programming Pyramid
• Courtesy of Ola Bini

9. Ola - JVM languages expert.
Do not talk to him
Your brain will melt
9

10. Polyglot Layers
• Domain-specific
- Tightly coupled to a specific part of the application domain.
- e.g. Apache Camel DSL, Drools, Web templating
• Dynamic
- Rapid, productive, flexible development of functionality
- e.g. Groovy, Jython, Clojure
• Stable
- Core functionality, stable, well-tested, performant.
- e.g. Java, Scala

11. Ask yourself before going Poly
• Is the project area low risk?
• How easily does the language interoperate with Java?
• What tooling support is there?
• Is it easy to build, test & deploy in this language?
• How steep is the learning curve?
- How easy is it to hire developers?

12. Experts: “use < 5 bullet points”
sr&%w that!
12

13. Matt Raible - 20 criteria web frameworks
– Developer Productivity
– Developer Perception
– Learning Curve
– Project Health
– Developer Availability
– Job Trends
– Templating
– Components
– Ajax
– Plugins or Add-Ons
– Scalability
– Testing Support
– i18n and l10n
– Validation
– Multi-language Support
– Quality of Documentation/Tutorials
– Books Published
– REST Support (client and server)
– Mobile / iPhone Support
– Degree of Risk

14. JVM language web framework shoot out
• Grails Wins!
• http://bit.ly/jvm-frameworks-matrix

15. Functional Programming
• Functional Programming is important again
- Multi-core CPUs means that your code can truly run parallel
- map, reduce, filter idioms would be welcome!
• Java's support is mostly missing
- Java 7's Fork and Join provides a bit of Map/Reduce
- How would we want it to work in Java?
• Other languages on the JVM already provide support
- Groovy, Scala, Clojure

16. Example - Reconciliation Service
• We have 2 sources of data
• Source 1 - The upstream system “sourceData”
- e.g Call a web service for transaction records
• Source 2 - The downstream database
• We need a reconciliation system
- Check that data is actually reaching the DB.

17. Reconciliation - Java Take 1

18. Output of Reconciliation - Java Take 1
7172329 OK
7173341 OK
1R6GT OK
1R6GV OK
1R6GW OK
main_ref: 1R6H2 not present in DB
main_ref: 1R6H3 not present in DB
1R6H6 OK
623SRC OK

19. Analysing the data
• Q: What’s gone wrong?
• A: Upstream system is case-insensitive
- Whereas the downstream one is case-sensitive
• 1R6H2 is present in the DB
- It’s just called 1r6h2 instead
• Let’s go back to the code slide
- Can anyone see a problem with the code now?
• There’s no containsCaseInsensitive() method
- This is an irritant

20. Reconciliation - Fixing Case Sensitivity
• With this:

21. Functional Realisation
• If you’ve ever found yourself writing collections code
• And get frustrated because...
- There’s a method which almost provides a way..
- To do what you need..
- But you just need to tweak it slightly..
• Then that frustration is an itch
- That could be scratched by functional programming!

22. Introducing Functional Concepts
• Two ideas related to FP in the previous example
• First idea is:
- Operating on collections / data structures as a whole
- Rather than explicitly iterating over their contents
• Second idea is:
- A lack of capability to add additional logic to existing
methods
• Both ideas help with writing concise, safer OO code

23. What if we could...
• Tweak the functionality of a method?
- By adding in some new code of our own?
• We’d need to pass the code into the method
- As a parameter.
• We'd need some way to treat the as if it was a value
- We want to be able to put it into a variable.
• FP requires the ability to represent bits of logic as
though they were values.

24. Reconciliation - With Match Function

25. Library Support
• There’s no actual 2-parameter contains() method.
• But that’s what we would want, if we could start again
• Other languages have this functionality
- Called: Lambda expressions, closures, function literals..
• Need library support as well as the language primitive

26. “What if” is for namby pamby
dreamers
26

27. The Map Pattern
• FP fans would call this a map expression
- extractPrimaryKeys() takes List & returns new List
- Run an operation on each element in turn
• And return the new list we built up

28. More on the Map Pattern
• Note that the type contained in the returned List may
be different from the incoming List.
- In our example, incoming type is DBInfo, outgoing String
- The original List hasn’t been affected in any way.
• This is where “functional programming” comes from
- The functions behave like mathematical functions
• A function like f(x) = x * x
- Doesn’t alter the value 2 when it’s passed in.
- Instead, it returns a different value, 4.

29. The Filter Pattern
• The use of map is an absolutely classic FP idiom.
• It’s usually paired with the filter idiom.

30. Functions-as-values
• We can construct our "function-as-a-value"
- Need a way to represent that “predicate function” for filter
• Here’s one way we could write it (in almost-Scala):
(msg) -> { !msg.get("status")
.equalsIgnoreCase("CANCELLED") };
• This is a function which takes one argument
- msg is a Map<String, String>
- The function returns boolean
• Actually, this is also how Java 8 is going to write it.
- In fact this is a very Java-ish way of writing Scala

31. There you go Scala folks!
We finally gave you some props
It’s the last time
31

32. What We Didn’t Cover
• Why functional is good for modern concurrency
- That’s in the next hour!
• The myriad academic definitions of closures
• Groovy, Scala, Clojure, JRuby, Jython, Nashorn
- Well actually....
• The Groovy folder you copied from the USB stick
- Unzip the groovy-2.0.0.zip to a location of your choice
- Work through as much of CH08 as you like!

33. What? You still here?
Go take a break will you!
33