Evolution in Data Integration From EII to Big Data
Approaches to integrating data are changing with emergence of cloud computing.
The content has been bookmarked!
There was an error bookmarking this content! Please retry.
How would you like to view the presentation?
Monitor your Production Java App - includes JMX! Low Overhead - Free download
Using Drools? See what you're missing! Get the Power of Drools with the Assurance of Red Hat
In today’s hyper-competitive world, later may be too late to adopt Agile development and this Roadmap for Success will help you get started. Download "Agile Development: A Manager's Roadmap for Success" now!
It is a nice trick to unblock the mind. Of course an fp introduction can go as far as +oo, even for an intro but Neal Ford, gave a nice and concise speech on this matter. Functional programming for the working OOP programmer. I liked it!
If you're interested in other upcoming videos from Strange Loop, the full release schedule is here and all slides are here. If you want to be notified about Strange Loop announcements in the future, sign up for the mailing list.
Functional Programmng (FP) requires a declartive, mathematical way of thinking.
Unfortunately, our minds get corrupted too early by imperative, OO thinking. And - as I found out - (re-)learning functional programming requires quite a bit of effort (to get those neurons re-wired). CS shools should teach FP first. Its gratifying to see CMU taking a lead.
A declarative way of thinking is a better basis for creating abstractions.
I like this video very much. I believe this is very educational for new comers of FP, like me. Neal Ford is very good.
As I always say, OOP to Functional is really difficult, Functional to OOP could be just disturbing, yet doable in a timely manner.
They should give examples of end-user software like how to implement a web browser using functional programming or how to implement a blog or something.
Hi,
Just to notice that what you see at 20:00 are not matching with the slides that are shown. Neil Ford talks about slide no 45, not 35 . And I did not find the lides about some clojure code. Maybe the version of the slides that is given here is not the right one?
Anyway, it's a minor problem. The presentation is just great so far :)
Indeed, most real world problems are about shuffling data around and transforming structures. When was the last time I had to invent a real algorithm, which may work recursively? I cannot remember.
Of course math examples are perfect for functional programming. Math is all about functions and recursive definitions after all.
I think, when data structures are able to execute code on behalf of the caller (with closures), and thus avoid the ubiquitous iteration loops, most work is done already. A mainstream enterprise Java program contains mostly copy operations and loops over structures. Sophisticated algorithms are not often needed.
The standard data structures Map, Set, List, Tree, Array should provide processing algorithms, which potentially can run in parallel. The so-called business logic as such has almost never anything to do in parallel, really. It's all in the data structures.
The "business" services very rarely have any state, they are basically data structure transformers between some user or external interfaces and persistent data storage, which carry the state.
One reason why I enjoy programming in Ruby: Almost no loops! Array, Hashes, Strings, Files, all have operations based on closures. A real pleasure to program.
As for Java, a decent closure syntax and a rewrite of the standard library would help a lot.
Agree that closures/lambdas make data manipulation a lot easier - even when not working on complex algorithms. Such 'functional' data manipulation can be more easily parallelized.
Example: Word Count is the canonical ("Hello World" equivalent) demo problem in map-reduce. Following are F# serial and parallel versions of Word Count - which are strikingly similar:
let file = @"C:\Users\Fai\Downloads\War_and_Peace.txt"
let splitLine (l:string) = ...function to split a line into words...
//serial word count
file |> File.ReadLines
|> Seq.map splitLine
|> Seq.collect (fun xs -> xs)
|> Seq.map (fun w -> w.ToLower())
|> Seq.countBy (fun w -> w)
//parallel word count
file |> File.ReadLines
|> PSeq.map splitLine
|> PSeq.collect (fun xs -> xs)
|> PSeq.map (fun x -> x.ToLower())
|> PSeq.countBy (fun w -> w)
Nice presentation, of the sort I wish I would have seen years ago. Ford paces back and forth throughout the presentation -- whoever ran the camera for this session must have been going crazy, but she/he did a great job.
Do you realize you've written most of this comment in the passive voice?
Sorry, I was just being lazy. The comment doesn't take effect unless someone starts reading it. :)
Approaches to integrating data are changing with emergence of cloud computing.
Michele Ide-Smith presents the lessons learned in the process of introducing UX principles and techniques into a large organization through a series of small steps.
Dave Farley and Martin Thompson discuss solutions for doing low-latency high throughput transactions based on the Disruptor concurrency pattern.
Rajneesh Namta shares his thoughts, experiences, and some of the critical lessons learned while implementing software test automation on a recent Agile project.
Dale Schumacher presents several patterns of actor interaction that can be used in collaborative programs written in any language.
Rúnar Bjarnason discusses Scalaz, a Scala library of pure data structures, type classes, highly generalized functions, and concurrency abstractions to perform functional programming in Scala.
One of the main challenges when designing software architecture is considering quality attributes. Not only their design turns out to be difficult, but also the specification of these attributes.
Michael Feathers analyzes real code bases concluding that code is not nearly as beautiful as designers aspire to, discussing the everyday decisions that alter the code bit by bit.
12 comments
Watch Thread Reply