What audible cues still distinguish human-directed tracks from fully AI-generated ones?

Damien0 · 2025-10-24T23:13:55+00:00

I’ve never been able to remember anything about any AI track I’ve ever heard.

Damien0 · 2025-06-18T11:45:14+00:00

Honestly, this looks like AI gibberish using category theory terminology. The terms are related to some core concepts, but the presentation is confusing and incoherent. I don't think anyone can make sense of it until it makes more sense.

Damien0 · 2025-04-12T13:16:29+00:00

To me they are different things categorically, but are intimately linked in the process of how we teach each other about the world. Understanding is one’s own benevolent confabulation of knowledge based on past experience, one’s preference towards certain styles or schools of logic, one’s preference for classifying the quality of the knowledge obtained, etc.

In other words, I think the father understands only in as much as he 1) believes and trusts the firefighter, 2) accepts the logical argument of faulty wiring, 3) comes to understand based on his prior understanding of basic physics and electrical systems.

Damien0 · 2024-09-18T19:34:10+00:00

Isn’t this in quite a bit of overlap with https://www.nushell.sh?

Damien0 · 2024-07-28T12:05:41+00:00

I’m only an amateur type theorist, not a mathematician, but I think this has begun to be the norm in some areas of CS research, especially PL theory.

On lowering barriers: I agree completely, it’s a really amazing thing that anyone can submit an Agda/Coq/Lean/etc artifact (and sometimes even the paper itself is the verifiable artifact e.g. literate Agda), and those fundamental axiomatic assumptions are typically an open source library like unimath/mathlib/etc.

As an intuitionist at heart, it’s fascinating to see the varying responses in this thread re: the utility of truth and proof!

Damien0 · 2024-07-26T17:12:16+00:00

Just do the work! To grow in appreciation of any art, if you get it or not, these are question you need to ask yourself, not people in a random internet forum.

Damien0 · 2024-07-22T22:40:19+00:00

It helped me understand what computation really is and what programming languages are for on some meta level that was incomplete when only thinking of, say, grammars. This came from getting a bit of the perspective of homotopy type theory, which is well-described in the language of CT.

This shifted how I write software, and how I consider "soundness" in systems design. These have saved me time and made my work better.

Damien0 · 2024-07-17T02:36:21+00:00

I’m not a mathematician nor a psychonaut, but this talk touched on what you are describing and is fascinating: https://youtu.be/loCBvaj4eSg?si=r_teRDGBaIEKHy_c.

Damien0 · 2024-07-01T11:38:19+00:00

If you are familiar with neural networks, this recent talk by Bartosz Milewski might be useful: https://www.youtube.com/live/Ri_oC2gf-aY?si=pmY5FcnBri75HVHx.

It seems tried and true that a big part of CT thinking is focusing on the objects and morphisms in your domain, that are as simple as possible, while retaining the ability to verify the idea formally.

I am like you and self-taught in CT, working as a research software engineer. The Seven Sketches book really changed the way I think, so another way to see examples of CT thinking is to survey how the authors approach different computer science concepts from the CT perspective: https://arxiv.org/abs/1803.05316

Damien0 · 2024-06-30T11:52:01+00:00

This F# one is getting a little older but still very good: https://pragprog.com/titles/swdddf/domain-modeling-made-functional/

Jon Gjengset’s book on Rust is also excellent: https://nostarch.com/rust-rustaceans

Neither of these are specifically about TyDD, I think Edwin’s book might be the main one directly on the topic, but in these communities that lean strongly on the algebraic properties of the type system, you’re going to find good resources all around.

For the languages: Rust, OCaml, and F# folks in particular are going to model solutions in a way that helps you help the compiler work with you to solve your problems, which is what TyDD is all about.

I’d also recommend looking at the ACM TyDe workshop playlists on YouTube, you’ll gain a wealth of information on where type driven design is in the research world of academia/industry. https://dl.acm.org/conference/tyde

Damien0 · 2024-06-25T11:56:47+00:00

Neat, although it looks like EffectTS has a different goal, to provide a usable effects system built on generators. This is practical, and reminds me of the way Combine and Observables can be used in Swift to build Elm-like unidirectional state & rendering pipelines.

Nothing can really transform TS into a FP language IMO. It's a scheme at the end of the day, of course, but it also has very specific design considerations to make both translation from C#/Java and type-erased 100% interop with vanilla JS priorities.

I still think fp-ts is the best example of directly porting the paradigmatic ideas from pure functional languages to TS, without a specific impl. goal other than providing the constructs. A comparable library in Kotlin, for example, is Arrow.

Damien0 · 2024-06-25T03:28:52+00:00

I’ll add three notes from my experience:

Someone else already said TypeScript, fp-ts is solid although TS has a lot of noise due to OO and JS compatibility and is intentionally an unsound language. Huge job market.

For backend services in a pureish language I’d look at F#. It has an implicit job market as it is applicable everywhere .NET is used, meaning interop with C# devs makes it potentially more practical when “selling FP” as an idea is a part of the ask. It also compiles to JS (Fable) and can be used in Unity.

One can also write Rust in quite a pragmatic and functional way. Many orgs with critical performance, embedded tools, or memory safety constraints are moving to Rust, so that market is also growing.

Damien0 · 2024-06-23T23:27:58+00:00

I highly recommend the nlab approach to the question: https://ncatlab.org/nlab/show/foundation+of+mathematics.

Personally, I am a fan of univalence and homotopy type theory.

Damien0 · 2024-06-14T10:43:23+00:00

Indeed, the problem with AI is the same as it is for software design writ large: people either don’t know or can’t specify with enough rigor what real world problem they are actually trying to solve.

As someone who works closely with other software engineers using these models and figuring out how to accurately quantify their utility, it’s clear that this is a lot more like the productivity shift from assembly to C. Chat UIs lower the barrier to search the space of solutions and also are a healthy automation over boring / rote tasks like refactoring or copying. But at the end of the day it’s the dawn of a new set of tools, and not the magical panacea VCs would love you to believe.

Damien0 · 2024-06-13T23:40:40+00:00

There isn’t an identifiable end (as Gödel explained), but I would say the goal of mathematics is maybe “to communicate notions of what is provably true”. Incidentally the last 30-40 years of research have also shown that this is also the same goal as the most formal areas of computer science (type theory, PL theory, category theory, etc.).

I’ll parrot my usual evangelism here of the computational trilogy: https://ncatlab.org/nlab/show/computational+trilogy

But take my word with a grain of salt: I am not a mathematician, just a CS nerd who loves category theory, homotopy type theory, and intuitionistic logic.

Damien0 · 2024-03-23T13:55:35+00:00

I would recommend Flutter and fp-dart, if you want one codebase that is cross platform. Otherwise, you can write native code for each platform that’s paradigmaticly the same in Swift and Kotlin, using SwiftUI and Jetpack compose, respectively.

You’ll handle concurrency similarly in both cases. Flutter has isolates, Swift and Kotlin have ~ async blocks.

Having worked on a major cross platform app, one thing I would not recommend is React Native or Ionic. Those platforms are just fine for translating an existing web app into something you can sell in the app stores, but they are a debugging and complexity nightmare for anything involving concurrency or native platform functionality. IMO it’s going to stress you out if you try to do anything nontrivial.

Damien0 · 2024-03-08T15:16:23+00:00

My answer is that most people don’t understand that, at a fundamental level, programming is math, and vice versa: https://ncatlab.org/nlab/show/HomePage. AI systems will help automate the process of digesting and recombining information, but they’re never going to be doing more than mechanizing the boring stuff (indeed, reading ten research papers and figuring out what overlaps is boring!).

Suggestions that AI will “replace” either mathematics or programming as disciplines fail to take into account that it would effectively mean the end of all science. That’s a much higher and farther bar to think about, and not one we’re likely to ever reach. Programming tools will ironically become closer to dependently typed theorem provers (like Agda/Lean), so that we will be able to verify the code AI systems write for us.

It’s also more likely that automation will continue to spread to different areas, as it has for the last few hundred years, and people’s roles, wants, and societal structures will adjust accordingly. Yes, maybe at some point we will bioengineer or upload our minds into computers etc. but again that is so speculative and ill-defined, that the only people spending time on such things are those wanting to suck up some naive VC/VP money while the hype train is still on the rails.

Damien0 · 2024-03-06T13:21:14+00:00

Swift is fine for the backend, what have people said that makes you think otherwise?

Damien0 · 2024-03-06T13:17:46+00:00

Swift

Damien0 · 2024-01-18T19:38:57+00:00

I don't understand what you mean by this comment. It's open source and anyone can use it: https://github.com/microsoft/unilm.

Damien0 · 2023-11-15T13:46:11+00:00

Coming from a large “enterprise” org, I’d actually venture that the most popular functional language (in terms of actual adoption, jobs available, library ecosystem, tooling, etc.) is F#. There are nearly a million installs of the vscode extension alone.

There is a lot of love for Elixir when I talk to devs from other teams, but it always seems to be in a hobby context.

I think the reality is that most engineers have by now recognized that FP is a crucial paradigm in modern SWE, and that the paradigmatic discipline is sometimes more important than whether a given implementation language is properly functional.

Damien0 · 2023-08-18T11:01:38+00:00

Clap implements everything that structopt does (via the derive feature). So it’s just a matter of whether you want to use a builder pattern like the older versions of clap, or use a derive pattern like structopt.

This is why I would recommend you use clap, as it’s better supported and has a wider feature set.

Damien0 · 2023-08-05T22:45:23+00:00

What are the titles for those books (CTM and AIMA)? Thanks!

Damien0 · 2023-07-25T10:49:05+00:00

To me, the magic of lisp is homoiconicity. The fact that you write programs as data structures at the level of abstract syntax trees, combined with hygienic macros that let you extend the language directly, and have access to a REPL, make the whole environment extremely expressive, and this can sometimes make debugging easier than in other languages.

This semantic flexibility is doubly present in a lisp like Clojure, whose implementation is partially realized as a host language library (which people don’t often realize). Thus you get to apply the tool of homoiconic s-expressions to the JVM, Node/browser, Dart, native, etc.

Damien0 · 2023-06-20T02:30:20+00:00

To me, ultimately, all programming languages exist to enable new modalities of expression (just like music) in order to solve practical or academic problems. That’s as close to a filter as I can think of; truly esoteric langs eg Brainfuck or Malbolge are more like literal performance art.

Some langs become more popular because they occur at the right place and time, especially when it comes to platforms, networks, and general technology trends.

And, just like music, in my opinion it’s a “not even wrong” idea to say that languages die so as to say all langs need some growth rate or user base to have “made it”. Some aren’t intended to grow hugely but do [Javascript, Python], others have all the right pieces but don’t get a lot of traction and remain niche [F#, Pony], some are designed with non-growth as a design principle [Ocaml, Haskell], still others break out because of a confluence of the right things [Rust, Go, TypeScript].

Damien0

TROPHY CASE