#FunctionalProgramming
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: https://leanpub.com/b/categories/c/socialpostsale20231204 #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.
This is amazing, super close to my heart, and more important than I think most will initially realize! Can't believe I didn't notice this sooner.
#functionalprogramming #functional #knowledge #KnowledgeSystems #wikimedia #wikipedia #library #LibrarySocialism #knowledgeispower #EmpowerEveryone
Composing Software by Eric Elliott is on sale on Leanpub! Its suggested price is $34.00; get it for $25.50 with this coupon: https://leanpub.com/sh/BQNDWLn1 #ComputerProgramming #FunctionalProgramming #Javascript #Software #SoftwareEngineering #SoftwareArchitecture
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: https://leanpub.com/sh/wXfi2kUd #Javascript #FunctionalProgramming
#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 https://icfp24.sigplan.org/track/icfp-2024-papers#Call-for-Papers
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! https://github.com/somecho/aoc23.cpp/blob/main/src/day_4_2.cpp
#cpp #aoc #adventofcode #codingchallenge #functionalprogramming
GOING LIVE! #AdventOfCode 2023 Day 4! All in beautiful (okay, that's debatable), #FunctionalProgramming with #FSharp!
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: https://leanpub.com/b/categories/c/LeanpubWeeklySale2023Dec01 #ComputerScience #Mathematics #FunctionalProgramming #GraphTheory
GOING LIVE! #AdventOfCode Day Two in #FSharp!
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 !
- https://hledger.org/release-notes.html#2023-12-01-hledger-132
- https://hledger.org/install
#hledger is free, fast, reliable, multi-currency, double-entry, #PlainTextAccounting software for unix, mac, windows, and the web.
https://hledger.org
GOING LIVE! Good Yule tidings to all, we're going to do some #AdventOfCode, 2023 Edition!
Functional Programming for Mortals by Sam Halliday is free with a Leanpub Reader membership! Or you can buy it for $7.99! http://leanpub.com/fpmortals #Scala #FunctionalProgramming
λ Building a startup on Clojure | Wobaka
https://wobaka.com/blog/building-a-startup-on-clojure/
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: https://leanpub.com/sh/0xjfXQL2 #Scala #FunctionalProgramming #Software
:blobaww: Why is Elm such a delightful programming language?
https://dev.to/marciofrayze/why-is-elm-such-a-delightful-programming-language-2em8
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: https://leanpub.com/sh/oDmMKY19 #FunctionalProgramming #Mathematics #ComputerScience
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: https://leanpub.com/sh/5vASz92t #FunctionalProgramming #Mathematics #ComputerScience
Functional Programming, I/O is fast, Test factory functions in Django
#FunctionalProgramming #SoftwareDevelopment #python #movie #thriller
👉 Please retweet if you ❤ Plurrrr. Thanks! 👍
λ Why My Brain Is Wired for Clojure | HackerNoon
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! https://leanpub.com #FunctionalProgramming #Scala #Software
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: https://leanpub.com/sh/xAVPx7uF #Javascript #FunctionalProgramming
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.
https://www.meetup.com/functional-programming-meetup-group-the-functional-lab/events/296993803/
RIP David Turner, creator of #Miranda and long standing pillar of the #FunctionalProgramming community. https://www.theguardian.com/technology/2023/nov/24/david-turner-obituary
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: https://leanpub.com/sh/hz8QiZy5 #Scala #FunctionalProgramming #Software
Composing Software by Eric Elliott is on sale on Leanpub! Its suggested price is $34.00; get it for $25.50 with this coupon: https://leanpub.com/sh/tjvN9cb4 #ComputerProgramming #FunctionalProgramming #Javascript #Software #SoftwareEngineering #SoftwareArchitecture
The Haskell Unfolder Episode 15: Interruptible operations. ~ Edsko de Vries (@EdskoDeVries), Andres Löh (@kosmikus). https://www.youtube.com/live/VpYC-uixrEQ #Haskell #FunctionalProgramming
🦾 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"
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. - https://typelevel.org/cats-effect/docs/thread-model
----
Two kinds of threads pools, and why you need both | Lobsters - https://lobste.rs/s/k8knw4/two_kinds_threads_pools_why_you_need_both
🐫 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 」
https://tech.ahrefs.com/beyond-typescript-differences-between-typed-languages-f3e14253
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.
https://dev.to/jakub_zalas/functional-event-sourcing-example-in-kotlin-3245
#functionalprogramming #eventsourcing #kotlin #arrowkt #ddd #dddesign
#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:
- https://thi.ng/shader-ast: 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...)
- https://thi.ng/shader-ast-stdlib: Collection of ~220 re-usable shader functions & configurable building blocks (incl. SDFs primitives/ops, raymarching, lighting, matrix ops, etc.)
- https://thi.ng/webgl-shadertoy: 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...
Demo:
https://demo.thi.ng/umbrella/shader-ast-easings/
(Check the console to view the generated GLSL shader)
Source code:
https://github.com/thi-ng/umbrella/tree/develop/examples/shader-ast-easings/src/index.ts
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):
github.com/thi-ng/umbrella/discussions
#ThingUmbrella #WebGL #Shader #GLSL #FunctionalProgramming #GraphicsProgramming #Plot #CodeGeneration #DSL #TypeScript #JavaScript #Tutorial
Why you should learn #StronglyTypedFunctionalProgramming
From Martin Odersky's talk about #Scala https://youtu.be/7mTNZeiIK7E
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”: https://dev.to/jakub_zalas/functional-event-sourcing-1ea5
#eventsourcing #fp #functionalprogramming #ddd #kotlin #arrow #ArrowKt
That's what my last blog post is about - "Functional domain model " - https://dev.to/jakub_zalas/functional-domain-model-o3j
I'm warming up to a few more blog posts to continue this topic.
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.
#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.
https://www.phparch.com/2021/05/fiendish-functions-filtering-fact-from-fiction/
This looks wild! 🤯
civet - The Modern Way to Write #TypeScript
Gleam v0.31.0 is out now! ✨
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🙌
#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 https://thi.ng/transducers
- HTML parsing, cleaning & rewriting via https://thi.ng/parse
- Reactive UI components via https://thi.ng/rstream & https://thi.ng/rdom
- Polymorphic (multiple-dispatch) functions via https://thi.ng/defmulti
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...
Demo:
https://demo.thi.ng/umbrella/mastodon-feed/
Source:
https://github.com/thi-ng/umbrella/tree/develop/examples/mastodon-feed/src
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!
https://github.com/sponsors/postspectacular
https://patreon.com/thing_umbrella
#TypeScript #JavaScript #Mastodon #UI #Reactive #FunctionalProgramming
I am looking for an iterator who repeatedly applies a function to itself, so it's elements are (when starting with zero):
0
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
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? 🤔
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.
Learn Physics with Functional Programming - A Hands-on Guide to Exploring Physics with Haskell
https://nostarch.com/learn-physics-functional-programming
Discussions: https://discu.eu/q/https://nostarch.com/learn-physics-functional-programming
#HowToThing #014 — Building a simple browser REPL UI for yesterday's Lispy S-expression mini language[1], using https://thi.ng/rdom and other usual suspects like https://thi.ng/rstream & https://thi.ng/transducers.
The language impl itself now also has local let-bindings, some more error checking, introspection and more examples of built-in functions...
Demo:
https://demo.thi.ng/umbrella/lispy-repl/
Source code:
https://github.com/thi-ng/umbrella/blob/develop/examples/lispy-repl
(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:
https://mastodon.thi.ng/@toxi/111006345413482231
#HowToThing #009 — Basic 2D canvas drawing and using the `threadLast()` dataflow operator from https://thi.ng/compose 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:
- https://thi.ng/dsp - points/curve generation via oscillators
- https://thi.ng/geom - shape types
- https://thi.ng/rstream - reactive stream creation
- https://thi.ng/rdom-canvas - reactive canvas creation & drawing
- https://thi.ng/transducers - data transformations
Demo:
https://demo.thi.ng/umbrella/rdom-canvas-basics/
Source code:
https://github.com/thi-ng/umbrella/blob/develop/examples/rdom-canvas-basics/src/index.ts
#ThingUmbrella #FunctionalProgramming #TypeScript #JavaScript #Animation #Tutorial
Announcing #HowToThing, small code snippets illustrating useful patterns and use cases for various libraries/projects in the https://thi.ng ecosystem/anti-framework...
#HowToThing #001:
Build a FPS counter with moving average w/ https://thi.ng/transducers
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
λ What is Functional Programming?
➥ Magnus Sedlacek - Ada Beat
#FP #FunctionalProgramming #Haskell #Erlang #Lisp
https://adabeat.com/fp/what-is-functional-programming/
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!
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)?
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:
-
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).
-
“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.
-
“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, for..in, 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
renameor have access to the Tcl interpreter usingeval,uplevelandupvarfor some metaprogramming if you so wish. -
“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 $mylistand on the other sideset 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. -
“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 (http://web.archive.org/web/20190325110123/https://twitter.com/joeerl/status/1110126278953312256):
“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.
@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
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?
Super happy that my book, the Well-Grounded Java Developer (2nd Edition) is once again in Manning's Top 10 titles - https://shortener.manning.com/2rM9 #java #jvm #concurrency #functionalprogramming
A Skeptic’s Guide to Functional Programming with JavaScript
https://jrsinclair.com/skeptics-guide#buy-book
Discussions: https://discu.eu/q/https://jrsinclair.com/skeptics-guide%23buy-book
#Prediction: #RocLang will make purely functional programming languages mainstream and much more accessible.
#ProgrammingLanguage #FunctionalProgramming #DX #DeveloperExperience