4 hours ago

The bundle Visual Category Theory by Dmitry Vostokov is on sale on Leanpub! Its suggested price is $39.95; get it for $15.00 with this coupon: #ComputerScience #Mathematics #FunctionalProgramming #GraphTheory

In less than two hours (9PM Eastern) I'm going live to work on #AdventOfCode!

I'll be doing Days 5 and 6 in #FSharp!

Come for the #FunctionalProgramming, stay for the festive, Yule-time vibes.

#DotNet #LiveCoding

17 hours ago

Composing Software by Eric Elliott is on sale on Leanpub! Its suggested price is $34.00; get it for $25.50 with this coupon: #ComputerProgramming #FunctionalProgramming #Javascript #Software #SoftwareEngineering #SoftwareArchitecture

1 day ago

Functional-Light JavaScript (Book & Code) by Kyle Simpson is on sale on Leanpub! Its suggested price is $29.95; get it for $21.56 with this coupon: #Javascript #FunctionalProgramming

2 days ago

#CallForPapers #ICFP #ICFP2024 , International Conference on #FunctionalProgramming : "seeks contributions on the design, implementations, principles, and uses of functional programming, covering the entire spectrum of work, from practice to theory, including its peripheries" #fp

2 days ago

Hoopla just completed Day 4 of #adventofcode2023. The hoops I had to jump through to get part 2 to work for loops in C++ is 😵 But here it is!

#cpp #aoc #adventofcode #codingchallenge #functionalprogramming

GOING LIVE! #AdventOfCode 2023 Day 4! All in beautiful (okay, that's debatable), #FunctionalProgramming with #FSharp!

#DotNet #LiveCoding

4 days ago

The bundle Visual Category Theory by Dmitry Vostokov is on sale on Leanpub! Its suggested price is $39.95; get it for $15.00 with this coupon: #ComputerScience #Mathematics #FunctionalProgramming #GraphTheory

Simon Michael
5 days ago

Delighted to announce hledger 1.32, with more precision control, beancount output, TSV output, --summary-only, strict/idempotent import, CSV rule enhancements, timedot letters, fixes - it's a lot !


#hledger is free, fast, reliable, multi-currency, double-entry, #PlainTextAccounting software for unix, mac, windows, and the web.

#haskell #FunctionalProgramming #PersonalFinance

GOING LIVE! Good Yule tidings to all, we're going to do some #AdventOfCode, 2023 Edition!

All in pure, functional #FSharp and #DotNet!

#LiveCoding #OpenSource #FunctionalProgramming

6 days ago

Functional Programming for Mortals by Sam Halliday is free with a Leanpub Reader membership! Or you can buy it for $7.99! #Scala #FunctionalProgramming

1 week ago

Practical FP in Scala by Gabriel Volpe is on sale on Leanpub! Its suggested price is $49.99; get it for $35.99 with this coupon: #Scala #FunctionalProgramming #Software

1 week ago

Certainty by Construction by Sandy Maguire is on sale on Leanpub! Its suggested price is $80.00; get it for $28.00 with this coupon: #FunctionalProgramming #Mathematics #ComputerScience

1 week ago

Certainty by Construction by Sandy Maguire is on sale on Leanpub! Its suggested price is $80.00; get it for $28.00 with this coupon: #FunctionalProgramming #Mathematics #ComputerScience

John Bokma
1 week ago

Functional Programming, I/O is fast, Test factory functions in Django

#FunctionalProgramming #SoftwareDevelopment #python #movie #thriller

👉 Please retweet if you ❤ Plurrrr. Thanks! 👍

1 week ago
1 week ago

Practical FP in Scala + Functional event-driven architecture https://leanpub.comb/pfp-feda-scala by Gabriel Volpe is the featured bundle on the Leanpub homepage! #FunctionalProgramming #Scala #Software

1 week ago

Functional-Light JavaScript (Book & Code) by Kyle Simpson is on sale on Leanpub! Its suggested price is $29.95; get it for $21.56 with this coupon: #Javascript #FunctionalProgramming
2 weeks ago

I thought this might present some interest to other Elixir developers and to those interested in functional programming. It's free and it's virtual.

#myelixirstatus #poetry #functionalprogramming

2 weeks ago

RIP David Turner, creator of #Miranda and long standing pillar of the #FunctionalProgramming community.

2 weeks ago

Practical FP in Scala by Gabriel Volpe is on sale on Leanpub! Its suggested price is $49.99; get it for $35.99 with this coupon: #Scala #FunctionalProgramming #Software

2 weeks ago

Composing Software by Eric Elliott is on sale on Leanpub! Its suggested price is $34.00; get it for $25.50 with this coupon: #ComputerProgramming #FunctionalProgramming #Javascript #Software #SoftwareEngineering #SoftwareArchitecture

José A. Alonso
2 weeks ago

The Haskell Unfolder Episode 15: Interruptible operations. ~ Edsko de Vries (@EdskoDeVries), Andres Löh (@kosmikus). #Haskell #FunctionalProgramming

Anupam 《ミ》λ≡
2 weeks ago

Attention #Delhi NCR / #Gurgaon people.

🚨Announcing a new #Haskell meetup near you🚨

We are learning Haskell from the ground up, with in person meetups and online events!

Kickoff is this Saturday @ WeWork Two Horizon Gurgaon. Join us!

#FunctionalProgramming #India #Meetup

2 weeks ago

🦾 Funktal: a frugal functional programming language | @wim_v12e

"The main principle for the design of Funktal is that it should use as little memory as possible, both for the compiler and the programs it produces. This influences most of the design decisions. But at the same time, it should be minimally but fully featured"

#Funktal #FunctionalProgramming

2 weeks ago

Since other people are discussing these things, always a good reminder that on #scala using cats-effect library and using #FunctionalProgramming these thing are properly abstracted away nowadays and on daily usage one finally barely has to care at all about it. -


Two kinds of threads pools, and why you need both | Lobsters -


3 weeks ago

🐫 Beyond TypeScript: Differences Between Typed Languages
➥ Javier Chávarri

「 Maintaining codebases became much easier, regardless of their size. And day-to-day work felt more like having a super pro sidekick that helped me identify issues in the code as I refactored it. This was a very different feeling from what I had experienced with TypeScript and Flow 」

#TypeScript #OCaml #ReasonML #FunctionalProgramming

Jakub Zalas
1 month ago

Two weeks ago I published a post about a functional modeling approach to event sourcing. This week I'd like to dig deeper into an example implementation in Kotlin.

#functionalprogramming #eventsourcing #kotlin #arrowkt #ddd #dddesign

Editor showing command, event and error classes.
Karsten Schmidt
1 month ago

#HowToThing #026 — Shader meta-programming techniques (functional composition, higher-order functions, compile-time evaluation, dynamic code generation etc.) to generate animated plots/graphs of 16 functions (incl. dynamic grid layout generation) within a single WebGL fragment shader.

Today's key packages:

- DSL to write (fully type-checked) shaders directly in TypeScript and later compile them to GLSL, JS (and other target languages, i.e. there's partial support for Houdini VEX and [very] early stage WGSL...)
- Collection of ~220 re-usable shader functions & configurable building blocks (incl. SDFs primitives/ops, raymarching, lighting, matrix ops, etc.)
- Minimal scaffolding for experimenting with fragment shaders (supports both normal GLSL or shader-ast flavors/compilation)

If you're new to the Shader-AST approach (highly likely!), this example will again introduce a lot of new concepts, hopefully in digestible manner! Please also always consult the package readmes (and other linked examples) for more background info... There're numerous benefits to this approach (incl. targetting different target langs and compositional & optimization aspects which are impossible to achieve (at least not elegantly) via just string concatenation/interpolation of shader code, as is much more commonplace...)

This example comes fresh off the back of yesterday's new easing function additions (by @Yura), though we're only showing a subset here...

(Check the console to view the generated GLSL shader)

Source code:

If you have any questions about this topic or the packages used here, please reply in thread or use the discussion forum (or issue tracker):

#ThingUmbrella #WebGL #Shader #GLSL #FunctionalProgramming #GraphicsProgramming #Plot #CodeGeneration #DSL #TypeScript #JavaScript #Tutorial

Screenshot of the linked example project, showing the plots/graphs of 16 easing functions in a 4x4 grid. Each function's curve has white-cyan gradient and a moving pink dot showing the current position on the curve... The grid cell under the mouse position is highlighted in lighter gray than the normal background color
Screenshot of the 1st part of the linked TypeScript source code
Screenshot of the 2nd part of the linked TypeScript source code
Jakub Zalas
2 months ago

In the previous post, we looked at the benefits of a domain model implemented in a purely functional code.

This time, we’ll consider how it might work in practice by applying the event sourcing pattern to a functional domain model.

As it turns out the two go very well together.

Read more in my latest post “Functional event sourcing”:

#eventsourcing #fp #functionalprogramming #ddd #kotlin #arrow #ArrowKt

Jakub Zalas
2 months ago

That's what my last blog post is about - "Functional domain model " -

I'm warming up to a few more blog posts to continue this topic.

#ddd #dddesign #functionalprogramming #fp #kotlin

Jakub Zalas
2 months ago

A functional domain model is made of pure functions and immutable types. As Domain Driven Design teaches us, it should be expressed in the language shared by everyone involved in the project.

The domain model is arguably the most important layer in an application. It should also be where complexity is tackled.

#ddd #dddesign #functionalprogramming #fp #kotlin

2 months ago

#ThrowbackThursday to when I got published in php[architect] with the fantastic title: Fiendish Functions Filtering Fact From Fiction

After saying that five times fast, I really thought it was interesting the myths that float around #FunctionalProgramming in the #PHP world so laid out a few arguments on those.

Jan :rust: :ferris:
2 months ago

This looks wild! 🤯

civet - The Modern Way to Write #TypeScript

#ProgrammingLanguage #Transpiler #FunctionalProgramming

Simon Vergauwen
2 months ago

I had an awesome time last week delivering both the #functionalprogramming essentials, and the Advanced Coroutines training in #kotlin at Xebia with Xebia Functional!

Thank everyone for the organisation, behind the scenes, for the lovely feedback! Lets do it again soon🙌

Simon Vergauwen delivering Advanced Coroutines Training.
Feedback on YouTube comments during live stream.
Simon Vergauwen delivering Functional Programming essentials training, and Francisco Díaz Rodríguez as co-trainer.
Karsten Schmidt
3 months ago

#HowToThing #016 — Building a small (and very incomplete!) Mastodon UI with #ThingUmbrella. Still, the following features are included so far and demonstrate:

- Looking up Mastodon account details & loading public messages for any given username
- Transforming JSON payloads with
- HTML parsing, cleaning & rewriting via
- Reactive UI components via &
- Polymorphic (multiple-dispatch) functions via

UI features:

- Account details w/ header image, avatar, bio
- Media previews for images, gifv, videos
- Fullscreen modal overlay for images & alt text
- UI design heavily inspired by the amazing @phanpy (😍)

Alas, the code for this new example (#131) is too long & too split up for showing here in this format, but it's well documented and you can find it all linked below...



I hope this (and other parts) of this ongoing #HowToThing series are interesting to you. If so, please consider boosting and/or supporting my #OpenSource work via GitHub or Patreon. Thank you very much in advance!

#TypeScript #JavaScript #Mastodon #UI #Reactive #FunctionalProgramming

Screenshot of the demo Mastodon UI

I am looking for an iterator who repeatedly applies a function to itself, so it's elements are (when starting with zero):

f( 0 )
f( f( 0 ) )
f( f( f( 0 ) ) )

I know I can implement this myself, but this feels like a pretty useful thing so I am guessing it already exists and I just don't know about it yet.

Kinda like a reverse fold operation?

#rust #functionalProgramming #functional

Yann Büchau :nixos:
3 months ago

On that note: Do people with a native language that reads right-to-left like #Arabic, #Japanese or #Chinese actually find #FunctionalProgramming languages like :haskell: #Haskell easier to read? 🤔

Csepp 🌢
3 months ago

Do people with a #functionalProgramming background have an easier time with #electronics / #hardware design? Thinking specifically of things like #FPGA dev.
I was listening to an Unnamed RE episode recently where the difficulty of learning an HDL was attributed to it "not being like programming", where "programming" means "writing a series of instructions that modify state".
Also worth asking if this extends to other math-y areas.

Haskell Weekly
3 months ago
Karsten Schmidt
3 months ago

#HowToThing #014 — Building a simple browser REPL UI for yesterday's Lispy S-expression mini language[1], using and other usual suspects like &

The language impl itself now also has local let-bindings, some more error checking, introspection and more examples of built-in functions...


Source code:

(The attached source code image only shows the UI/REPL parts, the language implementation can be found in the above link...)

#ThingUmbrella #TypeScript #JavaScript #Lisp #FunctionalProgramming #Reactive #UI #REPL #DSL

[1] See yesterday's toot about building/using a mini DSL:

Screenshot of the browser REPL in action
Screenshot of the 1st part of the TypeScript source code for the UI/REPL parts of the example
Screenshot of the 2nd part of the TypeScript source code for the UI/REPL parts of the example
Karsten Schmidt
3 months ago

#HowToThing #009 — Basic 2D canvas drawing and using the `threadLast()` dataflow operator from for better legibility & comprehension of complex, nested call expressions, e.g. as used in functional data transformation pipelines.

In this example, we're transforming a stream of timestamps (from `requestionAnimationFrame()`), into animated 2D curve points, those into colored circle shapes and finally wrap all into a single group/scene for drawing.

A more basic intro example of the operator is included at the beginning... (#Clojure people will know the same as the `->>` macro)

Other packages used:

- - points/curve generation via oscillators
- - shape types
- - reactive stream creation
- - reactive canvas creation & drawing
- - data transformations


Source code:

#ThingUmbrella #FunctionalProgramming #TypeScript #JavaScript #Animation #Tutorial

1st part of the TypeScript source code of the example linked in the toot...
2nd part of the TypeScript source code of the example linked in the toot...
Screenrecording of the animation produced by the code example. 100 circles moving along a dynamically generated/animated curve
Karsten Schmidt
4 months ago

Announcing #HowToThing, small code snippets illustrating useful patterns and use cases for various libraries/projects in the ecosystem/anti-framework...

#HowToThing #001:
Build a FPS counter with moving average w/

Source code in alt text

(Ps. Have been trying to start similar stuff in the past on the birdsite, but let's see if I can control my attention and be more consistent this time... If you have any topic requests, please reply below [or via DM])

#ThingUmbrella #TypeScript #JavaScript #FunctionalProgramming #Transducers #Tutorial

import { fiber } from "";
import { benchmark, comp, map, movingAverage, step } from "";

// compose a FPS counter function from multiple transducers
// the `step` function is a wrapper for step-wise execution
const fps = step(
        // measure time since last input
        // (the input value itself is irrelevant)
        // simple moving average (period=30)
        // convert time into frequency (frame per second), format
        map((x) => (1000 / x).toFixed(1) + " fps")

// example usage
// (in browsers default execution of fibers is via requestAnimationFrame())
fiber(function* () {
    while (true) {
        // compute next step of FPS counter
        // since we're using a moving average of 30,
        // the first 29 frames will not yield any result (returns `undefined`)
        // the logical-OR (`||`) will then choose a fallback string
        const currFps = fps(0) || "[sampling]";
        // wait until next frame

// see docs for more details:
4 months ago

λ What is Functional Programming?
➥ Magnus Sedlacek - Ada Beat

#FP #FunctionalProgramming #Haskell #Erlang #Lisp

Anupam 《ミ》λ≡
4 months ago

Would you or your company like to #sponsor or host #FunctionalProgramming events in the Delhi-NCR region?

We at #FPIndia are starting to organise in-person events. There's an #Elixir+FP meetup on 5 Aug, and a #Rust+FP meetup on 26 Aug.

If you want to help us organise more, DM me!

J. David Eisenberg
4 months ago

How is it that I did not know about Stream in #Java, which lets you do many #functionalProgramming operations, and has been around since 2014 (v1.8)?

Jakub Zalas
4 months ago

From Grokking Simplicity:

“Onion architecture is a pattern that occurs naturally when you apply #functionalprogramming practices.”

It’s interesting, as I always thought that #HexagonalArchitecture is what occurs naturally when I practice #tdd and apply solid principles.

Number four: #tcl #tcltk. Not as much hate as Perl gets, but a lot of misconceptions that I want to clear up for people who might hear about this for the first time:

  1. Tcl != Tk. Although they’re released together nowadays, Tk is a standalone cross-platform widget toolkit. That’s where the Tk in Tkinter comes from. There are several bindings for Tk: Ada (TASH), Python (the aforementioned Tkinter), Perl (Tcl::Tk, Tkx and Perl/Tk if you want native Perl access to Tk structures), Lua (tclua and ltcltk), Haskell (HTk), Ruby, Scheme, Ksh (through dtksh), R (tcltk) and probably many others. The Python bindings even use Tcl as a bridge to Tk, same with Tcl::Tk and Tkx from Perl).

  2. “Tk looks bad”. While it used to look like Motif on Unices, now it has (for quite some time) a native look and feel + theming support. Tkinter people sure don’t complain and probably neither do you realistically speaking.

  3. “Tcl is a toy language”. On the contrary, it’s really powerful with the syntax it has (that and its syntax is defined by the Dekalogue, only 12 rules). In a way, it’s like Lisp and Forth (two of my crushes). I even tried a Forth-esque DSL in Tcl… and I could actually do it. I can implement if I wish try/catch,, exceptions, classes, I can model it to my liking. This argument is genuinely more petty than even “Lisp has too many parentheses”. Additionally, it isn’t complex, which is a good thing (you can actually understand the whole language, implementation included). You can even redefine anything in Tcl using rename or have access to the Tcl interpreter using eval, uplevel and upvar for some metaprogramming if you so wish.

  4. “Tcl has no types”. Yes, if you want to be strict about it, it only has strings (although that’s like saying that Lisp only has lists). You don’t need to perform conversions, however you aren’t likely to introduce bugs because the checks on the format of the strings are very strict. It’s a bit like Postel’s law: “be conservative in what you send, be liberal in what you accept”, but in reverse I think. Even better, you don’t need serialization because everything is a string already. You can even do stuff like sending a list through a TCP socket through puts $socket $mylist and on the other side set mylist [read $socket], it’s that easy. The central data structure is the list, not the string, and any Lisp programmers knows the implications of that.

  5. “Tcl is slow”. This shares the same sentiment as in the Perl argument. Of course it isn’t gonna be a power house for sure in the runtime department, but it sure is quick to develop in. Heck, once you have some commands going on, you can start writing executable files that look like configuration (if you really tried, you could surely replicate #nginx syntax for example).

Besides that, there are a couple of other nice things about Tcl:

  • you can have multiple paradigms: since the language is so flexible, you can add #oop, #functionalprogramming #fp programming, even throw some arrays for good measure (I have seen a code snippet somewhere in the Tcler’s wiki of someone doing vector arithmetic using just raw Tcl and some elbow grease).
  • because code in Tcl is first class, it’s very simple to write functional language primitives that play well with the logic of the language (for examplem with stock Tcl you can do lmap i {1 2 3 4 5} { expr $i*$i} which prints 1 4 9 16 25.
  • the Tcl source code is (in my humble opinion) one of the best written C programs you’ll find (please, look at it for yourself), the quality of the interpreter is amazing. It works exactly the same in different environment, including Tk).
  • in a way, considering how it’s written, you can kinda think about it as an accessible Lisp with square brackets (it essentially works on the same sort of notation without the s-expr part).
  • easy shelling? check. easily embeddable? check. easy sandboxable? check. reasonably rich standard library - check. high level abstractions - check. you can find all of these and more in Tcl. ;)
  • Erlang’s author said in a tweet (
    “You know - TCL/TK8.6 is insanely great.

I stopped using TCL/wish in about 2004 - this was a BIG
mistake - I can now build GUIs in described by pure text.
Nothing is hidden it’s all text - I just need emacs and make.

Why oh why did I ever even click on a button to start Xcode”

The only people that are mad about Tcl/Tk at this point are RMS (because he’s still butthurt that #guile failed in face of Tcl and not even Emacs adopted, only Guix (Guile is good though), he even went so far as to call John Ousterhout a “parasite” (ironic coming from him, huh?)), MAYBE Larry Wall and people who didn’t bother checking up Tk (or looking at Tcl ever). And with that (for today, I think) I am done, although I could touch up on #forth, #php, #ada, #cobol, #smalltalk, #fortran… Even #ml #prolog. These languages deserve some love too, even though they aren’t particularly used. I truly believe that Tcl should become a more popular language, for me it was love at first sight (I like it so much that this is the language I chose to implement for my bachelor’s thesis on a Raspberry Pi Pico). Long live Tcl.

Thinking Elixir
5 months ago
Making the leap from OOP to Functional? Unleash the power of #Elixir! We chat with Steve Bussey about his book “From Ruby to Elixir” and about navigating the mental shift to build amazing applications. #FunctionalProgramming #Ruby
6 months ago

@SummerSchool My talk will be on a frugal functional programming language for the tiny Uxn virtual machine that I have been working on.
#Uxn #SolsticeSchool #FunctionalProgramming

6 months ago

haihai, uh, #introduction

name is essi, using she/her. roughly thirty (huh).

im into
#programming, work in a kinda unique corner of #gamedev. at work just #code, free time also more #art and #music stuff as well. pretty much entirely self-taught, but it's been about 20 years at this point, so not entirely lost anymore.

another main interest would be
#linguistics and #communication generally, which might explain my letter collection (as in diagnoses, #autism and #adhd, as well as both the b and t in #lgbt).

the generalization really is systems, or how small and relatively simple things can come together to a beatiful, tantalizing whole.

among games, mainly into fps and fighting games. talking
#code, full-stack, with a love in particular for #functionalprogramming and the #math side of things (abstract algebra, my beloved ❤️); mostly writing #csharp and #typescript.

#foss, of course, already considering a PR for #calckey when i get some time left over...

probably missed something semi-vital, but uh, yeah, tl;dr essi, she/her, nice to meet you?

Ben Evans
6 months ago

Super happy that my book, the Well-Grounded Java Developer (2nd Edition) is once again in Manning's Top 10 titles - #java #jvm #concurrency #functionalprogramming

Jan :rust: :ferris:
6 months ago

#Prediction: #RocLang will make purely functional programming languages mainstream and much more accessible.

#ProgrammingLanguage #FunctionalProgramming #DX #DeveloperExperience