I'm officially resigning from the haskell.org committee effective immediately after the end of the Summer of Haskell.

To those of you on the committee, I apologize for abandoning you.

The reason I joined and have remained on the committee for the past several years is entirely to deal with the needs of the Summer of Code, both financially and administratively. It has provided me a way to give back to a community that has been so incredibly good to me.

When Galois managed our finances, someone had to deal with it. When we moved into SPI, it ironically started taking more effort. When we formed a non-profit in December things started looking up in terms of administrative overhead, but then we crushingly weren't accepted into the program this year.

In the wake of that I was somehow able to raise funding and wrangle us around $40,000 in sponsorship to fund eight students to work on Haskell for the summer. The outpouring of goodwill there was tangible. Those projects are wrapping up nicely now.

This part of my role within the committee has been as life affirming and wonderful as anything I've ever done.

However, the job is coming at an ever greater personal cost that I'm simply unwilling to continue to bear. My wife has come to dread the "there's someone wrong on the internet" moments, and I've come to realize it isn't fair to her -- I simply find myself spread too thin.

I shall continue to serve on the Core Libraries Committee, as I do continue to care deeply about the structure of the language we all love, if not so much the tooling around it, and I am willing to put in the time to on that front where I feel much more strongly about the issues at hand and have what I hope is a nuanced opinion to offer. Ultimately, the barbs thrown around, say, during the Foldable/Traversable Proposal, while heated, never felt personal, merely rational disagreement between well meaning parties with different priorities.

I care a great deal about our community; it was ultimately Cale and the rest of the folks in #haskell channel that lured me in at first, not any of the technical merits of the language. Those only took hold of me later on, but without that comfortable environment never would have had a chance to set.

I do not care enough about the contents of a web page to let my health, relationships, productivity and home life suffer further. I hope that by stepping back I can continue to retain or perhaps regain some of those friendships that recent events have strained.

--Edward Kmett

Hey fellow Haskellers,

I’m excited to announce that Functional Design and Architecture has just been released by Manning! 🎉 This project has been years in the making, and it’s finally ready to make a splash in the world of functional programming. 🌍

Why should you care?

For years, Haskell users have been asking for more guidance on best practices, application architecture, and design patterns—things we’ve seen abundant in OOP, but far less in FP. This book aims to fill that void. (You can find my article "The Voids of Haskell" very interesting in this regard; it's about imaginary Haskell books we could have but don't yet.)

With Haskell as the model language, I’ve worked hard to provide a universal reasoning framework for building real-world, scalable applications with functional programming principles. I call this methodology Functional Declarative Design. Think of it as a practical guide, but one that also tackles the deeper architectural challenges we face in industry.

This book is written for anyone passionate about practical functional programming. While the examples are in Haskell, the concepts apply across functional languages like Scala, OCaml, F#, and even C++ and C#. It brings an engineering approach to FP to help you build real-world applications.

A lot was done to accompany this book:

🟠 A full-fledged application framework, Hydra

🟡 The methodology of Functional Declarative Design

🟢 Authored a new architectural approach, Hierarchical Free Monads

🔵 A multitude of new design patterns, approaches, and practices, in addition to those that already existed;

🟣 Several demo applications, included both in the book and in the Hydra framework;

🟤 A wealth of accompanying material: articles, talks, and side projects;

⚪️ All the ideas were tested in various companies with a big success. It's not just a theoretical knowledge!

I’m incredibly honored to have endorsements from legends like:

• Scott Wlaschin (Domain Modeling Made Functional)

• Debasish Ghosh (Functional and Reactive Domain Modeling)

• Vitaly Bragilevsky (Haskell in Depth)

Comprehensive, with simple and clear code examples, lots of diagrams and very little jargon!

-- Scott Wlaschin

Fill an empty slot in the field of software architecture. I enjoyed reading about Haskell applications from the perspective of dsign and architecture.

-- Vitaly Bragilevsky

Discussess the goodness of functional programming patterns in the context of real world business applications. It explains free monads beautifully.

-- Debasish Ghosh

I got many highly positive reviews on the book. There’s even been talk of it becoming a new classic in Software Engineering!

What's next?

I’m already working on my next book, Pragmatic Type-Level Design, which will complement Functional Design and Architecture and provide practical methodologies for type-level programming. Expect it in early 2025!

If you’ve ever wanted to see Haskell take a bigger role in software engineering, I hope this book contributes to that goal.

🔗 Check out the book here: Functional Design and Architecture

Let me know what you think! 🙌

[1] Functional Design and Architecture (Manning Publications, 2024): https://www.manning.com/books/functional-design-and-architecture

[2] The Voids of Haskell: https://github.com/graninas/The-Voids-Of-Haskell

[3] Pragmatic Type-Level Design: https://leanpub.com/pragmatic-type-level-design

[4] Functional Design and Architecture, first edition, self-published in 2020: https://leanpub.com/functional-design-and-architecture

[5] Domain Modeling Made Functional by Scott Wlaschin: https://pragprog.com/titles/swdddf/domain-modeling-made-functional/

[6] Functional and Reactive Domain Modeling by Debasish Ghosh: https://www.manning.com/books/functional-and-reactive-domain-modeling

[7] Haskell in Depth by Vitaly Bragilevsky: https://www.manning.com/books/haskell-in-depth

I emailed Starch Press to let them know that the link from their Learn You a Haskell page to the author's site was down. They contacted the author, and it's back up. 😀

I'm happy to announce that my book "Production Haskell" is complete.

The book is a 500+ page distillation of my experience working with Haskell in industry. I believe it's the best resource available for building and scaling the use of Haskell in business.

To buy the ebook, go to the Leanpub page - the price is slightly lower here than on Amazon.

To buy hard copies, go to Amazon.

Thanks to all of you for reading my blog, commenting on Reddit, and encouraging me to write the book in the first place.

This really saddens me. I don't have much to say but that he is a great man and he has inspired me a lot. Let's hold him and his family in light.

Recently, Bartosz had completed his epic series on Category Theory on his blog.

I took it upon myself to try and convert this work into a PDF, and with his permission, so I have!

I scraped the blog, converted it to LaTeX using pandoc, and manually tweaked a whole bunch of things. The result is one beautifully-typeset PDF, if I say so myself :)

So please download the complete PDF here: https://github.com/hmemcpy/milewski-ctfp-pdf

Note: this is just the beginning, there's probably a lot still wrong, and it should be further "mathified". Please feel free to contribute (PRs, issues!)

Thank you!

While increasingly there is great material on learning category theory, specific information on how and why it is relevant to functional programming remains scattered throughout the web in the form of individual blogs posts, IRC logs and other random notes (maybe the exception is the excellent series of blog posts by Bartosz Milewski).

Over the last year I have been exploring the relationship between CT and Haskell, and have slowly been writing some detailed notes that cover the most relevant (and accessible) parts of this fascinating topic. They are a bit more detailed (in terms of mathematics) than most blog posts.

As a PhD student in (applied) mathematics, I shared this adventure with my colleagues semi-regularly in the form of a seminar. This has the benefit that the notes are largely set up so that many of the chapters can be read by themselves. The topics discussed are:

• Categories

• Types as a category

• Products

• Yoneda

• Closed Cartesian categories

• Adjunctions

• Monads

• F-algebras and recursion

• Comonads

• Lenses

The notes can be found here (PDF): https://github.com/jwbuurlage/category-theory-programmers/raw/master/doc/categories_for_programmers.pdf

I have set up a GitHub repository for tracking issues, or for contributing fixes.

Stephen Blackheath and I are extremely happy to report that as of today, GHC can natively build binaries for iOS devices and the iOS Simulator.

You'll find everything you need here: http://ghc.haskell.org/trac/ghc/wiki/Building/CrossCompiling/iOS

The short of it is you can use "ghc-ios myFiles.hs" to get a universal ARMv7/ARMv7s/i386 static library to drop straight into an Xcode project.

Stephen's already working on some wonderful FRP-powered games, I'm working on a project called SpaceTime that I'll announce shortly, and you may now all begin creating insanely great iOS software using the finest language in the world : ).

Stephen deserves the lion's share of the credit for this project — it's been over 3 years in the making! Many thanks to Maxwell Swadling for generalizing static library builds into a -staticlib flag for GHC, Carter Schonwald for compilation guidance, and the venerable Austin Seipp for reviewing and merging our patches.

Hello dear all,

My name is Alexander Granin, and I’m thrilled to announce that my book is finished!

Buy it: Functional Design and Architecture

It is a fundamental book about Software Design in Haskell. The main idea of this book is to provide a comprehensive source of knowledge, a complete methodology of building real world applications in Haskell. Application architectures, best practices, design patterns and approaches, - all the information you need to achieve a simple, maintainable, testable code with low complexity and low risks. By reading this book, you’ll learn many useful techniques: from the requirement analysis to the implementation of particular subsystems such as SQL and NoSQL databases, multithreading, logging. You’ll learn about design principles, application layers, functional interfaces, Inversion of Control and Dependency Injection in Haskell.

The book covers a big gap in the Haskell ecosystem: the lack of resources about high-level application design.

The book is very practical. It will be useful for software engineers who want to improve their software design skills with a strong relation to many advanced Haskell concepts. The book requires a certain level of Haskell knowledge, up to intermediate. In fact, it can be your third Haskell book (I recommend to read two books: "Get programming with Haskell" by Will Kurt and "Haskell in Depth" by Vitaly Bragilevsky). But I think my book will be somewhat approachable to functional developers in other languages (especially Scala, PureScript, F# and OCaml).

It’s also important that the ideas from the book were tried in real production with great success. You might have heard about Juspay, an Indian financial company, and its CEO, Vimal Kumar. I was a person who created several core technologies for this company in Haskell and PureScript, and this allowed Juspay to become a successful company widely known in the community. I’m proud that my approach drives their main frameworks. Not by chance, Vimal was one of the top supporters of the book on Patreon.

The text is completed and revised by a professional editor. My plan for September is to reformat and restyle the book to achieve the following goals:

• provide a better readability by choosing better fonts;

• prepare the book for printing on paper.

The book has 120K words, and will have ~600 pages in the proper formatting (currently it has 350 pages) 500 pages. Once I finish with all the preparations, I’ll print the book on paper and send a hardcopy to all buyers (who’ve chosen the corresponding option on LeanPub).

UPD The printing process is started. Paper copy is expeted at the end of November. Please send me your PurchaseID and your shipping address, and I'll send you a copy (for free).

I’m happy to be helpful to the community! Feel free to contact me and ask questions!

P.S. I say BIG THANKS to all people who supported this book on Patreon and not only on Patreon! You're awesome, and this book is possible because of your support!

Book topics:

• requirements analysis and architecture modeling;

• application layering;

• design principles, SOLID;

• Haskell-specific design patterns;

• Inversion of Control and Dependency Injection;

• domain modeling, embedded and external DSLs;

• functional interfaces, subsystems and services;

• Free monads, ReaderT pattern, Service handle pattern;

• Final Tagless/mtl, GADTs

• multithreading and concurrency;

• state and stateful applications;

• design of business logic;

• interaction with impure subsystems;

• relational and key-value databases;

• error handling, exceptions, error domains;

• web servers, HTTP backends, CLI applications;

• property-based, functional and integration testing;

• black box and white box testing.

/preview/pre/51x6lqmtluk51.jpg?width=794&format=pjpg&auto=webp&s=92a3a424e9f0f6a108cdfbbad091609b48aefd23

My friend u/jappieofficial (from the Netherlands) and I ( u/monadic_riuga ) recently made the long journey to the remote rural town of Haskell, Texas to fly a flag of the Haskell logo in front of the iconic 'Welcome to Haskell' sign, and to document that Haskellers have, in fact, been to Haskell.

We started from Houston, TX at NASA JSC, drove up to Dallas, stayed the night there, then made a beeline for Haskell out west the following morning, before finally driving through Waco back to Houston that same night. The whole journey took us just short of 1,000 miles (1,600km) and 15.5 hours of continuous driving. All in my beat up 1997 Honda Accord that we morbidly believed would break down in the middle of nowhere at some point for some inexplicable reason.

We've assembled a comedic recounting of our journey here for anyone who is keen to experience it as we did. Watch as we brave past reckless Dallas drivers, suffer past our car getting continuously skunked along I-35, and put up with an endless stream of corny Texas highway billboard signs along the route to the promised land.

Maybe one day we can host some sort of Haskell/GHC hacking retreat in Haskell, TX. Just a pipe dream lol. The closest major city with an airport would be Dallas/Fort Worth, and it's still a good ~3 hours drive west of Dallas even then.