brokenix

julesh, 10 days ago to random

Someone should write "mathematics for the working category theorist", to teach a bit of algebraic topology to those of us who started out in functional programming

brokenix, 13 days ago to haskell

quoting @prophet
mli files are mostly used to constrain the visibility of definitions whereas hs-boot files are about allowing mutual recursion between modules (which OCaml doesn't support, even with mli files!)
But the mechanism by which they achieve their goals is nearly identical even though the perception of it is so vastly different.

I guess the conclusion to draw from this is that both sides are wrong: IMO, mli files are not nearly as good as OCamlers think they are, but hs-boot files aren't as ugly as Haskellers think either.
-- prettySrcLoc and prettyCallStack are defined here to avoid hs-boot
-- files. See Note [Definition of CallStack]

Backpack's design is primarily driven by compatibility considerations (“how do we build upon GHC's existing foundation?”), rather than elegance. In particular, Backpack doesn't eliminate those ugly .hs-boot files, it just automates and hides their generation and processing.

For all their faults, Standard ML and OCaml have pretty good support for modular programming. And, as the Modular Type Classes paper you linked shows, type classes can be built elegantly on top of a good modular foundation.
#ocaml #haskell
https://cohost.org/prophet/post/3251638-it-s-really-interest
https://haskell.fi.muni.cz/doc/base/src/GHC-Exception.html
https://twitter.com/lexi_lambda/status/1172629363730333697
https://news.ycombinator.com/item?id=11371130

brokenix, 15 days ago to random

Endlessh is an #SSH tarpit that very slowly sends an endless, random SSH banner. It keeps SSH clients locked up for hours or even days at a time. The purpose is to put your real SSH server on another port and then let the script kiddies get stuck in this tarpit instead of bothering a real server.
https://github.com/skeeto/endlessh

brokenix, 17 days ago to random

> you mostly model data with sum types, which in my mind are the best way to model data

True its quite strict in Haskell though
https://blog.darklang.com/leaving-ocaml/

brokenix, 17 days ago to random

Reason Town: Elm to #OCaml, Technical Debt, and Escape Hatches with Paul Biggar
Speaking of which , now that @codyroux has related diagonalisation to p = np ( which either idk or I don't recall reading ), I got to follow up the whole series
Episode webpage: https://podcasters.spotify.com/pod/show/reason-town/episodes/Elm-to-OCaml--Technical-Debt--and-Escape-Hatches-with-Paul-Biggar-e52keq

Media file: https://anchor.fm/s/79070e8/podcast/play/4329370/https%3A%2F%2Fd3ctxlq1ktw2nl.cloudfront.net%2Fstaging%2F2019-7-23%2F21544635-44100-2-c1b9431e68ec7.mp3

kornel, 26 days ago to random

I've set up git commit signing with SSH. It was relatively easy, and did not need any GPG cruft.

https://calebhearth.com/sign-git-with-ssh

brokenix, 26 days ago to haskell

pseq combinator is used for sequencing; informally, it eval-
uates its first argument to weak-head normal form, and then eval-
uates its second argument, returning the value of its second argu-
ment. Consider this definition of parMap:
parMap f [] = []
parMap f (x:xs) = y ‘par‘ (ys ‘pseq‘ y:ys)
where y = f x
ys = parMap f xs
The intention here is to spark the evaluation of f x, and then
evaluate parMap f xs, before returning the new list y:ys. The
programmer is hoping to express an ordering of the evaluation: first
spark y, then evaluate ys.
The obvious question is this: why not use #Haskell’s built-in seq
operator instead of pseq? The only guarantee made by seq is that
it is strict in both arguments; that is, seq a ⊥ = ⊥ and seq ⊥
a = ⊥. But this semantic property makes no operational guaran-
tee about order of evaluation. An implementation could impose this
operational guarantee on seq, but that turns out to limit the optimi-
sations that can be applied when the programmer only cares about
the semantic behaviour. Instead, we provide both pseq and seq
(with and without an order-of-evaluation guarantee), to allow the
programmer to say what she wants while leaving the compiler with
as much scope for optimisation as possible.
https://simonmar.github.io/bib/papers/multicore-ghc.pdf

hko, 29 days ago to random

Two days ago I switched my OpenPGP card-based #git signing setup away from gpg to an experimental new Rust alternative.

I did not realize how much of a quality of life improvement that would be. Very excited that pin entry popups are (almost entirely) a thing of the past for me, now.

louis, 1 month ago to random

While most programming languages pride themselves in how they limit the programmer, there is one that does quite the opposite. One, that rewards you with every day you spend, every struggle you overcome with a new box of undiscovered tools. And when there are no more, you have all the tools you need to build your own.

You all know which one I'm talking about.

brokenix, 1 month ago to FunctionalProgramming

Implement web servers using lenses #functionalprogramming
dependent types
https://github.com/ska80/idris2-server?tab=readme-ov-file

brokenix, 2 months ago to haskell

fixpoint combinators like Y can't be well-typed in #Haskell. Specifically, something of the form x x requires x to have two conflicting types simultaneously. In dynamic languages, this doesn't matter because you just don't care what the type is, only that you can use the value in some way. But a Haskell compiler does care. However there's no need for such combinators, because Haskell's solution fix f = let x = f x in x is more elegant anyway, and has no typing difficulties (but does require lazy evaluation).
#javascript is perhaps not the best launchpad to haskell , to their credit they make good fp presentations
https://stackoverflow.com/questions/68975627/translating-a-fixed-point-operator-to-haskell-language

brokenix, 2 months ago to random

A good strategy to go from a thesis to a typechecker #typetheory
https://spire-lang.org/blog/2014/01/05/an-unremarkable-type-checker/

brokenix, 2 months ago to random

ZFC includes an infinite axiom schema

louis, 2 months ago to random

Freshen up on your Common Lisp skills with @vindarel 's Udemy course and support his work along the way:

https://www.udemy.com/course/common-lisp-programming/?couponCode=CELEBRATE1001

His course celebrates 1001 learners today and he's probably the most active missionary to bring Common Lisp to newcomers in an accessible way.

#commonlisp

Disclaimer: I do not receive any commissions for this link.

brokenix, 2 months ago to microsoft

Even if you’re one of the “good devs,” and even if Copilot suddenly makes you twice as productive, as #Microsoft (dubiously) claims, your day didn’t just suddenly get half as long. You just suddenly got twice as many responsibilities
https://joshcollinsworth.com/blog/copilot

brokenix, 2 months ago to haskell

when you reverse a list in #haskell

aux_reverse [] out = out aux_reverse (x:xs) out = aux_reverse xs (x:out)<br></br>reverse l = aux_reverse l []<br></br>

does it keep the reference to the original list (using max space) ? ll #ocaml do the same?

brokenix, 2 months ago to haskell

What is beta reduced ( evaluated ) form of

(\1 - > ( x- > 1)) 2

where x is f abstraction and 1, 2 are literals
#haskell

brokenix, 2 months ago to random

This like #eyesight testing for fp

louis, 3 months ago to emacs

TIL Emacs TRAMP will fail to work with an ssh target when you change the prompt of your default remote shell to not end with $.

#emacs #tramp

louis, 3 months ago to random

I recently sent someone a DM on Mastodon, thanking them for some of their artwork, which they provide publicly and for free.

That person than took a screenshot of my DM and posted it publicly. Just because they were happy about it.

Re-posting DMs without consent, or worse screenshots of a DM, even with good intentions, is not OK. Not OK.

brokenix, 3 months ago to guix

the “Nix store” is independent of the “Nix language” (which we’ll define below). In other words, you could replace the front-end Nix programming language with another language (e.g. #Guile scheme, as #Guix does). This is because the Nix derivation format (the .drv files) and the nix-store command-line interface are both agnostic of the Nix expression language.

In isolation, the Nix language is “just” a purely functional programming language with simple language constructs.
Nixpkgs support for overrides is essentially an embedded domain-specific language, meaning that you still express everything in the Nix language (layer 1), but the ways in which you express things is fundamentally different than if you were simply using low-level Nix language features.
OS is based on the NixOS module system, which is yet another embedded domain-specific language. In other words, you configure #NixOS with Nix code, but the idioms of that Nix code depart even more wildly from straightforward “layer 1” Nix code
https://www.haskellforall.com/2022/08/stop-calling-everything-nix.html?m=1

brokenix, 3 months ago to haskell

#haskell lenses are just functional references

brokenix, 3 months ago to NixOS

I haven't caught up on even important changes in #nixos , #initrd has stopped using #dropbear
but why ? Though?
alternative doesn't sound very cool either

image/png