This talk will sketch some connections at the foundations of semantics (of programming languages, logics, formal systems in general). In various degrees of abbreviation, we will present Galois Connections, Lawvere Theories, adjoint functors and their relationship to syntax and semantics, and the core notion behind abstract interpretation. At each step we'll draw connections, trying to show why these are good tools to think with even as we're solving real world problems and building tools and libraries others will find simple and elegant to use.
A big thanks to Johan Kiviniemi. Without his help in fixing the audio this video would be nearly unwatchable. This event and its recording has been brought to you by the combined hard work of NYC Haskell User Group members: meetup.com/NY-Haskell/events/91576512/
Edward Kmett will introduce his lens library, which provides a highly composable toolbox for accessing and modifying multiple parts of data structures.
From simple beginnings, starting with building blocks such as fmap and (.), we will build up combinators suitable for working with a wide array of data structures. These generalize the notions you already know how to use into a form that is easier to compose, and simultaneously allow them to be used for monomorphic containers such as Data.Text. All without compromising on your ability to reason about them using laws!
Once we've built up some foundations, we'll do a bit of a deep dive, exploring consequences of this design. We will discuss the efficient generic programming programming framework exported by lens, and type-safe Traversal-based zippers.
Familiarity with the Applicative and Traversable classes from the Haskell base libraries will be helpful (links provided below), but a basic understanding of the concepts will be introduced we go along. Attendees should expect to be gobsmacked with a newfound appreciation for the power of a little (or a lot of) abstraction.
All proceeds from the tip jar will go towards NY Haskell Meetup activities.
New Haskell users often point to complicated types and lack of pervasive side-effects in functions as confusing. But these features provide powerful tools to reason with, that can dramatically reduce the complexity of sophisticated code. We're starting off 2013 with two talks, one beginner and one intermediate, that will explain this from the ground up.
Ryan Trinkle will start off the evening with an intro talk to get beginners up to speed. Then, Doug Beardsley will talk about purity, strong types, and monads--why you should care about them, and how they can help you write better quality software. Drawing on experience with real world projects, we will take a look at practical motivations for these concepts. Then we will explore how they were actually used in the development of the recent 0.10 release of the Heist template system.