casual conversation · software unscripted podcast

I have been loving working my way through the backlog of the Software Unscripted podcast! Can't believe I didn't know of it sooner. Thought it'd be fun to have a thread in here to chat about it if there isn't one already.

Most recently listened to the episode with José Valim. Massive respect to him, I feel like he's been such an excellent steward of that language and community. Excited to see what they can do with static types.

Richard Feldman (Jun 19 2023 at 16:51):

thanks! I just recorded a follow-up episode with Jose, hopefully will be out in a month or so

Uttam Narsu (Jun 30 2023 at 21:23):

Richard Feldman (Jun 30 2023 at 22:34):

I don't know any of them, but I'm totally open to it...I wonder if anyone knows them and could make an intro?

Logan Lowder (Jul 03 2023 at 14:34):

Just listened to the episode with Jean Yang. It feels like all of the folks I've been following in software for the past few years end up on your guest list, Richard! Stellar guest line up! :big_smile:

You guys shared some really challenging thoughts about how we want to create these "worlds" of software without chaos or disorder and maybe the right move is moving to the "era of nuance", trying to make things better where we can. Like 2nd law of thermodynamics. We can't escape entropy or Murphy's Law.

Richard shared a thought about feeling like your role is to try to bring ideas from academia into industry and practical use. That resonates with me so much and is something that really draws me to Roc. Wanting to make something that's not just a marginally better programming language but something that at least attempts to make some significant steps forward and push the industry forward.

Uttam Narsu (Jul 13 2023 at 18:10):

I reached out to see if there's any interest. I don't know them but worth a try!

Johan Lövgren (Oct 15 2023 at 13:34):

I just listened to the most recent episode with Troels Henriksen. What a great interview. He’s clearly brilliant, fun to hear him derive in real time the implications of Richard’s statements! :big_smile:

Isaac Van Doren (Oct 15 2023 at 14:29):

Agus Zubiaga (Dec 01 2023 at 23:39):

Casey Muratori not knowing about ORMs made my day. Must be nice :smiling_face_with_tear:

John Murray (Dec 01 2023 at 23:40):

Brendan Hansknecht (Dec 02 2023 at 01:02):

So for mojo, I would say that the language essentially is c++ in python clothing. The python is jit compiled instead of interpreted. You can add a lot of extra typing to the python to make it static, templated, etc. Compared to C++ I would say the templating is a lot cleaner. They also have much nicer support for simd and things of that nature to make code faster.

Lastly, mojo has the magic of MLIR. With that I mean, it is easy to extend the language with mlir primitives and then use those primitives. As a direct example, Tensorflow has an mlir dilect that can compile to gpu. You could use that directly in mojo to build a graph and then run it through tensorflow on the gpu. This gives a huge level of extra potential power and flexibility to the language.

Johan Lövgren (Dec 02 2023 at 12:52):

I also feel very vindicated after having struggled with CSS so much at work. “Nobody knows how to center things!” :laughing:

Pearce Keesling (Dec 02 2023 at 18:31):

I feel this on a deep level. I work in react native and even when you get the right flex styles on everything sometimes you just run into a Yoga bug that has been around for 5 years so you need to so some insane workaround that makes no sense.

David Dunn (Dec 13 2023 at 19:41):

David Dunn (Dec 13 2023 at 19:43):

Luke Boswell (Dec 13 2023 at 21:41):

Sweet, I didn't know this was on Spotify, I've listened to a couple of podcasts before after hearing about it on this forum but always just downloaded the file from the website.

Agus Zubiaga (Dec 14 2023 at 16:26):

It's also in the Apple Podcasts catalogue which means you can listen to it in apps like Overcast (which is my favorite podcast player).

Brendan Hansknecht (Dec 14 2023 at 16:35):

Anton (Dec 15 2023 at 09:13):

Hannes (Dec 15 2023 at 10:47):

AntennaPod also had a yearly summary, all generated on device with no telemetry!

Software Unscripted was number 5 for me this year, but that's because I listened to the whole back catalogue, probably won't be so high next year unless Richard releases another 100 or so episodes in 2024 :laughing:

Elias Mulhall (Jan 06 2024 at 20:09):

Love that José has come back for three episodes now. I learned about Roc through him promoting the first elixir static typing episode. What a guy.

Zellyn Hunter (Jan 07 2024 at 21:15):

I guess this is the topic for Software Unscripted discussions? I just listened to the Roc reverse interview, and am part-way through the Go one, and I have so many comments. I'm a — I guess somewhat expert? — Go programmer, working at Square, with a pretty huge Go monorepo.

Richard Feldman (Jan 07 2024 at 21:15):

Zellyn Hunter (Jan 07 2024 at 21:16):

re: Go package management over-indexing on performance. It's actually trying to avoid falling into 3-SAT, which is very easy to do. Most package managers essentially have a custom solver for the 3-SAT equivalent problem. Go's packaging design is carefully avoiding that.

Zellyn Hunter (Jan 07 2024 at 21:18):

re: tabs vs spaces for indent and copy/pasting code: in Go, since it's not whitespace-sensitive, you can just past and reformat. IIUC, Roc indentation can indicate scope (or is it usually just laid out to look like that?). So, especially for the copy/paste situation, you might need to decide on your own solution based on first principles.

Zellyn Hunter (Jan 07 2024 at 21:19):

In a large monorepo, you get a lot of vendored code. du -h in our monorepo's vendor folder gives me a terrifying 740M!

Zellyn Hunter (Jan 07 2024 at 21:20):

That does bring the usual problems of "I want to upgrade package X, but now I have to worry about matching versions of gRPC, protobufs, the GCP libraries, etc." It's not as bad as in Java, but with an undisciplined use of third-party code, it definitely becomes something to think about.

Zellyn Hunter (Jan 07 2024 at 21:27):

The rest of the monorepo is less than twice that size, if I exclude the protobufs

Zellyn Hunter (Jan 07 2024 at 21:29):

Our go.mod has 5 replace directives, three related to protobufs (Square was very early with protobufs, and made a bunch of custom changes, which I have not yet in 8 years here managed to expunge.) All 5 are to Square-specific forks of a corresponding open-source package.

Zellyn Hunter (Jan 07 2024 at 21:31):

Although they get less mention, in my personal, non-work Go, I find "workspaces" (go work …) essential: it lets you define a workspace below a set of directories, and then specify which of those directories to use instead of the real, remote version.
In my "blog" workspace, for my personal blog, I have checkouts of goldmark, goldmark-pikchr, and hugo, since I had to do some custom stuff to make Hugo support pikchr diagrams (unfortunately currently broken, and never got enough "tuits" as the Perl folks used to say.)

Zellyn Hunter (Jan 07 2024 at 21:32):

blog🐚 ~/gh/blog ls
bin             go.work         go.work.sum     goldmark        goldmark-pikchr hugo            zellyn.com
blog🐚 ~/gh/blog cat go.work
go 1.20

use (
    ./goldmark
    ./goldmark-pikchr
    ./hugo
)

Zellyn Hunter (Jan 07 2024 at 21:34):

(Off-topic, that ":shell:" is because I'm using hermit, which is great. I've started using it in all my personal repos, since it dramatically improves the "coming back to this thing in 3 years and how do I even get things compiling again?" experience. I should write a roc package for hermit.)

Zellyn Hunter (Jan 07 2024 at 21:40):

One last comment on versioning. Go is very committed to the idea that v2 is a completely different package, with a different name. This does _not_ work well for projects that want to create versions every three months (I thought k8s was like that, but its github says it's on v1.26.12, so :shrug:), nor projects that want to number releases based on year/month or similar things.

Zellyn Hunter (Jan 07 2024 at 21:41):

There are also some kind of subtleties around import paths and version tags and github repos that I really should just go read an internalize once and for all, because they get annoying to constantly not quite understand.

Zellyn Hunter (Jan 07 2024 at 21:43):

go.mod also allows v0 "pseudo-version numbers", which look like v0.0.0-20170915032832-14c0d48ead0c — they encode the shasum and the… datetime, it looks like?

Zellyn Hunter (Jan 07 2024 at 21:46):

fwiw, the complaining about Go package management that I've seen mostly stems from how the team handled communication with the community: some folks had invested a huge amount of effort into independently developing a traditional solver-based solution, and Russ's more dramatic re-think, while very much in Go's style, kinda came out of nowhere. Opinions and hurt feelings abound, or abounded — it's receding into the past now.

Zellyn Hunter (Jan 08 2024 at 01:36):

One of the reasons it's harder to teach recursion than for loops, even when they compile down to the same CPU steps, is that that shape of tail-call recursion that emulates a loop is a slightly degenerate case of recursion: it's recursion, used to loop. But it's taking a much more powerful machine (recursion) and using an instance of it to do something simple (repeat these steps). Recursion can also do things that go down multiple paths, like graph search or tree traversal, or even fibonacci numbers.

Zellyn Hunter (Jan 08 2024 at 01:37):

Of course another reason is that recursion just seems to be hard for people to understand, in the same way that people find proof by induction a bit mind-bending. Repeating steps is something you do every day in normal life.

Zellyn Hunter (Jan 08 2024 at 01:39):

re: hot-code reloading. I love the idea that since all state is in the platform, you can easily swap out roc code! Definitely a win for functional programming. Go does have plugins (link), so it should be possible to segregate, say, handler functionality, out into a plugin, and hot-reload that. Indeed, it appears someone has built a thing that does that: https://github.com/edwingeng/hotswap

Zellyn Hunter (Jan 08 2024 at 01:43):

re: goroutines and grow-on-demand stacks. IIRC (and it's been a while), the fact that Go has weird stacks and non-standard calling conventions means that it's not that hard to host c libraries in Go — I think the cffi code makes sure the stack is "big enough" and then does a little translation of calling conventions around the handoff — but (unless things have changed) means that it's difficult to host Go code inside of something with C calling conventions and stacks, etc. Even when Google was considering building a giant sidecar-like thing, or inside-out sidecar-like thing ("envelope"), I believe for Go, the plan was to have Go own main, then hand off to the envelope code and then have it call back into Go. (Although it's been a while… my memory is fuzzy.)

Zellyn Hunter (Jan 08 2024 at 01:53):

One question I'd be interested in your thoughts on, @Richard Feldman … y'all were talking about Functional Programming quite a bit, and Lane mentioned teaching Functional Programming in Python. Indeed, that was more or less how I learned Functional Programming, a very long time ago at Georgia Tech: the first few weeks of Lisp were limited to purely functional constructs (old-school lisp cons lists lend themselves to that anyway), and then as the quarter went on we settled on a "you can be destructive inside a function, but you should still make it look purely functional to the outside world". That seemed to be what Lane was using "Functional Programming" to mean. As a mostly observer, who has never used a purely functional programming language "in anger", that although that sort of completely technically defines what Functional Programming means, it's really only one half of the story.

The other part seems to be a mix of very powerful higher-level tools for thought and programming: (a) sometimes I'll see Haskell folks talking about Functors and Lifting and Monads, and it seems very powerful: like they're reasoning at one level higher in abstraction than normal imperative programming would lead you to, like they've applied some kind of "Lift" operator on their abstractions (b) there's a sort of inside-out turning about that seems to happen in functional programming. The I/O or Task paradigms seem to do this. Although Roc code goes to some lengths to make Task-based code look sequential, under the covers, it's callbacks all the way down, and it's a slightly mind-bending blend of "my response to this input is a set of instructions to run that'll depend on the next input" kind of thing. It _may_ be analagous to the explicit inside-outing that seems to happen in finger trees and similar immutable data structures. All I know is that I look at monad code in Haskell, or Task code in Roc (a bit, although it really does look like imperative code :smile:), or, say, JSON-parsing code in Elm (or really any parsing code in any of them), and I feel like there's a level of familiarity/comfort with some kind of inside-outing going on that I just don't quite grok.

I find the first paragraph above to be easy to get, as a fairly skilled (imperative) programmer. I've mostly bounced off the second one.

Zellyn Hunter (Jan 08 2024 at 01:56):

As an example, in the episode y'all did about gradually rewriting your backend Ruby code into Haskell, you mentioned a re-architecting that put the database queries at the start, and then the logic, and finally resulted in a set of mutations to apply. That feels very analagous to the overall way I/O or Tasks work in functional programming languages, and seems like something only a Haskell programmer would have come up with. (It also sounded like a very powerful and lovely abstraction/pattern, and I would gladly listen to like five podcasts in a row if they went deep into the concept until I could grok it enough to apply it elsewhere!)

Agus Zubiaga (Jan 16 2024 at 12:33):

Wow. Hearing “Combo boxes” brought me back to hacking afternoons after a middle school day

Zeljko Nesic (Jan 23 2024 at 13:30):

Zeljko Nesic (Jan 23 2024 at 13:31):

Emil Kloeden (Jan 24 2024 at 09:35):

Chris Wesseling (Jan 26 2024 at 21:36):

Chris Wesseling (Jan 26 2024 at 21:41):

@Richard Feldman Maybe you can add them to the show notes? Hmmm I guess not, there are multiple references to the show notes from several podcast platforms. Mutating them would break referential integrity.

Chris Wesseling (Jan 26 2024 at 21:43):

Richard Feldman (Jan 26 2024 at 21:45):

Richard Feldman (Jan 26 2024 at 21:46):

Chris Wesseling (Jan 26 2024 at 21:48):

It's a very cool subject. I just added HM type inference to the most ugly Lisp known to the internet (JsonLogic). Worked through the papers, and implemented in Python and Typescript.

Richard Feldman (Jan 26 2024 at 21:48):

Chris Wesseling (Jan 26 2024 at 21:48):

Richard Feldman (Jan 26 2024 at 21:49):

Chris Wesseling (Jan 26 2024 at 21:51):

Supporting variadic functions. JsonLogic has some operations that can have different arity. So I solved it in the parser by monomorphisation.

Richard Feldman (Jan 26 2024 at 21:51):

Chris Wesseling (Jan 26 2024 at 21:51):

Chris Wesseling (Jan 26 2024 at 21:53):

Chris Wesseling (Jan 26 2024 at 21:56):

A. Richter (Jan 26 2024 at 23:55):

@Richard Feldman, big fan of your podcast here. A friend and me think, that John A De Goes (@jdegoes on X.com), the head behind ZIO (great and innovative effect system for Scala, with big focus on Dev Experience) and Golem.cloud (invincible cloud platform around WASM, written in Rust) and You would be an perfect much for a podcast episode, what do You think?

Richard Feldman (Jan 27 2024 at 00:03):

Christian Queyrouze (Feb 05 2024 at 19:43):

where's the issue for lambda set defunctionalization? and can you also send a link to your O-Camel implementation of it?

Richard Feldman (Feb 05 2024 at 19:59):

great question! I don't think we have a GitHub issue for it (unless @Ayaz Hafiz knows of one?) but here's his OCaml implementation: https://github.com/ayazhafiz/cor

Elias Mulhall (Feb 06 2024 at 16:25):

Isaac Van Doren (Feb 15 2024 at 02:31):

I really enjoyed yesterday’s episode with Greg Wilson. I resonated a lot with the industrial design analogy.

It’s super cool that he wants to do a book with Roc and I would love to participate! :big_smile:

Brendan Hansknecht (Feb 15 2024 at 05:04):

Luke Boswell (Feb 16 2024 at 06:46):

I really enjoyed that episode. Would love to contribute a chapter, or at least the start of a thing.

Johan Lövgren (Feb 19 2024 at 18:28):

I had not heard of Greg Wilson until earlier this month when I listened to the latest CoRecursive episode in which he told his story. I recommend that one as well to anyone who liked the Software Unscripted episode, he talks about some similar topics.

IsaacDynamo (Feb 29 2024 at 19:58):

Are there show notes for the Software Unscripted podcast? If so, where can I find them?

Richard Feldman (Feb 29 2024 at 20:52):

IsaacDynamo (Feb 29 2024 at 22:15):

IsaacDynamo (Mar 02 2024 at 14:14):

Quorum @ 8:00

Beautiful Code @ 23:10

How do the experts solve difficult problems in software development? In this unique and insightful book, leading computer scientists offer case studies that reveal how they found unusual, carefully designed solutions to high-profile projects. You will be able to look over the shoulder of major coding and design experts to see problems through their eyes.
https://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047

The Architecture of Open Source Applications @ 42:53

Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.
https://aosabook.org/en/index.html

Software Design by Example @ 46:00

The best way to learn design in any field is to study examples, and the most approachable examples are ones that readers are already familiar with. These lessons therefore build small versions of tools that programmers use every day to show how experienced software designers think.
https://third-bit.com/sdxpy/

@ 46:48
Take apart applications, look at how there designed to give you a vocabulary for larger scale design.

@ 55:44
We need to get better in reading code and understanding what design is embodied in it. And how the code is manufactured.

Luke Boswell (Mar 04 2024 at 00:26):

Zellyn Hunter (Mar 19 2024 at 17:24):

@Richard Feldman would it be possible to create a Software Unscripted "stream" (I think that's the right name in Zulip) so that each episode could get its own conversation?

Zellyn Hunter (Mar 19 2024 at 17:26):

Richard Feldman (Mar 19 2024 at 18:00):

Anton (Mar 19 2024 at 18:12):

I'm good with trying it, if it gets so active that it's distracting we could find a new home for it.

Notification Bot (Mar 19 2024 at 18:47):

nat-418 (Apr 05 2024 at 17:32):

discovered the pod through Roc and been really enjoying it. great combinations of good guests, good vibes, and good questions

Richard Feldman (Apr 05 2024 at 18:02):

nat-418 (Apr 19 2024 at 22:50):

been working through the back catalog of episdoes and I too recall keybase. recently I have been exploring the Codeberg organization and found this interesting project : https://keyoxide.org/

nat-418 (Apr 22 2024 at 12:34):

just listened this morning to your episode about vim etc. have you tried neovim? with neovim's tree-sitter integration you can have the structural movements etc. you were talking about wanting

Richard Feldman (Apr 22 2024 at 13:56):

the last time neovim was my main editor, it didn't ship with tree-sitter integration - but I've recently been using Zed as my main Rust editor and it has tree-sitter built in! I'm really enjoying it :smiley:

Der Schutz (Jul 03 2024 at 13:10):

Been binging the podcast while driving to/from work, amazing conversations and guests. I've become more aware about a lot of topics I never knew about and definitely my favorite software/programming podcast. Also the intro/outro music is awesome.

Would love to see a convo with ginger bill, since I've heard the issues with providing array programming built-in to not support general operator overloading mentioned and Odin has it. I remember hearing about how to use Arena's for something specific in a text editor, he'd probably be able to answer that too since Odin's virtual.Arena is common. Odin has a very pragmatic design philosophy, reminds me of Go. Also could mention using your own language at work. I believe (might be wrong) he said his team has a 700k+ LOC Odin codebase integrated with 500k+ LOC of other languages. I think there is a lot of interesting conversation there.

Stream: software unscripted podcast

Topic: casual conversation

Logan Lowder (Jun 19 2023 at 15:40):

Richard Feldman (Jun 19 2023 at 16:51):

Uttam Narsu (Jun 30 2023 at 21:23):

Richard Feldman (Jun 30 2023 at 22:34):

Logan Lowder (Jul 03 2023 at 14:34):

Uttam Narsu (Jul 13 2023 at 18:10):

Johan Lövgren (Oct 15 2023 at 13:34):

Isaac Van Doren (Oct 15 2023 at 14:29):

Agus Zubiaga (Dec 01 2023 at 23:39):

John Murray (Dec 01 2023 at 23:40):

Brendan Hansknecht (Dec 02 2023 at 01:02):

Johan Lövgren (Dec 02 2023 at 12:52):

Pearce Keesling (Dec 02 2023 at 18:31):

David Dunn (Dec 13 2023 at 19:41):

David Dunn (Dec 13 2023 at 19:43):

Luke Boswell (Dec 13 2023 at 21:41):

Agus Zubiaga (Dec 14 2023 at 16:26):

Brendan Hansknecht (Dec 14 2023 at 16:35):

Anton (Dec 15 2023 at 09:13):

Hannes (Dec 15 2023 at 10:47):

Elias Mulhall (Jan 06 2024 at 20:09):

Zellyn Hunter (Jan 07 2024 at 21:15):

Richard Feldman (Jan 07 2024 at 21:15):

Zellyn Hunter (Jan 07 2024 at 21:16):

Zellyn Hunter (Jan 07 2024 at 21:18):

Zellyn Hunter (Jan 07 2024 at 21:19):

Zellyn Hunter (Jan 07 2024 at 21:20):

Zellyn Hunter (Jan 07 2024 at 21:27):

Zellyn Hunter (Jan 07 2024 at 21:29):

Zellyn Hunter (Jan 07 2024 at 21:31):

Zellyn Hunter (Jan 07 2024 at 21:32):

Zellyn Hunter (Jan 07 2024 at 21:34):

Zellyn Hunter (Jan 07 2024 at 21:40):

Zellyn Hunter (Jan 07 2024 at 21:41):

Zellyn Hunter (Jan 07 2024 at 21:43):

Zellyn Hunter (Jan 07 2024 at 21:46):

Zellyn Hunter (Jan 08 2024 at 01:36):

Zellyn Hunter (Jan 08 2024 at 01:37):

Zellyn Hunter (Jan 08 2024 at 01:39):

Zellyn Hunter (Jan 08 2024 at 01:43):

Zellyn Hunter (Jan 08 2024 at 01:53):

Zellyn Hunter (Jan 08 2024 at 01:56):

Agus Zubiaga (Jan 16 2024 at 12:33):

Zeljko Nesic (Jan 23 2024 at 13:30):

Zeljko Nesic (Jan 23 2024 at 13:31):

Emil Kloeden (Jan 24 2024 at 09:35):

Chris Wesseling (Jan 26 2024 at 21:36):

Chris Wesseling (Jan 26 2024 at 21:41):

Chris Wesseling (Jan 26 2024 at 21:43):

Richard Feldman (Jan 26 2024 at 21:45):

Richard Feldman (Jan 26 2024 at 21:46):

Chris Wesseling (Jan 26 2024 at 21:48):

Richard Feldman (Jan 26 2024 at 21:48):

Chris Wesseling (Jan 26 2024 at 21:48):

Richard Feldman (Jan 26 2024 at 21:49):

Chris Wesseling (Jan 26 2024 at 21:51):

Richard Feldman (Jan 26 2024 at 21:51):

Chris Wesseling (Jan 26 2024 at 21:51):

Chris Wesseling (Jan 26 2024 at 21:53):

Chris Wesseling (Jan 26 2024 at 21:56):

A. Richter (Jan 26 2024 at 23:55):

Richard Feldman (Jan 27 2024 at 00:03):

Christian Queyrouze (Feb 05 2024 at 19:43):

Richard Feldman (Feb 05 2024 at 19:59):

Elias Mulhall (Feb 06 2024 at 16:25):

Isaac Van Doren (Feb 15 2024 at 02:31):

Brendan Hansknecht (Feb 15 2024 at 05:04):

Brendan Hansknecht (Feb 15 2024 at 05:04):

Luke Boswell (Feb 16 2024 at 06:46):

Johan Lövgren (Feb 19 2024 at 18:28):

IsaacDynamo (Feb 29 2024 at 19:58):

Richard Feldman (Feb 29 2024 at 20:52):

Richard Feldman (Feb 29 2024 at 20:52):

IsaacDynamo (Feb 29 2024 at 22:15):

IsaacDynamo (Mar 02 2024 at 14:14):

Quorum @ 8:00

Beautiful Code @ 23:10

The Architecture of Open Source Applications @ 42:53