solomonb

I'm very sympathetic to this view, and it would be a nice counter to claims of AI creativity, but I'm not convinced this is the only way creativity can express itself. There are examples of strokes of genius, hence the term.

I suppose you could say such strokes of genius are the outcomes of a lifetime of creative work but that seems different from your example of editing a poem.

what does any of that have to do with my comment?

There are a bunch of these scifi world building short video channels now. IMO they all seem really creative initially but rapidly lose their luster and become repetitive.

Sora makes the hard parts easy and the easy parts hard. I don't think any of these content producers will be remembered in the future. :/

Hopefully! Supposedly it is pretty locked down but I'm hopeful there is a way to get other apps onto it.

Why are you trying to make fun of me?

I pay for parking with quarters or a credit card.

If necessary I use a piece of paper for maps.

For music I have an ipod.

Wow I wish they had announced this sooner. I just ordered a keyphone but this looks way more suited to my use case. I just want a basic feature phone + qwerty keyboard + signal + whats app.

I've been using a lightphone for 3 years but i can't stand the touch screen and only having SMS is annoying.

Psychiatric disorders are leaky abstractions.

And ADHD meds seem like they would be helpful for studying.. How and where do we draw the line who gets and needs additional support?

> Quite the opposite actually. certain live coding languages give you the tools to create extremely complex patterns

I think I must not be expressing myself well. These tools seem to be optimized for parametric pattern manipulation. You essentially declare patterns, apply transformations to them, and then play them back in loops. The whole paradigm is going to encourage a very specific style of composition where repeating structures and their variations are the primary organizational principle.

Again, I'm not trying to critique the styles of music that lend themselves well to these tools.

> And yet it also constrains and prevents the construction of bad programs in a very strict manner via its type system and compiler.

Looking at the examples in their documentation, all I see are examples like:

    d1 $ sound "[[bd [bd bd bd bd]] bd sn:5] [bd sn:3]"

So it definitely isn't leveraging GHC's typechecker for your compositions. Is the TidalCycles runtime doing some kind of runtime typechecking on whatever it parses from these strings?

> It's also notable for being probably the only Haskell library used almost exclusively by people with no prior knowledge of Haskell, which is an insane feat in itself.

I think Pandoc or Shellcheck would win on this metric.

I'm not saying anything negative about repetitive music. I'm saying that tools like live coding are going to constrain the kind of music you can produce reasonably.

No one in this thread is saying quantization is never appropriate.

yes exactly, and when I say "quantization of every dimension of composition" I mean an application of quantization to every aspect of composition not just pitch and rhythm.

100% agree.

I think this format of composition is going to encourage a highly repetitive structure to your music. Good programming languages constrain and prevent the construction of bad programs. Applying that to music is effectively going to give you quantization of every dimension of composition.

I'm sure its possible to break out of that but you are fighting an uphill battle.

> more or less does that exact exercise for you at a press of a button.

Well it would give you a similar final artifact but it wouldn't be doing the exercise at all.

In college I had a professor assign us to write a 100% plagiarized paper. You had to highlight every word in a color associated with the source. You couldn't plagiarize more then one sequential sentence from a single source.

It ended up being harder then writing an ordinary paper but taught us all a ton about citation and originality. It was a really cool exercise.

I imagine something similar could be done to teach students to use AI as a research tool rather then as a plagiarization machine.

> No, no loss of safety. Was there something in particular you were thinking of?

This is second hand information and may apply more so to effectful then bluefin. I have just done some pretty minimal test projects with bluefin and effectful but I was told:

""" It's not too hard to make segfault if you organize your higher order effects just right.

It's been a while but i think you just return a continuation with the effect you just handled, and then all of a sudden it's not in scope and yet you need to still handle it.

And the tricks they use to make things go fast don't work in this case and things go boom """

Yes but from what I understand at a loss of safety. You can decide if that is worth it but you aren't getting a free lunch.

that said, your library is really cool. : )

`eff` is a research project that is no longer in active development and never made it to production in any sense. It would be AMAZING if `eff` were completed but I dont think that will happen at this point.

`eff` is based on delimited continuations (which Alexis had to build into GHC), it is not using `Freer`. If you want to look at an effect system in Haskell that actually has been used in production AND is based on this paper then look at `freer-simple`: https://hackage.haskell.org/package/freer-simple

No it is not high performance, but neither are any other Haskell effect systems and performance is relative to your problem domain. It also has the benefit of being implemented very similarly to Oleg's paper making it a lot easier to learn from then most other options.

I would like to expand and add a little nuance to my statement as apparently it was controversial.

From wikipedia:

> Business is the practice of making one's living or making money by producing or buying and selling products (such as goods and services). It is also "any activity or enterprise entered into for profit."

So a business is an activity or enterprise engaged in by people for profit.

If a business exists to generate profit for its participants, it should maximize profit distribution to everyone involved in that business. This implies salary limits that maintain business sustainability. Otherwise, excessive compensation would eliminate profit for all participants.

My point wasn't about how to balance salaries between different employees. I'm arguing that companies should maximize compensation for all employees (at every level) to the extent that doing so doesn't threaten the business's viability. Without this, you get companies hoarding excessive capital reserves that sit idle rather than circulating through the economy.

The intuitionistic negation example is so mind blowing. I can only wrap my head around it when I think about it in terms of functions and types:

    not : Type -> Type
    not P = P -> ⊥
    
    modus-ponens : P -> ((f : P -> Q) -> Q)
    modus-ponens p = λf. f p
    
    -- p implies not-not-p
    not-not : P -> ((f : P -> ⊥) -> ⊥)
    not-not p = λf. f p
    
    -- not-p implies not-not-not-p
    not-not-not : (P -> ⊥) -> (((P -> ⊥) -> ⊥) -> ⊥)
    not-not-not np = λf. f np

    -- not-not-not-p implies not-p
    not-p : (((P -> ⊥) -> ⊥) -> ⊥) -> (P -> ⊥)
    not-p nnnp = λp. nnnp (not-not p)

Now it all just turns into function application :)

They (and everyone else) should be paid the maximum amount the company can afford to pay while still being sustainable.

This work predates agents as we know them now and was intended for building chat bots (as in irc chat bots) but when auto-gpt I realized I could formalize it super nicely with this library:

https://blog.cofree.coffee/2025-03-05-chat-bots-revisited/

I did some light integration experiments with the OpenAI API but I never got around to building a full agent. Alas..

You didn't explicitly call your examples major milestones of human progress but you did use rather trite examples of consumer capitalism as a counter example to my disappointment at the lackluster end game of 20th century techno-futurism.

As other commenters have stated the techno-futurist vision that comes out of the Whole Earth Catalog was radically utopian and far grander then "I get to watch low value consumer media whenever I want."

I love the Whole Earth Catalog. That era of techno-utopian optimism is so exciting. I'm too young to have experienced more then the tail end of it in the 90s going to computer camp as a kid, but it felt like anything was possible and everything was connected.

It is a bit sad to see where we have landed after all that.

Before I got my first full time software engineering gig (I had worked part time briefly years prior) I was working full time as a carpenter. We were paying for an expensive online work order system. Having some previous experience writing software for music in college and a couple /brief/ LAMP stack freelance jobs after college I decided to try to write my own work order system. It took me like a month and it would never have never scaled, was really ugly, and had the absolute minimum number of features. I could never had accepted money from someone to use it but it did what we needed and we ran with it for several years after that.

I was only able to do this because I had some prior programming experience but I would imagine that if AI coding tools get a bit better they would enable a larger cohort of people to build a personal tool like I did.

What language do you use which does not have exceptions?

since were just making up functions..

    myCoolSubroutine = do
      now <- getCurrentTime
      users <- getUsers
      forM users (sendEmail now)

    sendEmail now user =
      if user.expiry <= now
        then sendExpiryEmail user
        else sendNonExpiryEmail user

The whole pipeline thing is a red herring IMO.

Just postulate function extensionality and move on with life. :D

Given an algebraic data type such as:

    data List a = Nil | Cons a (List a)

You can define its recursion principle by building a higher-order function that receives an element of your type and, for each constructor, receives a function that takes all the parameters of that constructor (with any recursive parameters replaced by `r`) and returns `r`.

For `List` this becomes:

   foldr :: (() -> r) -> (a -> r -> r) -> List a -> r

The eliminator for `Nil` can be simplified to `r` as `() -> r` is isomorphic to `r`:

   foldr :: r -> (a -> r -> r) -> List a -> r
   foldr z f Nil = z
   foldr z f (List a xs) = f a (foldr f z xs)

For `Bool`:

    data Bool = True | False

We get:

    bool :: a -> a -> Bool -> a
    bool p q True = q
    bool p q False = p

Which is precisely an If statement as a function!

:D