News about the Haskell programming language from 2024-05-30.
In this episode we talk with David Christiansen, he wrote the books Functional Programming in Lean and the Little Typer. He has also worked as the Executive Director of the Haskell Foundation, at Galois and did his PhD developing a bunch of cool stuff for Idris. David is a super upbeat person and I feel that we could spend hundreds of hours talking about Functional Programming Writing and Dependent Types, and we still wouldn’t run out of topics!
News about the Haskell programming language from 2024-05-16.
Wouter and Joachim interview Arseny Seroka, CEO of Serokell. Arseny got into Haskell because of a bet over Pizza, fell for it because it means fewer steps between his soul and his work, and founded Serokell because he could not get a Haskell job. He speaks about the business side of a Haskell company, about the need for more sales and marketing for Haskell itself, and about the Haskell Developer Certification.
News about the Haskell programming language from 2024-05-02.
`ghc-debug` is a debugging tool for performing precise heap analysis of Haskell programs (check out [our previous post introducing it](https://www.well-typed.com/blog/2021/01/fragmentation-deeper-look/)). While working on [Eras Profiling](https://www.well-typed.com/blog/2024/01/ghc-eras-profiling/), we took the opportunity to make some much needed improvements and quality of life fixes to both the `ghc-debug` library and the [https://hackage.haskell.org/package/ghc-debug-brick](https://hackage.haskell.org/package/ghc-debug-brick) terminal user interface. To summarise, * `ghc-debug` now works seamlessly with profiled executables. * The `ghc-debug-brick` UI has been redesigned around a composable, filter based workflow. * Cost centers and other profiling metadata can now be inspected using both the library interface and the TUI. * More analysis modes have been integrated into the terminal interface such as the 2-level profile. This post explores the changes and the new possibilities for inspecting the heap of Haskell processes that they enable. These changes are available by using the `0.6.0.0` version of [https://hackage.haskell.org/package/ghc-debug-stub](https://hackage.haskell.org/package/ghc-debug-stub) and [https://hackage.haskell.org/package/ghc-debug-brick-0.6.0.0](https://hackage.haskell.org/package/ghc-debug-brick-0.6.0.0).
I've mentioned my new effect system, Bluefin, a few times on this forum. It's now ready for me to announce it more formally. Bluefin's API is differs from all prior effect systems in that it implements a "well typed [Handle](https://jaspervdj.be/posts/2018-03-08-handle-pattern.html)/[Services](https://brandonchinn178.github.io/posts/2023/05/03/services-design-pattern) pattern". That is, all effects are accessed through value-level handles, which makes it trivial to mix a wide variety of effects, including: * [Bluefin.EarlyReturn](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin-EarlyReturn.html), for early return * [Bluefin.Exception](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin-Exception.html), for exceptions * [Bluefin.IO](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin-IO.html), for I/O * [Bluefin.State](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin-State.html), for mutable state * [Bluefin.Stream](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin-Stream.html), for streams If you're interested then read the [Introduction to Bluefin](https://hackage.haskell.org/package/bluefin-0.0.4.3/docs/Bluefin.html). I'd love to know what you all think.
News about the Haskell programming language from 2024-04-18.
This is the first of a two-part series of blog posts on GHC specialization, an optimization technique used by GHC to eliminate the performance overhead of ad-hoc polymorphism and enable other powerful optimizations. There will also be a Haskell Unfolder episode about this topic.
jaror Now • 100%
Stream fusion does work:
data Stream a = forall s. Stream !(s -> Step s a) !s
data Step s a = Yield a !s | Skip !s | Done
data Tup a b = Tup !a !b
cartesianProduct :: Stream a -> Stream b -> Stream (a, b)
cartesianProduct (Stream step1 s01) (Stream step2 s02) = Stream step' s' where
s' = Tup s01 s02
step' (Tup s1 s2) =
case step1 s1 of
Yield x s1' ->
case step2 s2 of
Yield y s2' -> Yield (x, y) (Tup s1 s2')
Skip s2' -> Skip (Tup s1 s2')
Done -> Skip (Tup s1' s02)
Skip s1' -> Skip (Tup s1' s2)
Done -> Done
eft :: Int -> Int -> Stream Int
eft x y = Stream step x where
step s
| s > y = Done
| otherwise = Yield s (s + 1)
fooS :: Stream (Int, Int)
fooS = cartesianProduct (eft 0 10) (eft 0 10)
toList :: Stream a -> [a]
toList (Stream step s0) = go s0 where
go !s =
case step s of
Yield x s' -> x : go s'
Skip s' -> go s'
Done -> []
foo :: [(Int,Int)]
foo = toList fooS
This fuses: ``` [(x, y) | x <- [0 .. 10], y <- [0 .. 10]] ``` But this does not: ``` liftA2 (,) [0 .. 10] [0 .. 10] ``` Because the latter inlines to: ``` let xs = [0..10]; ys = [0..10] in xs >>= \x -> ys >>= \y -> (x, y) ``` And GHC is afraid to push the `ys` binding into the `\x -> ...` lambda because that might duplicate the work of evaluating [0..10]. Even though in the end fusing everything would be beneficial. See: [https://gitlab.haskell.org/ghc/ghc/-/issues/24663](https://gitlab.haskell.org/ghc/ghc/-/issues/24663)
jaror Now • 100%
Admittedly it gets more complicated when summing two things at the same time:
let Pair dnormMean dnormNormMean =
fold (Pair <$> dimap (\(Pair _ dnormI) -> dnormI) (/ fromIntegral cc) sum
<*> dimap (\(Pair normBti dnormI) -> normBti * dnormI) (/ fromIntegral cc) sum)
$ map (\i -> Pair (((inp ! (off + i)) - meanBt) * rstdBt)
((weight ! i) * (dout ! (off + i))))
[0 .. cc - 1]
float dnorm_mean = 0.0f;
float dnorm_norm_mean = 0.0f;
for (int i = 0; i < C; i++) {
float norm_bti = (inp_bt[i] - mean_bt) * rstd_bt;
float dnorm_i = weight[i] * dout_bt[i];
dnorm_mean += dnorm_i;
dnorm_norm_mean += dnorm_i * norm_bti;
}
dnorm_mean = dnorm_mean / C;
dnorm_norm_mean = dnorm_norm_mean / C;
Declarative vs imperative: ``` let v = sum [ ((x ! i) - m) ^ 2 | i <- [0 .. cc - 1] ] / fromIntegral cc ``` ``` float v = 0.0f; for (int i = 0; i < C; i++) { float xshift = x[i] - m; v += xshift * xshift; } v = v/C; ``` [\#haskell](https://kbin.social/tag/haskell)
News about the Haskell programming language from 2024-04-11.
News about the Haskell programming language from 2024-04-04.
Roman, known better online as effectfully, is interviewed by Wouter and Joachim. On his path to becoming a Plutus language developer at IOG, he learned English to read Software Foundations, has encountered many spaceleaks, and used Haskell to prevent robots from killing people.
News about the Haskell programming language from 2024-03-28.
jaror Now • 100%
The machine itself can generally only do very simple things
I disagree. Assembly languages for modern architectures are a complexity hell. You need books with thousands of pages to explain how they work. In comparison the lambda calculus is much simpler.
News about the Haskell programming language from 2024-03-21.
When composing several list-processing functions, GHC employs an optimisation called foldr-build fusion. Fusion combines functions in such a way that any intermediate lists can often be eliminated completely. In this episode, we will look at how this optimisation works, and at how it is implemented in GHC: not as built-in compiler magic, but rather via user-definable rewrite rules.
In this episode, András Kovács is being interviewed by Andres Löh and Matthias Pall Gissurarson. We learn how to go from economics to functional programming, how GHC's runtime system is superior to Rust's, the importance of looking at GHC's Core for spotting stray closures, and why staging might be the answer to all your optimisation problems.
jaror Now • 100%
Apparently there was still some manual action required: https://discourse.haskell.org/t/haskell-interlude-44-jose-manuel-calderon-trilla/8935/3?u=jaror
jaror Now • 100%
That's odd. This latest episode is indeed not mentioned on there: https://feeds.buzzsprout.com/1817535.rss. I'd guess it is something on buzzsprout's side.
jaror Now • 100%
The symbolic rewriting is interesting.
I do wonder what "modern-style" functional programming means.
Also their FAQ says:
But considering other FPLs like Haskell and ML, Pure's library support isn't bad
Clicking that link reveals a list of about 34 libraries. In comparison, Haskell's current curated Stackage snapshot has 3340 packages in it (the total number of packages is probably more than 10x that). So, I think it is odd to claim its ecosystem is anywhere near Haskell's.
jaror Now • 100%
We can make it a lot more performant, shorter, and also safer by using lazy byte strings:
{- cabal:
build-depends: base, network, network-run, bytestring
-}
{-# LANGUAGE OverloadedStrings #-}
import Network.Run.TCP (runTCPServer)
import qualified Network.Socket.ByteString.Lazy as Net
import qualified Data.ByteString.Lazy.Char8 as Str
main = runTCPServer (Just "127.0.0.1") "9999" $ \s -> do
request <- Net.getContents s
case Str.words (Str.takeWhile (/= '\r') request) of
["GET", resource, "HTTP/1.1"] -> do
let path = Str.concat
[ "htdocs/"
, Str.dropWhile (== '/') resource
, if Str.last resource == '/' then "index.html" else ""
]
page <- Str.readFile (Str.unpack path)
Net.sendAll s ("HTTP/1.1 200 OK\r\n\r\n" <> page)
_ -> error "todo"
jaror Now • 100%
Actually, if you combine network
with network-run
then it is the right level of abstraction:
{- cabal:
build-depends: base, network, network-run, monad-loops
-}
import Network.Run.TCP
import Network.Socket
import System.IO
import Control.Monad.Loops
main = runTCPServer (Just "127.0.0.1") "9999" talk where
talk s = do
h <- socketToHandle s ReadWriteMode
l <- hGetLine h
case words l of
["GET", resource, "HTTP/1.1"] -> do
whileM_ (("\r" /=) <$> hGetLine h) (pure ())
let path = concat
[ "htdocs/"
, dropWhile (== '/') resource
, if last resource == '/' then "index.html" else ""
]
hPutStr h "HTTP/1.1 200 OK\r\n\r\n"
hPutStr h =<< readFile path
hClose h
_ -> error "todo"
jaror Now • 100%
And for more GHCi performance options see: https://stackoverflow.com/a/77895561/15207568
jaror Now • 100%
Another way to put it is that HasCallStack isn't optimized away by tail call optimization. And Haskell without tail call optimization will have huge stacks.
jaror Now • 100%
The discussion about incentives for stability was interesting. It reminded me of the maintainership standards proposal. I think it would be very useful to have Hackage show information like how quickly a package fixes version bounds when new versions of their dependencies are released.
jaror Now • 100%
@kosmikus @mangoiv I'm not really the right person to ask, having spent exactly zero time in industry. But I can imagine most industrial users have little interest in the main ICFP program and the other co-hosted workshops. So hosting the event separately at a smaller venue for just two days could make it possible to substantially lower the fees (and individual accommodation costs) which naturally makes the event more accessible. And I expect that the fees are generally a bigger problem outside of academia, so it cater more to industrial users and hobbyists.
jaror Now • 100%
This was a fun episode. I was introduced to breadth first labeling and attribute grammars by Doaitse Swierstra at the Applied Functional Programming summer school in Utrecht. He was an inspiring figure.
The biggest disadvantage of circular programs is that it is very easy to get into infinite loops when you make mistakes. I wish there was an easy way to guarantee statically that circular programs are terminating (perhaps using types).
There is also a recent paper about implementing breadth-first traversals without relying on laziness: https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/traversals.pdf. Unfortunately, that does not contain any benchmarks.
jaror Now • 100%
Maybe the symposium should start catering more to industrial users, now that Haskell itself also seems to be moving more in that direction (e.g. more backwards compatibility). The symposium already allows experience reports and demos.
jaror Now • 100%
Sadly, it seems things are not going so well for the Symposium: https://discourse.haskell.org/t/rfc-changes-to-the-haskell-symposium/8359?u=jaror
jaror Now • 100%
What's up?
jaror Now • 100%
For more details on DerivingVia
, check out the paper:
https://ryanglscott.github.io/papers/deriving-via.pdf
Especially Section 4 which lists many use cases including the superclasses demonstrated in the video.
jaror Now • 100%
I think Idris' bang notation for performing effects in a do-block is pretty, it could look like this:
main = do putStrLn ("You said: " ++ !getLine)
Today, you'd have to come up with a new variable name or figure out the right combinator names:
main = do line <- getLine; putStrLn ("You said: " ++ line)
main = putStrLn . ("You said: " ++) =<< getLine
But unfortunately there are more complicated cases:
main = do print (True || !getLine == "foo")
In a strict language with built-in short-circuiting logical operations the getLine
would never be performed, but in Haskell ||
is just a normal function that happens to be lazy in its second argument. The only reasonable way to implement it seems to be to treat every function as if it was strict and always perform the getLine
:
main = do line <- getLine; print (True || line == "foo")
Do you think this is confusing? Or is the bang notation useful enough that you can live with these odd cases? I'm not very happy with this naive desugaring.
jaror Now • 100%
My to-watch list:
- Modular Models of Monoids with Operations
- HasChor: Functional Choreographic Programming for All (Functional Pearl)
- More Fixpoints! (Functional Pearl)
- Timely Computation
- Embedding by Unembedding
- A well-known representation of monoids and its application to the function ‘vect...
- Modal FRP for all: Functional reactive programming without space leaks in Haskel...
- Explicit Refinement Types
- FP²: Fully in-Place Functional Programming
- Calculating Compilers for Concurrency
- Bit-Stealing Made Legal: Compilation for Custom Memory Representations of Algebr...
jaror
jaror@ kbin.socialAll the side effects were never mentioned to me
I am innocent of uncontrolled abuse