#haskell
The current GHC Contributors' Workshop talk "The GHC Packaging Ecosystem" https://youtube.com/video/9aciLG-EpIc by Duncan Coutts (slides https://haskell.foundation/assets/other/Duncan%20Coutts%20-%20GHC%20Tool%20Ecosystem.pdf) is really worth watching! #ZuriHac #Haskell
Issue 371 :: Haskell Weekly newsletter
https://haskellweekly.news/issue/371.html
Discussions: https://discu.eu/q/https://haskellweekly.news/issue/371.html
>λ= Why Liquid Haskell matters | Facundo Domínguez
⎧ The point is not so much that proofs are easier with Liquid Haskell, but rather that we are in front of an approach that integrates well with a programming language as is, and yet it leverages the power of tools specialized to reason about logic when verifying programs ⎭
#Haskell #LiquidHaskell #FormalMethods
https://www.tweag.io/blog/2022-01-19-why-liquid-haskell/
[Tw] RT @kakkun61: コモナドを使うことで木構造のノードの持つ値を再帰的に総和していくコードが簡単に書けた。ファイルシステムのディレクトリーごとのファイルサイズの総和とかをイメージしてる。 #Haskell https://t.co/cOGOUxBg24
[de] https://twitter.com/windymelt/status/1666890971550973952
Announcing halide-haskell - a Haskell interface for the Halide image and array processing language
https://www.tweag.io/blog/2023-06-08-announcing-halide-haskell/
Discussions: https://discu.eu/q/https://www.tweag.io/blog/2023-06-08-announcing-halide-haskell/
La campagne de recrutement des ingénieurs @CNRS titulaires est ouverte jusqu'au 5 juillet et il y a un poste pour venir travailler avec nous !
A l'Institut des Systèmes Complexes de Paris Île-de-France, sur #GarganText, développez à la pointe de la techno en #textmining #IA #haskell & #infoviz et bien sûr en libre. Go go go! ⬇️
https://iscpif.fr/projects/gargantext/
The recruitment campaign for tenured @CNRS engineers is open until July 5 and there's a position to come and work with us in Paris ! At the Complex Systems Institute, on #GarganText, you will develop at the cutting edge of #textmining #IA #haskell & #infoviz , etc. And of course, it's a free software ! Go go go!⬇️
https://iscpif.fr/projects/gargantext
New trident release v1.2.0.0! Please see the changelog here: https://github.com/poseidon-framework/poseidon-hs/releases/tag/v1.2.0.0 #aDNA #OpenData #Haskell
The #Haskell security-advisories repo is open for submissions. We will have folks at ZuriHac (and in its Discord) if you want to contribute known/historical issues or help develop our tooling. https://github.com/haskell/security-advisories
Issue 371
Welcome to another issue of Haskell Weekly! Haskell is a safe, purely functional programming language with a fast, concurrent runtime. This is a weekly summary of what’s going on in its community.
https://haskellweekly.news/issue/371.html
#haskell #rss
#haskell type error that is designed to make me smile every time I have to deal with it
Tom's Guide to #Haskell Performance: Set a stack size limit with `+RTS -K`.
That's it. That's the guide.
#haskell tip, cryptonite has been forked to crypton.
You need to pin to less than 1.7 for TLS if you don't want build errors like this: https://github.com/kazu-yamamoto/crypton/issues/2
Network/Connection.hs:122:43: error:
• Couldn't match expected type ‘crypton-x509-store-1.6.9:Data.X509.CertificateStore.CertificateStore’
with actual type ‘Data.X509.CertificateStore.CertificateStore
Dynamic programming in Haskell: automatic memoization. ~ Brent Yorgey. https://byorgey.wordpress.com/2023/06/06/dynamic-programming-in-haskell-automatic-memoization/ #Haskell #FunctionalProgramming
Haskell tip: when trying to make unrepresentable states unrepresentable in your code, try your best to use types to keep related data together and "parse, don't validate!"
In other words, don't have different fields of a record depend on one another having particular combinations of values. You'll end up having validation logic all over your code and may make mistakes when maintaining it.
Instead make a new type that captures the dependencies and have one field in your record with that type.
10 Days of grad: Deep learning from the first principles (Day 10: Beyond supervised learning). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day10/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 9: Roaming the latent space). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day9/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 8: Model uncertainty estimation). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day8/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 7: Real world deep learning). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day7/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 6: Saving energy with binarized neural networks). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day6/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 5: Convolutional neural networks tutorial). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day5/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 4: The importance of batch normalization). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day4/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 3: Haskell guide to neural networks). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day3/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 2: What do hidden layers do?). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day2/ #Haskell #FunctionalProgramming #AI #DeepLearning
10 Days of grad: Deep learning from the first principles (Day 1: Learning neural networks the hard way). ~ Bogdan Penkovsky (@penkovsky). https://penkovsky.com/neural-networks/day1/ #Haskell #FunctionalProgramming #AI #DeepLearning
While on my train 🚆 journey heading to #ZuriHac 2023, and preparing for my participation in the GHC Contributors' Workshop tomorrow, I go through this visual introduction to RTS (#Haskell runtime) https://takenobu-hs.github.io/downloads/haskell_ghc_illustrated.pdf It's great! Thanks, Jaro, for the recommendation on Discord 🙂
Journal of Functional Programming - Call for PhD Abstracts
http://www.cs.nott.ac.uk/~pszgmh/jfp-phd-abstracts.html
Discussions: https://discu.eu/q/http://www.cs.nott.ac.uk/~pszgmh/jfp-phd-abstracts.html
Crypton is forked from cryptonite with the original authors permission
https://github.com/kazu-yamamoto/crypton
Discussions: https://discu.eu/q/https://github.com/kazu-yamamoto/crypton
Questions about Haskell and FP (Paper)
https://arxiv.org/pdf/2105.02856.pdf
Discussions: https://discu.eu/q/https://arxiv.org/pdf/2105.02856.pdf
MuniHac 2023 • July 7-9 • on-site in Munich
Discussions: https://discu.eu/q/https://munihac.de/2023.html
#Scala's type classes are first-class, in a very literal sense.
Ironically, Scala's type classes are more first-class than #Haskell's.
Not only because Scala 3 now has good syntax for extension methods, or for deriving instances, but also because …
‣ Type classes are just types;
‣ Type class instances are simply values passed as params.
The issue in Scala is that “coherence” relies on a weaker non-ambiguous check, instead of “canonicity”, but this plays better w/ OOP or dynamic linking.
Brisbane Functional Programming Group #BFPG Tue 2023-06-20. Two presos: 1) #FP in #TypeScript 2) #Haskell project bootstrap - Cabal and haskell-ci. Be there or be a lambda cube! https://www.meetup.com/brisbane-functional-programming-group/events/293986409
haskell-ci how-to: caching and using your program executable
https://frasertweedale.github.io/blog-fp/posts/2023-06-04-haskell-ci-use-executable.html
Discussions: https://discu.eu/q/https://frasertweedale.github.io/blog-fp/posts/2023-06-04-haskell-ci-use-executable.html
The decision to use Ruby for Mastodon was a poor choice, to put it mildly.
The diagram below shows relative energy consumption, with values normalized to the most efficient one. So C, as the most energy efficient, has the value 1.
#MastoDev #FediDev #Programming #C #Rust #CPP #Java #Lisp #Haskell #Go #JavaScript #Python #Ruby #Permacomputing
Libro "Piensa en Haskell y en Python" (versión del 3-junio-23). https://raw.githubusercontent.com/jaalonso/Piensa-en-Haskell-y-en-Python/main/Piensa_en_Haskell_y_en_Python.pdf #Haskell #Python #Matemáticas #Algorítmica
Call for Papers - JFP Special Issue on Program Calculation
Discussions: https://discu.eu/q/https://tinyurl.com/prog-calc
Implementing Co, a Small Language With Coroutines #4: Adding Channels
https://abhinavsarkar.net/posts/implementing-co-4/
Discussions: https://discu.eu/q/https://abhinavsarkar.net/posts/implementing-co-4/
Testing control-flow translations in GHC. ~ Norman Ramsey. https://www.tweag.io/blog/2023-06-01-translation-testing/ #Haskell #programming
Dynamic programming in Haskell: lazy immutable arrays. ~ Brent Yorgey. https://byorgey.wordpress.com/2023/06/02/dynamic-programming-in-haskell-lazy-immutable-arrays/ #Haskell #FunctionalProgramming
#Vervis the reference implementation of @forgefed just released a tech preview of their refactored codebase that is based on the Actor Model. A mirror of the codebase can be found on #Codeberg at:
Did you know? impurepics is working on a Video series based on 'Learn #Haskell by building a blog generator'. 8 videos have already been published covering up-to (and including) the I/O chapter!
Here's the playlist on youtube:
https://www.youtube.com/watch?v=ZL0qExCnO8g&list=PLxn_Aq3QlOQcXoHWdzxnnuGlGWNXJg43R&index=2
@GeePawHill I've occasionally done test-first demos for first year students. I introduce it as the ultimate way to 'cheat' on homework assignments. But those demos ignore IO etc, so yes. (#haskell is an example what one gets of putting all the danger away in boxes. I had to take #miranda, a precursor to Haskell as first programming language in uni. Just to give those of us used to state and IO a whack on the side of the head :-) ).
vanilla-fp - the no-framework framework for building component-based purely-functional UIs
https://github.com/abuseofnotation/vanilla-fp
Discussions: https://discu.eu/q/https://github.com/abuseofnotation/vanilla-fp
Learning #Haskell is like a rite of passage. Everybody should do it irrespective of what they actually use
Cue quarterly #Haskell community meltdown
To be fair, I think Haskell will continue to fill the niche it filled ~10 years ago, around the time it started to get mainstream hype. Small teams of skilled devs delivering robust products that would normally require much larger teams to maintain will continue to prevail. Purely functional lazy programming was never bound for world domination in an economy which is antagnostic to curiosity, creativity and truths.
On the other hand, I have the feeling that we're going to see more and more Haskellers-turned-Rustaceans come to realize that #Rust does little to alleviate the primary barrier to Haskell's wider success -- fast and predictable turnaround time for projects developing cutting-edge technologies -- and will wind up going the same route as some major Haskell projects such as #Unison and #Idris have in recent years, which is to try #Chez Scheme, only to discover that it allows them to release blazing fast functional programs on a generic foundation where major breaking changes are practically non-existent, providing incredible flexibility while significantly reducing dependencies by dint of the ad-hoc tooling that falls out of the bottom of #scheme. Not to mention the joys that come from near-instant startup times, some of the fastest compile time you've ever encountered, fully-customizable interactive development and a surgical #debugger that rivals Haskell in scheer fun. Yesterdays naysayers will become tomorrow's enthusiastic bootstrappers. Or a at least a boy can dream.
That said, in all seriousness I don't think Scheme will ever reach the heights of Haskell's moderate commercial success. But I do think that projects built on Scheme, like Unison, will get a leg up and eventually surpass it, and interest in #lisp will only grow.
I've been playing around with implementing a #haskell wrapper to #opencascade with a view to using it to do programmable CAD.
It's early days so far (the code has no structure, and I'm leaking memory all over the shop), but I've been able to implement the bottle example from the library tutorials.
One piece of advice I offer to younger software engineers (which means pretty much all software engineers, TBH) is to learn #Haskell, even if you never write a line of production code in it. It will help you look at and attack problems in new ways.
Does anyone have a favourite intro to FFI in #haskell? I've read the stuff on wiki.haskell.org, and the docs for the FFI language extension, but I think I'd benefit from something a bit more opinionated? Maybe a tutorial, ideally using Stack?
Also does the warning about using capi over ccall still agree with received wisdom?
Learning a #programming language that challenges your notion of what programming is might be one of the most rewarding things once it "clicks" and you start seeing the bigger picture. Whether that's #Clojure, #Rust, #Haskell, #Datalog or whatnot — doesn't really matter. They're *systematic*, and when you see the system, that's empowering.
「 As the name suggests, with purely functional programming, the developer can write only pure functions, which, by definition, cannot have side effects. With this one restriction, you increase stability, open the door to compiler optimizations, and end up with code that’s far easier to reason about 」
— IEEE Spectrum
#FunctionalProgramming #FP #PL #Haskell
https://spectrum.ieee.org/functional-programming
The Hackett Programming Language
by Alexis King
“Hackett is a statically typed, pure, lazy, functional programming language in the Racket language ecosystem. Despite significant differences from #lang racket, Hackett shares its S-expression syntax and powerful, hygienic macro system. Unlike Typed Racket, Hackett is not gradually typed—it is designed with typed programs in mind, and it does not have any dynamically-typed counterpart.” - https://lexi-lambda.github.io/hackett/
#haskell #lisp
#introduction time!
Hey everyone!
I am Lira (she/her), a #programmer from #Belgium.
Professionally I use #cSharp and in my free time I use #Haskell and do #nesDev. I also like to dabble with #math.
My favourite animal is the #redPanda!
TFW you are looking for a technique for testing in #Haskell and you bump into a blog that talks about pairing with a former colleague of yours (@testobsessed).
What was the technique? How to run HUnit tests each in their own temporary directory with suitable cleanup. This was standard practice in Go (e.g. https://onsi.github.io/ginkgo/#managing-external-resources-in-parallel-suites-files), but perhaps less so in Haskell.
Here's the blog: https://rickardlindberg.me/writing/reflections-on-programming/2012-02-25-setup-and-teardown-in-hunit/
Hi, just moved to this instance so is time for a new #introduction!
I love open source and also do (retro) gamedev (ZX Spectrum, Amstrad CPC, MSX and Commodore 64; sometimes PC), and other types of "dev" in #Scala, #Python, #C, #Z80, and #Haskell.
My games are always free to download and play, go and check:
(some of the retro ones have physical edition too)
Moved from mastodon.sdf.org.
Big news! LambdaConf returns Sept 16-19th and is better than ever! 🔥
https://www.eventbrite.com/e/lambda-conf-colorado-usa-in-person-only-tickets-540887036687
Discussions: https://discu.eu/q/https://www.eventbrite.com/e/lambda-conf-colorado-usa-in-person-only-tickets-540887036687
Mostly adequate guide to FP (in JavaScript)
https://mostly-adequate.gitbook.io/mostly-adequate-guide/
Discussions: https://discu.eu/q/https://mostly-adequate.gitbook.io/mostly-adequate-guide/
I translated, from #Mercury to #Haskell, the #ContinuedFractions #RosettaCode draft task:
Continued fraction/Arithmetic/G(matrix ng, continued fraction n1, continued fraction n2) - Rosetta Code https://rosettacode.org/wiki/Continued_fraction/Arithmetic/G(matrix_ng,_continued_fraction_n1,_continued_fraction_n2)#Haskell
I have decided there isn’t a single thing I like about Haskell syntax. I do not care how one writes a thing, I hate it. There is no reason whatsoever for Haskell not to have had a more ML-like syntax. None whatsoever, except to encourage breakage.
_> wait waht
[Tue Jan 14 14:32:25 2014] <tac> applicative functors. In Haskell, their definition is kind of a cluster fuck. (The laws seem totally random and arbitrary)
[Tue Jan 14 14:32:51 2014] <tac> But if you have univalence, you can use a more symmetric-looking definition.
[Tue Jan 14 14:34:08 2014] <sclv_> if you look at their laws from the standpoint of monoidal functors they make perfect sense
[Tue Jan 14 14:34:13 2014] <sclv_> and correspond precisely, even
[Tue Jan 14 14:34:24 2014] <tac> right
[Tue Jan 14 14:34:55 2014] <sclv_> the weird thing is that they are presented as _closed_ functors rather than monoidal functors. but those two things mutually imply one another in this setting.
[Tue Jan 14 14:35:22 2014] <sclv_> and in fact you can also look at the laws for closed functors and get a more obvious correspondence to the applicative laws
[Tue Jan 14 14:35:23 2014] <tac> oh? What's a closed functor?
[Tue Jan 14 14:35:26 2014] <tac> I haven't heard that term.
[Tue Jan 14 14:36:08 2014] <sclv_> just like a monoidal functor is a functor between monoidal cats that respects the monoidal op
[Tue Jan 14 14:36:29 2014] <sclv_> a closed functor is a functor between closed cats that respects the internal hom
[Tue Jan 14 14:37:48 2014] <sclv_> if any two cats are closed monoidal, a monoidal functor gives a closed functor and vice versa
It's hot take but also a compelling pitch
It helps if
#haskell folks get interested in #categorytheory
IMG is my way of trying to get better at the theory , what's yours?
https://web.mit.edu/~jgross/Public/tmp/freenode:%23%23hott
So one way to define #continuousintegration is to write recursive function that defines its inputs in terms of the outputs, which the function gives using initial inputs and so on.
So domain corresponds to rand and vice versa and this describes continuity of the function?
Can we define the continuity in #math like this
Why types should I use if i write it in #haskell
Aha others are thinking about it too
Albeit, i don't think I can treat arrows like applicatives in my approach
Quote
fetching gives you a source promise and you want an image promise
writing pipelines using arrow notation is difficult because we have to program in a point-free style (without variables).
ci- is cool
https://codeberg.org/Codeberg-CI/request-access
https://roscidus.com/blog/blog/2019/11/14/cicd-pipelines/
via @talex5
"Parse, don't validate" is one of those phrases and articles that has stuck with me as I've learned to think more and more in and through types. It's demonstrated with #Haskell but applies equally to langs like #OCaml or #Rust.
https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
The #Haskell cabal team is proud to announce the release of cabal 3.10.1.0. You can download it today from ghcup (https://haskell.org/ghcup).
Major highlights include XDG support & the `haddock-project` command!
Read the full announcement on the Haskell Discourse: https://discourse.haskell.org/t/just-released-cabal-3-10-1-0/5978
time for an #introduction
I'm Tuula Aurora, a transwoman living in Finland and trying to figure out the world.
I tend to switch from hobby to hobby when it strikes my fancy. Currently I'm #reading quite a bit and trying to learn more about #sewing.
I used to paint miniatures, mainly 15mm ancients. I like coding and switch from language to language (#python, #hy, #haskell) are the most recent ones. Sometimes I try to wrap my head around #coq, but that's proven quite a challenge so far.
I also like #drawing and doodle silly things on the margins now and then.
I toot in finnish and english, feel free to toot me on either language.
Also, tell me about your cool project. I love hearing what people are creating.
The lazy list implementation for #ATS was only as much more difficult than #Haskell as one would expect in going from almost any other programming language to ATS:
When I first wrote the #Mercury version, I accidentally made it eager rather than lazy. That’s a serious risk for the programmer, a flaw in Mercury’s "lazy" module. But ATS’s demanding type system makes that kind of mistake unlikely.
ChatGPT como profesor de programación con Haskell. https://www.glc.us.es/~jalonso/vestigium/ #ChatGPT #Haskell