1. [ny-haskell] Functional Reactive Programming for Musical User Interfaces by Paul Hudak

    01:24:12

    from Richard Minerich / Added

    1,426 Plays / / 0 Comments

    Paul Hudak[1] was one of the principal designers of Haskell language. He is currently authoring the book "The Haskell School of Music -- From Signals to Symphonies"[2], and is one of the founders of the Computing and the Arts program at Yale[3]. His talk will introduce Functional Reactive Programming (FRP), a programming paradigm that supports the notion of continuous time-varying values, as well as streams of discrete events. It will describe one version of FRP in Haskell, focusing on its use not only in graphical user interfaces, but "musical user interfaces" for controlling computer music applications. The work he will describe lets us “reify” real-world objects, allowing things like keyboards, soundcards, and so on, to be represented as signal functions. To make this idea safe, “resource types” are introduced that constrain the use of these devices. Finally, the question is posed, “what is an effect in FRP?” One answer is “wormholes,” a form of non-local communication between signal functions, in which values are sent into a blackhole, and magically received at the other end from a whitehole. The work he is presenting has been done jointly with Daniel Winograd-Cort[4]. [1] http://haskell.cs.yale.edu/people/paul-hudak/ [2] http://haskell.cs.yale.edu/?post_type=publication&p=112 [3] http://cs.yale.edu/c2/ [4] http://danwc.com/publications

    + More details
    • Alissa Pajer - How Haskell is Changing my Brain

      48:32

      from Arktekk AS / Added

      6,258 Plays / / 4 Comments

      This video was filmed during The flatMap(Oslo) conference which took place on the 12-13th of May 2014 in Oslo, Norway. flatMap(Oslo) is Norway's first dedicated Scala and functional programming conference. Abstract: http://2014.flatmap.no/speakers/pajer.html Track us: http://flatmap.no | http://twitter.com/#!/flatmaposlo | http://lanyrd.com/2014/flatmap/ flatMap(Oslo) 2014 could not be be possible without our fine sponsors: http://arktekk.no | http://finn.no/ | http://www.conax.com/ | http://bekk.no/ | http://iterate.no/ | http://miles.no/ | http://kodemaker.no/ | http://itera.no/ | http://nets.eu/ | http://webstep.no/

      + More details
      • Programming in Vinyl / BayHac 2014

        01:14:07

        from Jon Sterling / Added

        200 Plays / / 1 Comment

        + More details
        • A Practical Haskell Retrospective: Using Parsec, REST and Pandoc to Scrape Jira

          01:16:26

          from Lambda Luminaries / Added

          31 Plays / / 0 Comments

          A Practical Haskell Retrospective: Using Parsec, REST and Pandoc to Scrape Jira Presented at Lambda Luminaries on May 12, 2014. http://hanstolpo.github.io/TalksAndStuff/slides/2014-05-12-A_Practical_Haskell_Retrospective_Using_Parsec_REST_and_Pandoc_to_Scrape_Jira.html http://www.meetup.com/lambda-luminaries/events/172101552/

          + More details
          • LSOT @ Jazzhaus | May 3rd, 2014

            02:58

            from LSOT WEARELSOT / Added

            37 Plays / / 0 Comments

            Last Stop Outta Town playing "I Believe in a Thing Called Love" at the Jazzhaus (Lawrence, KS) on May 3rd, 2014.

            + More details
            • LSOT @ Stage 49

              23:46

              from LSOT WEARELSOT / Added

              45 Plays / / 0 Comments

              + More details
              • Matthew Brecknell - Introduction to Haskell III - BFPG - 2014-04-22

                45:07

                from Rob Manthey / Added

                110 Plays / / 0 Comments

                Introduction to Haskell III by Matthew Brecknell http://www.meetup.com/Brisbane-Functional-Programming-Group/events/166867022/ Brent Yorgey: cis.upenn.edu/~byorgey/ "The Yorgey Lectures": seas.upenn.edu/~cis194/lectures.html While completing HW 2, you probably spent a lot of time writing explicitly recursive functions. At this point, you might think that’s what Haskell programmers spend most of their time doing. In fact, experienced Haskell programmers hardly ever write recursive functions! How is this possible? The key is to notice that although recursive functions can theoretically do pretty much anything, in practice there are certain common patterns that come up over and over again. By abstracting out these patterns into library functions, programmers can leave the low-level details of actually doing recursion to these functions, and think about problems at a higher level—that’s the goal of wholemeal programming. This lecture will cover these recursive patterns, the haskell abstractions that make them possible and where to find these library functions in the prelude. We'll also take a tangent into the different between total and partial functions and why you should care about the difference.

                + More details
                • Tony Morris - Comonads, Applicative Functors, Monads and Other Principled Things - BFPG - 2014-03-25

                  40:42

                  from Rob Manthey / Added

                  1,004 Plays / / 2 Comments

                  Comonads, Applicative Functors, Monads and Other Principled Things by Tony Morris http://www.meetup.com/Brisbane-Functional-Programming-Group/events/166867012/ In this talk, we will discuss what these concepts represent and how they apply in everyday programming practices. A concrete explanation of the meaning and motivation for each of these will be provided — no metaphors or handwaving. Some of the practical consequences will be introduced by drawing on the ubiquitous knowledge of everyday programmers. The audience should expect to walk away with an introductory understanding and vocabulary for these topics with a capability to directly apply this knowledge in any programming environment and an aspiration to take this knowledge further.

                  + More details
                  • Lambda Days - Adam Szlachta - Functional programming patterns in Haskell

                    30:26

                    from Erlang Solutions / Added

                    74 Plays / / 0 Comments

                    Many people think of Haskell as the most beautiful programming language, because of the simplicity of the core language, conciseness of the Haskell code, theoretical foundations, and other reasons. Haskell is well known to be a number one purely functional language. This means that you can't do things in an imperative style: changing values of variables, mixing side effects with calculations, interrupting the program flow by breaks or exceptions. Functions have to be referentially transparent, they will yield the same results for the same set of arguments. This is not a recommended style, it's the only possible one. And it makes it much easier to reason about program behaviour, to prove correctness, and to write concurrent applications. There are some techniques however, which make it possible to write an imperative looking code, without violating purity of the language. They require zero to little syntactic sugar, sometimes just a humble "do" keyword. They are based on constructs borrowed from a branch of mathematics named category theory. We can call them functional programming patterns, but they are something more: they have laws you have to obey if you want to implement one. They are powerful and expressive, and you can achieve much more than just mimicking imperative languages. I will show a couple of them with examples of usages.

                    + More details
                    • Nick Partridge - Introduction to Haskell Pt 2 - BFPG - 2014-03-25

                      45:30

                      from Rob Manthey / Added

                      145 Plays / / 1 Comment

                      Introduction to Haskell, Part II by Nick Partridge http://www.meetup.com/Brisbane-Functional-Programming-Group/events/166867012/ Brent Yorgey: cis.upenn.edu/~byorgey/ "The Yorgey Lectures": seas.upenn.edu/~cis194/lectures.html Continuing on with the Yorgey Lecture series, we will tackle lecture 2, and learn the basics of declaring and using data types in Haskell.

                      + More details

                      What are Tags?

                      Tags

                      Tags are keywords that describe videos. For example, a video of your Hawaiian vacation might be tagged with "Hawaii," "beach," "surfing," and "sunburn."