Functional Geekery

Functional Geekery

By ProctorTechnology
Download on the App Store

Functional Geekery episodes

  • Functional Geekery Episode 11 - Simon Peyton Jones

    In this episode I talk with Simon Peyton Jones. I ask him about his background in Functional Programming, the growing popularity of Haskell, things he would like to bring into Haskell further, and his work with Computing At School.

    Our Guest, Simon Peyton Jones

    Simon Peyton Jones

    Topics

    Haskell

    Computer Science at School
    How Simon Peyton Jones got into Functional Programming
    SK Combinators
    Implementation of Functional Programming Languages (Amazon, online)
    Creation of Haskell
    Haskell as a Laboratory for Innovation
    Interview on Software Engineering Radio
    Core of Haskell as Lambda Calculus
    System F
    Growing Popularity of Haskell
    Hackage and Cabal
    Concurrency in Haskell
    Haskell as a part of an Ideas Pipeline and Exemplar
    “When the limestone of imperative programming is worn away the granite of functional programming will be revealed underneath”
    Static Typing in Haskell vs Weaker Type Systems
    Type Inference
    Incomplete programs

    • Example 1: f x = sort _ ++ x
    • Example 2: f x = funny_lib_fn _ _ _
    • Things thinking about for future of Haskell

      Refinement Types and Liquid Haskell
      Larger Scale Modularity in Haskell and Software Components
      Cloud Haskell
      Refinements Examples

      • Example 1: f :: Int -> Int
      • Example 2: f :: (x:Int) -> {y:Int | y > x }
      • Example 3: g :: (x:Int -> {y:int | y>x}) -> …
      • Combination of Modularity at Package Level with Refinement Types as part of Component Contract

        Bringing Computer Science as Subject Discipline to England National School Curriculum
        What the curriculum looks like
        Number of Programming Environments aimed at Children in School
        Logo
        Scratch
        Alice
        Kodu
        Greenfoot
        Blockly
        touchdevelop
        Programming is Only Part of Computer Science
        Computer Science Unplugged
        How to Participate at the Local Level Even
        Join Computing At School

        A giant Thank You to David Belcher for the logo design.

        54 min
      • Functional Geekery Episode 10 - Paul Holser

        In this episode I talk with Paul Holser. We start out by talking about his junit-quickcheck project, being a life long learner and exploring ideas about computation from other languages, and what Java 8 is looking like in with the support of closures and lambdas.

        Our Guest, Paul Holser

        http://github.com/pholser

        @pholser on Twitter

        Topics

        The Container Store

        junit-quickcheck
        JUnit
        JUnit Theories
        Real World Haskell
        Haskell QuickCheck
        Prime Factors Kata
        Interest in trying to tackle shrinking for junit-quickcheck
        Bringing functional ideas back into Java
        Try to push the envelope of what you can do in a language
        Groovy
        Scala
        Clojure
        Being a life long student
        MOOCs (Massive Open Online Course)
        Coursera
        edX
        Why work in Java
        Being willing to suck at something to afford learning opportunities
        Ways to bring ideas from functional languages back to co-workers
        Guava
        Be gentle and persistent
        mockito
        How well Java 8 brings functional ideas back to Java
        Work to use lambdas as matchers in JUnit
        Hamcrest
        Single Abstract Method Types
        lambspec
        Steve Yegge’s Execution in the Kingdom of Nouns
        Support of closures and lambdas in Java 8
        New Optional Type in Java 8
        Dallas Area Java MUG at Improving Enterprises
        Coursera Courses and other MOOCs
        Functional Programming Principles in Scala on Coursera
        Principles of Reactive Programming on Coursera

        A giant Thank You to David Belcher for the logo design.

        43 min
      • Functional Geekery Episode 9 - William E. Byrd

        In this episode I talk with William Byrd. We talk about miniKanren and the differences between functional, logic and relational programming. We also cover the idea of thinking at higher levels of abstractions, and comparisons of relational programming to topics such as SQL, property testing, and code contracts.

        Our Guest, William Byrd

        http://webyrd.net/

        http://github.com/webyrd
        @webyrd on Twitter and [email protected]

        Topics

        U Combinator Lab

        miniKanren
        Will’s overview of how he got into LISP and Relational Programming
        Daniel Friedman and Indiana University
        Logic Programming
        Zebra Puzzle – Who owns the Zebra?
        Oleg Kiselyov
        The Reasoned Schemer
        Purely Relational Arithmetic System
        The Ability to Reorder Statements and Keep the Same Semantics
        Functional vs Logic vs Relational
        core.logic
        Interview of Will on InfoQ
        How Far Can We Get Being Purely Declarative
        Constraint Logic Programming
        Bob Harpers’ Post on Static vs Dynamic Typing
        Analogies Between Typing and Logic Programming
        Dependent Type Systems, e.g. Agda and Idris
        The Discovery of Functional Programming and Signs of Logic Programming
        Functional JavaScript by Fogus – (Note: There was Episode with Fogus on Functional JavaScript)
        Trying to Understand the Implementation of miniKanren to Understand Thinking Operationally
        The ability to be able to let go of implementation details and think at a more abstract level
        Pointers on Where to Dig Into Relational Programming
        miniKanren.org – For all things miniKanren
        Will’s Dissertation
        Scheme Workshop Paper
        Will is Working on a Book as Starting Place for Relational Programming
        The Art of Prolog
        Prolog Programming for Artificial Intelligence by Ivan Bratko
        Thanks to Everyone Who Has Worked on miniKanren
        Clojure/Conj and Strangeloop talks on miniKanren

        A giant Thank You to David Belcher for the logo design.

        57 min
      • Functional Geekery Episode 08 - Jessica Kerr

        In this episode I talk with Jessica Kerr. In this episode we talk bringing functional programming concepts to object oriented languages; her experience in Scala, using the actor model, and property testing; and much more!

        Our Guest, Jessica Kerr

        jessitron.com

        @jessitron on Twitter and [email protected]

        Topics

        Jessica’s ØreDev Talk

        Jessica’s Ruby Midwest Talk
        Bring Just Enough of the Ideas from Functional Programming Back to Java and C#
        Use Static/Class Level Methods to Make Needed Data Explicit
        Designate Methods That Modify State When Working in Object Oriented Languages
        Isolation as the Dual/Reverse to Encapsulation
        Guava library for Working in Java
        Readable Code vs Familiar Code
        Use Code Reviews to Spread Practices
        Scala as a Hybrid Language and the Blessings and Curses Therein
        Reasons One Might Choose Scala
        Akka
        Akka Concurrency by Derek Wyatt
        The Actor Model
        Testing with Scala
        Introducing a Functional Language by Writing Tests in that Language
        ScalaTest
        ScalaCheck
        Property Based Testing
        ScalaCheck: The Definitive Guide
        Commonalities Between Git and Functional Concepts
        Directed Acyclic Graphs
        Importance of Immutable Data in Functional Programming
        LambdaLounge
        F#
        Using a Functional Language to do Spikes to Solidify Ideas
        Kansas City Developer Conference
        Jessica’s Upcoming Appearances
        GOTO Chicago
        QCon New York 2014
        scalaz-stream
        GOTO Amsterdam 2014
        ScalaDays 2014
        Scala Puzzlers
        Ribbon Farm

        A giant Thank You to David Belcher for the logo design.

        Update: May 6th 2014

        Added link to Scala Puzzlers.
        Also, Jessica has informed me that she had to cancel her appearance at ScalaDays.

        53 min
      • Episode 7 - Angela Harms and Jason Felice on avi

        In this episode I talk with Angela Harms and Jason Felice about avi. We talk about the motivation of a vi implementation written in Clojure, the road map of where avi might used, and expressivity of code.

        Our Guests, Angela Harms and Jason Felice

        maitria

        Angela Harms: @angelaharms on Twitter and [email protected]
        Jason Felice: @eraserhd on Twitter and [email protected]
        avi on Github

        Topics

        Angela’s guest appearance on RubyRogues podcast

        Vim
        How Jason and Angela got into Clojure
        http://maitria.com/
        avi
        Podcast with creator of VsVim
        Why pick Clojure to write avi in
        Greenspun’s Tenth rule but for vi plugins
        Midje
        Where the vision of avi is going
        Do not defeat a Vimmer’s muscle memory
        How Immutable state is helping
        cocos2d
        What might make a MVP for avi
        Midje and testing framework style
        Expressivity of the avi’s tests
        The example tests on github
        Angela and Jason’s obsessiveness on expressivity and Clojure’s impact on it
        4clojure.com
        Issues and discussion about avi on github are much appreciated

        A giant Thank You to David Belcher for the logo design.

        49 min
      • Episode 6 - Reid Draper

        In this episode I talk with Reid Draper. We cover Reid’s intro to functional programming through Haskell, working in Erlang, distributed systems, and property testing; including his property testing tool simple-check, which has since made it into a Clojure contrib project as test.check.

        Our Guest, Reid Draper

        reiddraper.com

        @reiddraper on Twitter
        reiddraper on Github

        Topics

        Basho

        Riak and Riak CS
        Reid’s appearance on The Cognicast
        The Echo Nest
        Two camps of approaching learning a language, project based and learning the language for the language sake
        Learn You a Haskell for Great Good
        Papers on Haskell and ML to help learn functional programming
        Paxos and Raft papers
        Consensus
        Lamport papers
        Amazon Dynamo paper
        What about Erlang helps with building Distributed systems
        Messaging between nodes in Erlang
        The ability to debug live systems with Erlang
        Dealing with distributed systems that are not replicated
        The Eight Fallacies of Distributed Computing and Fallacies of Distributed Computing Explained
        “A static website with only one browser connected is a distributed system”
        Immutability and Eventual Consistency
        Importance of Idempotent commands in Distributed Systems
        Property Based Testing
        Quick Check
        Erlang Quick Check and Proper
        simple-check [It has since been moved to be Clojure contrib project as test.check]
        Thinking in Properties about functions
        Static vs Dynamic typing and Gradual typing
        core.typed by Ambrose Bonnaire-Sergeant
        Dialyzer from Kostis Sagonis
        Agda
        Idris
        “Learn one dynamically typed and one statically typed with a good type system”
        Typer for Erlang
        Webmachine
        Riak and RiakCS as example of large scale distribute/Erlang systems
        Haskell, Coq, Agda, Idris
        Implementation of Functional Programming Languages by Simon Peyton Jones

        A giant Thank You to David Belcher for the logo design.

        53 min
      • Episode 5 - Colin Jones

        In this episode I talk with Colin Jones, software craftsman at 8th Light. We cover Colin’s work on the Clojure Koans, making the transition from Ruby to Clojure, how functional programming affects the way he does object oriented design now, and his venture into learning Haskell.

        Our Guest, Colin Jones

        Colin on 8th Light

        Colin’s blog posts at 8th Light
        @trptcolin on Twitter
        trptcolin on github.com

        Topics

        8th Light

        Colin’s background on getting into programming
        Clojure Koans
        Learning Clojure by writing the Clojure Koans
        Teaching as a way to learn
        Colin’s blog post Clojure Libs and Namespaces
        Colin’s blog post Quoting Without Confusion
        Clojure Doc site
        REPLy
        nREPL
        Leiningen
        Possible use of nREPL to connect to a live running system
        8th Light’s experience with Clojure
        Pedestal
        Webmachine
        Liberator
        Using Object-Oriented constructs in Functional languages, and vice-versa
        Colin’s SOLID Clojure presentation
        Speclj
        clojure.test
        Midje
        Speclj works on ClojureScript as well
        ClojureScript
        Haskell
        exercism.io
        Learn You a Haskell for Great Good
        The other book that was recommended to Colin: Haskell: The Craft of Functional Programming
        Deliberate Practice with feedback
        Colin is writing a book on macros in Clojure from Pragmatic Press
        On Lisp by Paul Graham
        Let Over Lambda by Doug Hoyte
        David Nolen (@swannodette on Twitter)
        Concepts, Techniques, and Models of Computer Programming
        Michael Bernstein (@mrb_bk on Twitter)
        Michael Fogus (@fogus on Twitter)
        Out of the Tar Pit on CiteSeer
        Apprenticeship at 8th Light
        8th Light University on Friday afternoons

        A giant Thank You to David Belcher for the logo design.

        48 min
      • Episode 4 - Zach Kessin

        In this episode I talk with fellow podcaster Zach Kessin. We cover his background in software development and podcasting, the background of Erlang, process recovery, testing tools, as well as profiling live running systems in Erlang.

        Our Guest, Zach Kessin

        @zkessin on twitter

        zkessin on github.com
        Mostly Erlang
        @mostlyerlang on twitter

        Topics

        Structure and Interpretation of Computer Programs

        Programming HTML5 Applications
        Building Web Applications with Erlang
        Listing to podcasts as part of a commute
        365 Days of Astronomy
        Mostly Erlang
        Ohio State University astronomy professor Richard Pogue and his lectures
        Zach’s episode of JavaScript Jabber
        Zotonic
        Background of Erlang
        Actor Model
        Erlang Links/Monitors
        Behaviors in Erlang
        Process Recovery in Erlang
        Riak
        Robert Virding
        Dialyzer
        Kostis Sagonis
        PropEr and Property Based Testing
        Episode 16 & Episode 27 of Mostly Erlang
        Concuerror
        Testing Erlang
        Moore’s Law is over and mega-cores are the future
        Immutability in Erlang
        Joe Armstrong
        Simon Peyton Jones
        Profiling Covering in Running Code
        webmachine
        webmachine diagram
        Mostly Erlang – 029 Teaching Kids to Code
        Ruby Rogues – 141 RR Teaching Kids with Ron Evans
        Introducing Erlang by Simon St. Laurent
        Learn You Some Erlang for Great Good
        Erlang Factory
        Chicago Boss

        A giant Thank You to David Belcher for the logo design.

        46 min
      • Episode 3 - Fogus

        In this episode I talk with Fogus, author of The Joy of Clojure and Functional JavaScript. We cover his history with functional languages, working with JavaScript in a functional style, and digging into the history of software development.

        Our Guest, Fogus

        fogus.me

        Topics

        Joy of Clojure

        Chris Houser
        Clojure.core
        Relevance (Now Cognitect)
        Missing the interesting conversations as part of Clojure.core team
        Core/async
        Fogus’ previous functional language experience
        What about Lisp appeals to Fogus
        Progression of Imperative to Functional to Logic programming
        Functional JavaScript
        Douglas Crockford
        Underscore
        Jeremy Ashkenas
        Ostrich purity
        Lemonad
        Bilby and Fantasy Land by Brian McKenna
        Structuring and organizing functional programs
        How to build your knowledge of the history of computing
        Reading for the Rushed
        Follow footnotes/bibliography/references
        10 Technical Papers Every Programmer Should Read (At Least Twice)
        The History of Programming Languages Volume 2
        A Programming Language by Kenneth Iverson
        APL
        Structure and Interpretation of Computer Programs (from Amazon.com)
        Any book written before 1990
        Production Rule Systems in Clojure
        Infinite Jest
        House of Leaves

        A giant Thank You to David Belcher for the logo design.

        44 min
      • Episode 2 - Craig Andera

        In this episode I talk with fellow podcaster Craig Andera. We talk about working in Clojure, ClojureScript and Datomic, as well as making the transition to functional programming from C#, and working in Clojure on Windows. I also get him to give some recommendations on things he learned from guests on his podcast, The Cognicast.

        Our Guest, Craig Andera

        @craigandera

        Craig Andera

        Topics

        Cognitect

        Clojure
        Craig’s podcast, The Cognicast
        Mostly Lazy and Chas Emerick
        Making the transition from C# to Clojure
        Developmentor
        Stuart Holloway
        Justin Gehtland
        Relevance
        LINQ
        Structure and Interpretation of Computer Programs
        Gerald Sussman and Hal Abelson
        Out of the Tar Pit
        Design Patterns
        Some of the differences between Common Lisp and Scheme and Clojure
        ClojureScript
        Sharing code between Clojure and ClojureScript
        EDN and Reader Literals
        The “Holy Grail” of same language everywhere; client, server and database
        Rich Hickey’s Simple Made Easy
        Datomic
        Real-World Datomic: An Experience Report
        Room Key
        Datomic as an append only database
        Datalog
        The ease/difficulty of thinking about storing data in Datomic
        Amazon’s DynamoDB
        Tim Ewald
        Working back in DynamoDB after working with Datomic
        Developing in Clojure on Windows
        Cygwin
        XServer on Linux Virtual Machine in Windows
        Skype
        The Cognicast
        Good episodes for those unfamiliar with The Cognicast (formerly Think Relevance The Podcast)
        Maggie Litton on Think Relevance The Podcast Episode 46
        Michael Nygard on Think Relevance The Podcast Episode
        Pick a random episode and listen
        Rich Hickey on core.async
        Design Implementation podcast
        Reid Draper talking about Haskell and Erlang
        Where to find Cognitects
        Clojure DC
        Reston Hack Nights
        Baltimore Clojure
        Craig’s Github page
        dynne
        core.async
        Tim Ewald’s Clojure/conj presentation
        Russ Olsen’s Clojure/conj presentation
        Cognitect team page

        A giant Thank You to David Belcher for the logo design.

        58 min

      About Functional Geekery

      From the publisher's feed

      Functional Geeks, Geeking Functionally