Awesome Haskell Videos

Learn Haskell by building a blog generator (free e-book): https://lhbg-book.link/ Part 0. About the book. And a simple HTML "hello world" program using Haskell. 💡 Related links: * Resources to help you with Haskell: https://www.haskell.org/documentation/ * Author’s Haskell Study Plan: https://github.com/soupi/haskell-study-plan#about-this-guide * Book’s author: https://gilmi.me/ * Discussion board: https://github.com/soupi/learn-haskell-blog-generator/discussions * Install Haskell: https:...

Hate watching videos? Check out the complementary article, which covers the same content: https://dev.to/zelenya/debunking-haskell-myths-and-stereotypes-1e04 Haskell is covered with myths and stereotypes, such as “You need a PhD to do Haskell” or “Haskell is only good for writing compilers”. These are silly and not true. Let’s debunk most common ones. 💡 Relevant content * Why are FP devs obsessed with Referential Transparency: https://www.youtube.com/watch?v=UsaduCPLiKc * Debunking Haske...

Hate watching videos? Check out the complementary article, which covers the same content: https://dev.to/zelenya/there-is-no-tooling-issue-in-haskell-cal There is a stereotype that there exists a “Tooling issue” in Haskell. Which isn’t true. I want to cover the current state of things and show some tooling that other language ecosystems can only dream about. 💡 Links GHCup: https://www.haskell.org/ghcup/ GHC: https://www.haskell.org/ghc/ Cabal: https://www.haskell.org/cabal/ Stack: https:/...

I first heard of a programming language, Haskell, and wanted to try it because people were saying it changes your way of thinking, makes you more productive, etc. But I didn't know how weird this language actually was. I was struggling to write anything that even ran for the first couple of weeks. The language is so weird because it's declarative and function, basically a completely different concept of computing. Normal languages are mostly inspired by each other, but Haskell was created a ...

In this session you will learn about three heroes: Monoid (and its side-kick Semigroup), Foldable and Traversable. Three amazing type-classes, each providing a set of astonishing powers, making your daily programming routines easy as pie. During the talk we will encounter numerous villains (a.k.a programming riddles). Though the baddies look tough at the first glance, we will quickly learn that with the help of our protagonists, defeating those villains is a child's play. Are you ready to...

Special thanks to the Haskell Foundation for supporting the production of this video! Haskell Love 2021 schedule: https://emamo.com/event/haskell-love Haskell Love twitter: https://twitter.com/_haskellove This talk is a deep-dive on the Alternative typeclass from `Control.Applicative`, which provides a monoid over applicative functors, we love monoids, and we love applicatives, what do we get when we combine the two? We'll start off by exploring the typeclass and its laws by showing off so...

A distinctive feature in the design of Haskell was the inclusion of monads as the means of incorporating effects into programs. While it is entirely possible to write effectful programs in a single monolithic monad, there are advantages to decomposing a monad into smaller building bricks that can be layered on top of each other: smaller components are more easily reused and can be flexibly exchanged for others when needs change and improvements are made. Traditionally, this kind of modularity...

Haskell claims to be a declarative language, where you just write down some equations, and suddenly the variables contain the solution to these equations. This works even with recursive equations, but only in some cases: defining recursive functions, of course, but also cyclic data structures. One can even apply so-called knot-tying tricks, where a lazy data structure is filled with values that refer to that data structure! For example, one can very elegantly calculate the reachable nodes in ...

In this video, we look at 5 common mistakes that beginners make in Haskell. You'll learn what they are, why do they occur, and how to identify and solve them. Get FP merch that doesn't suck 👇 https://shop.serokell.io/ Follow us on social media: https://twitter.com/serokell Learn more about us: https://serokell.io/ https://github.com/serokell Contact us: academy@serokell.io 📚 Further reading 📚 Indentation https://en.wikibooks.org/wiki/Haskell/Indentation Left arrow vs. assignment ...

This is a hands on session where we learn how to make HTTP calls in Haskell using the "wreq" library in order to call REST APIs. The example we use is the "LibreTranslate" Translation API, which allows us to translate text to different languages. We go over JSON encoding/decoding (using the "aeson" library), and at the end do a little bit of concurrency. This video is suitable for beginner and intermediate level Haskell developers. I try to explain everything that is done as simply as poss...

This lecture gives an overview of the course. It starts by explaining how the lectures and labs will be organised, discusses the resources that are available to students and how the course is assessed, and concludes with a summary of the topics that will be covered. Course playlist: http://tinyurl.com/haskell-notts2

Lecture 1 about Haskell and FP fundamentals. Slides: https://slides.com/haskellbeginners2022/lecture-1 Course plan: https://github.com/haskell-beginners-2022/course-plan Exercises: https://github.com/haskell-beginners-2022/exercises 🗞 Subscribe to my newsletter to check the latest news about my courses, books, and big projects: https://chshersh.com/#subscribe Chapters: 0:00 - Preparation 2:00 - Intro 2:18 - What is FP? 5:33 - FP Concepts 7:53 - Haskell Features 10:32 - Haskell Toolchain ...

Check out Vitaly Bragilevsky's book 📖 Haskell in Depth | http://mng.bz/REmj 📖 To save 40% off this book ⭐ DISCOUNT CODE: watchbragilevsky40 ⭐ A Haskell expert Vitaly Bragilevsky demonstrates Haskell features that make programming at the level of types possible. This video is an excerpt from Intro to Type-Level Programming in Haskell, a live coding session by Vitaly Bragilevsky. Watch the full video at http://mng.bz/2j78. 📚📚📚 Haskell in Depth | http://mng.bz/REmj To save 40% off this ...

Check out Alexander Granin's book 📖 Functional Design and Architecture | http://mng.bz/raaJ 📖 To save 40% off this book ⭐ DISCOUNT CODE: watchgranin40 ⭐ Join Alexander Granin, the author of Functional Design and Architectures, to get a deeper understanding of Functional Declarative Design (FDD) as opposed to Object-Oriented Design (OOD). A word from the author: "For a long time, software engineering in FP wasn't anything to consider. It wasn't a discipline to benefit from. Today, we can...

Subscribe to Monday Morning Haskell! https://www.mmhaskell.com/subscribe -------------------------------------------------------------------------------- GitHub: Repository: https://github.com/MondayMorningHaskell/SimpleMaze This Video: https://github.com/MondayMorningHaskell/SimpleMaze/blob/main/src/Environment.hs -------------------------------------------------------------------------------- Articles: 1. Breadth First Search Basics: https://www.mmhaskell.com/blog/2021/11/22/ai-revisit...

In the second video of our Haskell Tips series, Flavio Corpa will take us through solving one kata from CodeWars with Haskell and recursion, and then go back to the solution and get a bit fancier with the Writer and State monads, everything is possible in Haskell! Flavio Corpa Senior Software Engineer https://www.twitter.com/FlavioCorpa Haskell Tips is a 47 Degrees Academy Production. https://www.47deg.com https://www.twitter.com/47deg

My example-driven talk will introduce and explore “Higher Kinded Datatypes” (HKDs), a novel approach to parameterizing data types which allows greater flexibility, re-use, and improved type-safety when performing common tasks on data. While many data types are parameterized over the values in the type; HKDs are generalized over a container type which wraps each field. This approach also allows us to “zip” record fields in a type-safe way, allowing us to append structured error messages to p...

To get back into 'thinking in Haskell', the first three lectures show how to develop an efficient Haskell program to solve sudoku puzzles. This lecture explains the problem, and sets up some basic definitions concerning sudoko grids. Course playlist: tinyurl.com/haskell-notts2

Support: https://www.patreon.com/tsoding Problem: https://adventofcode.com/2020/day/10

In this series, I'll be attempting to complete the 2020 Advent of Code in the Haskell programming language. 00:00 A quick retrospective of day 9 00:34 Solution to part 1 of day 10 02:39 Solution to part 2 of day 10 The Advent of Code challenges: https://adventofcode.com/2020 My solutions are also available on GitHub: https://github.com/haskelling/aoc2020 Full Haskelling the Advent of Code 2020 playlist: https://www.youtube.com/playlist?list=PLDRIsR-OaZkzN7iV6Q6MRmEVYL_HRz7GS

Pawel Szulc Haskell developer by day, Haskell developer by night. Explorer of the uncharted territories. Father, husband, cats herder.

Vladislav Zavialov Haskell programmer since 2012; GHC contributor since 2018. I’m interested in language design, programming language theory, and compiler engineering. Haskell to Core: Understanding Haskell Features Through Their Desugaring Haskell is an expressive language with many features. On one hand, it makes Haskell convenient, equipping the programmer with a rich arsenal of tools to get the job done and write high quality software. On the other hand, developing a thorough understandi...

Come hang out as Chris fumbles his way through designing a brand new library from scratch, maybe it'll work, maybe it won't!

This live-coding session will witness a brand-new (mostly useless) extension to GHC. By watching, you will get a road map of how this is done and what the moving pieces in GHC's front end are: parsing, name resolution, type checking, and error messages.

Source Code: https://github.com/tsoding/haskell-music Note Frequency Math: https://pages.mtu.edu/~suits/NoteFreqCalcs.html Chapters: 0:00 Producing First Sounds 19:03 Frequency in Hertz 28:06 Semitones 34:10 Attack-Release 43:32 Tempo 46:06 Making Music

Solving Project Euler problem 33 in Haskell. Project Euler: https://projecteuler.net/

Type checking and type inference in particular are often perceived as super-advanced topics, only reserved for specialists, witches, and wizards. In this workshop, Christoph Hegemann will show you that none of that is true, and type checking can be understood by everyone from first principles. To do so, we'll implement a type checker (with inference) for a small functional programming language in Kotlin. After familiarizing ourselves with our language for a few minutes, we'll dive right into ...

Procedural generation in game design is becoming more and more common: rather than building thousands of maps or levels, programs generate them according to a set of pre-defined rules. So, now we’re all stuck inside, working on our next platinum indie game, why don’t we try it out? In this talk, we’ll look at some of the techniques used in procedural generation, discuss how they translate to Haskell, and put it all together in time for our next best-seller. Tom Harding lives in London and w...

Zurich Haskell meetup: https://www.meetup.com/HaskellerZ/events/270136648 Code repository: https://github.com/nh2/haskellerz-async-tutorial-2020 Niklas will give a tutorial on asynchronous and parallel programming using the `async` library. It targets beginner to intermediate Haskellers, as well as anybody who has not used or does not understand `async` yet. If you understand how to do IO in Haskell, you are ready. After this tutorial you will be able to write correct multi-threaded code e...

As HUGE Functional Programming fans (and we know you are too) it was about time ventured our meet-up into Haskell. Our speakers? They are awesome🤩 VP of FP Complete, Michael Snoyman and Simon Hafner, Functional Compiler Engineer, who are both passionate functional programmers. 📣Simon Hafner, Functional Compiler Engineer @ Input Output Title: Row Row Row Your Type Abstract: Every Haskell developer complained about record types at least once. I am here to offer hope of a brighter future. �...

Learn how to build a web app in Haskell with the author of the Yesod framework, Michael Snoyman. Michael recently gave the talk, "Your First Haskell Web App With WAI And Warp" and this is going to be "Part Two with Yesod!" Michael Snoyman is the Vice President of Engineering at FP Complete, and the founder and lead developer of multiple Haskell open source projects, including Yesod, Conduit, Stack, and Stackage. He regularly speaks about programming best practices and writes articles and tut...

Zurich Haskell meetup: https://www.meetup.com/HaskellerZ/events/269475956/ Slides: https://docs.google.com/presentation/d/1j1Yx7ewS-nbyJSwtH3-j6mkVGxfq7ZAViv22jrizthI/edit?usp=sharing Juri Chome & Cazim Hysi - Workshop on building a webservice Hi Haskell friends, So obviously we won't be holding any in-person meetups anytime soon, but that doesn't mean we can't hang out together! Therefore we decided to hold a remote video meetup this month. We will have a small presentation/tutorial foll...

In this course we explore functional programming with Haskell.

Twitch: https://www.twitch.tv/tsoding GitHub Repo: https://github.com/tsoding/haskell-json My Haskell Setup: https://www.youtube.com/watch?v=5p2Aq3bRuL0 Unusual video this time. This is a slightly edited recording of my Twitch stream. Initially I planned to make a regular video on this topic, but quickly realized that it's just way too much material for a single regular 10 minutes video. So I decided to make a Live Stream where I explain as much information as possible. And since the Stream ...

In this Lambda World 2019 presentation, Paweł Szulc shows the benefit of programming with Haskell. Full Presentation Description: Developers interested in seeing Haskell being used as a general programming language. Engineers hoping to see Haskell as an environment in which one can quickly and effectively iterate between requirements, design and running, executable code - providing value to the business with an immediate feedback loop. Developers eager to see how they can rapidly create sof...

In this Lambda World 2019 presentation, Robert M. Avram talks about the consequences of effect models. Full Presentation Description The very essence of functional programming relies on a fairly simple premise: write side-effectless programs, so that you can reason about them equationally. Side-effects however are predominant in every program that . . . well, does something useful. In light of this, the modelling of effects in functional programs has become a fairly active domain of study. ...

Title: MuniHac 2019: The many faces of isOrderedTree Speaker: Joachim @nomeata Breitner, DFINITY Foundation Abstract: In this talk, we will look at a seemingly simple programming problem – checking whether the elements in a binary tree are in order – and not only explore many different approaches to solving this problem, but also show how they are all connected. As we do that, we will touch upon equational reasoning, defunctionalization, the worker-wrapper transformation, and more. We learn...

Title: MuniHac 2019: Making a Haskell IDE Speaker: Neil Mitchell Abstract: I've always wanted a Haskell IDE. The absence of a simple and robust solution led me to build Ghcid, which I've been using for many years. However, I have moved on, now using a real Haskell IDE based on technology we developed at Digital Asset for the DAML programming language. It turns out building an IDE is harder than I expected, so in this talk I'll cover three topics: 1. The theory behind building an IDE. We us...

Keynote at ZuriHac 2019 Simon is one of the designers of the Haskell language, an inspiring leader for the whole Haskell community, and the main developer of GHC, the de facto standard Haskell compiler. He also chairs the Computing At School group, which promotes the teaching of computer science at school Link: https://zfoh.ch/zurihac2019/#program www.hsr.ch

The rumours are true. Writing code in purely functional languages tends to produce code that is much easier to read, modify and reason about. This talk examines how an experienced Scala team transitioned into writing production code using PureScript in AWS lambda, and services using Haskell. EVENT: Typelevel Summit 2019 SPEAKER: Felix Mulder PUBLICATION PERMISSIONS: Original video was published with the Creative Commons Attribution license (reuse allowed). ATTRIBUTION CREDITS: Origina...

Code: https://github.com/mjgpy3/presentations/blob/master/lte-haskell/0-DoNotation.hs

This webinar will explain how to get up and running with making your own TUI applications by live-coding example TUIs with the brick. Terminal User Interfaces are text-based user interfaces for use from a terminal. Great for Haskell programmers to enhance productivity. This webinar was presented by Tom Sydney Kerckhove.

GTK+, or the GIMP Toolkit, is a multi-platform toolkit for creating user interfaces. In this video we will use the haskell-gi suite of packages to build a simple GTK+ application with Haskell. Show notes: (coming soon) Patreon: https://www.patreon.com/haskellatwork

Die HSR Hochschule für Technik Rapperswil begrüsste zusammen mit Google, Adjoint, Digital Asset, DFINITY und TWEAG rund 400 Informatikerinnen und Informatiker aus der ganzen Welt zum 7. Haskell Hackathon. Die jährlich stattfindende Konferenz knackte zum ersten Mal die 400er-Teilnehmergrenze. Sie richtet sich sowohl an ausgewiesene Expertinnen und Experten der Programmiersprache Haskell wie auch an interessierte Einsteiger. Studierende der HSR, der ETH und weiterer Hochschulen sowie Software-E...

Die HSR Hochschule für Technik Rapperswil begrüsste zusammen mit Google, Adjoint, Digital Asset, DFINITY und TWEAG rund 400 Informatikerinnen und Informatiker aus der ganzen Welt zum 7. Haskell Hackathon. Die jährlich stattfindende Konferenz knackte zum ersten Mal die 400er-Teilnehmergrenze. Sie richtet sich sowohl an ausgewiesene Expertinnen und Experten der Programmiersprache Haskell wie auch an interessierte Einsteiger. Studierende der HSR, der ETH und weiterer Hochschulen sowie Software-E...

Problems: Solve Me First: https://www.hackerrank.com/challenges/solve-me-first/problem Simple Array Sum: https://www.hackerrank.com/challenges/simple-array-sum/problem A Very Big Sum: https://www.hackerrank.com/challenges/a-very-big-sum/problem Support: https://www.patreon.com/tsoding

The Spock web framework for Haskell gives you a light but complete foundation to build web servers on, be it for traditional server-side rendered applications, or APIs for single-page applications. Compared to the Scotty framework, Spock is slightly richer in its feature set, and is more opinionated regarding the application architecture. In this episode we explore the basics of Spock and in-memory server state, as we build a note keeper application. Show notes: https://haskell-at-work.com/e...

Quickly going through the Data61 fp-course to show how I teach it at Atlassian: https://github.com/data61/fp-course Watch live at https://www.twitch.tv/puffnfresh #Haskell #fpcourse

Video about recursion: https://www.youtube.com/watch?v=Mv9NEXX1VHc Waste your money: https://www.patreon.com/tsoding Thumbnail art by https://reximkut.deviantart.com/

http://cppnow.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/boostcon/cppnow_presentations_2017 — In designing parallel programming abstractions, taking away user capabilities is as important as granting them. In this talk, I'll explain the role of this idea in several different parallel programming libraries for Haskell, C++, and other languages--spanning from shared memory to big data. The Haskell language is an experiment i...

Churchill College's annual Computer Science lecture. In this talk Simon discusses Haskell’s birth and evolution, including some of the research and engineering challenges he faced in design and implementation. Focusing particularly on the ideas that have turned out, in retrospect, to be most important and influential, as well as sketching some current developments and making some wild guesses about the future.

Simple examples, using the Stack tool. Download Stack at http://haskell-lang.org/get-started

When coming to Haskell from another programming language there are a lot of things that appear to be quite odd at first glance. One of these things is the non-strict evaluation strategy. Dreaded by some and loved by others, this might be one of the most controversial features of this programming language. In this talk, Raichoo will shed some light on the why and how of laziness and how GHC achieves it, as well as some interesting optimization techniques that the compiler performs to reduce so...

A Google TechTalk, July 23, 2016, presented by Alexander Thiemann ABSTRACT: This talk will give an insight on web development using the Haskell web framework «Spock» ( https://www.spock.li ). It will give a short overview of the possibilities like type-safe routing, hyperlinks, sessions, database queries, templates and JSON parsing/generation and then we will also look at a technique to build a full stack application with Spock and GHCJS as used in production in TramCloud. https://wiki.hask...

Motivation and philosophy

Why Haskell?

March 2016 HaskellerZ meetup - slides available at: https://github.com/meiersi/HaskellerZ/blob/a19f6c28cd999efdae86d38b1871378cbc3c0645/meetups/20160331-Haskell_Mistakes/slides.pdf

Reid Draper, Director of Engineer at Helium.co, talks about compiling, packaging, monitoring, and testing Haskell programs in a production environment. http://ChicagoHaskell.com | http://twitter.com/ChicagoHaskell | http://meetup.com/ChicagoHaskell

Katie Miller https://linux.conf.au/schedule/30363/view_talk Some say it was written exclusively for Unix-bearded wizards with PhDs. Some say only 10x programmers and unicorns can decipher its many operators. Some say any coding problem it touches will be saved from callback hell and find everlasting peace. The Haskell programming language has long been the subject of myths and misconceptions. Nonetheless it has been adopted by a slew of companies big and small, including Facebook, which has a...

In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID. The functional programming community has design patterns and principles as well. This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.

C◦mp◦se :: Conference http://www.composeconference.org/ January 31, 2015 Robots on Haskell by Anthony Cowley

This is the beginning of a series on writing a sed implementation in Haskell. You can follow along using the tags at the github repository: https://github.com/connermcd/sed Other Haskell Youtubers: http://www.youtube.com/user/jekor/videos http://www.youtube.com/user/KimballKinnison/videos http://www.youtube.com/user/LazyCasts/videos http://www.youtube.com/user/HaskellLiveTV/videos GNU sed source code: http://git.savannah.gnu.org/cgit/sed.git Haskell language: http://www.haskell.org/haskell...

This is part one of a series on writing parsers with Haskell. In this video we prepare the ground by creating a framework for reading and writing lines and parsing them. We are working towards building a calculator. If you have ideas or suggestions, please leave them in a comment and I promise I'll read them all and take them on board. I apologise for the heavy breathing in this one, mic position was poor and I was having trouble breathing tonight. Twitter: http://twitter.com/dsilverston...

Slides: http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf This was a talk I gave at the second New York Haskell User Group Meeting (http://www.meetup.com/NY-Haskell/) on the new lens library, which provides a highly composable toolbox for accessing and modifying multiple parts of data structures. Starting with building blocks such as fmap and (.), we build up combinators suitable for working with a wide array of data structures. These generalize the notions you already know how...

Google Tech Talk (more info below) October 14, 2011 Presented by Mark Lentczner. ABSTRACT Want to know a little more about programming Haskell than just the buzz-words? This talk will show you some of the joys coding in Haskell through lots and lots of code examples. No prior experience with Haskell or functional programming required. Just be ready for some strange and wondrous code! Slides: http://www.ozonehouse.com/mark/haskell-amuse-bouche/slides.html Code: https://github....