Having said that, Realtalk looks somewhat interesting: isn't that wish/claim thing a bit like Chris Granger’s Eve?

Yep very similar in principle 🙂

As someone who will never strap a computing device onto my body, for philosophical and physical accessibility reasons, I find the immersive computing future to be dystopian.

Less stridently, but I'm also very skeptical of AR as a primary computer interface. At minimum it must remain possible to fully utilize computers without it.

If you think of AR as implemented by Apple's Vision Pro (to cite just the latest incarnation), I agee with @Nick Main and Andrew F that it's not going to happen for mainstream computing, though perhaps for specific use cases where the inconvenience of the devices is tolerable.

But AR doesn't have to be close-to-the-body devices. Using transparent screens, small projectors, etc., digital information can be added to the physical world in a more natural way, i.e. closer to what our senses handle best.

Dynamicland is a research project. As such, it starts by exploring extremes. Once you understand what you gain and loose from those extremes, you can explore compromises. Which in the case of Dynamicland includes re-integrating tradtional computing technology.

As someone who will never strap a computing device onto my body, for philosophical and physical accessibility reasons, I find the immersive computing future to be dystopian.

I get this completely - but it's a whole nuther thread really. For the sake of this discussion, imagine a non-intrusive AR tech that's fully under your control, etc.

Less stridently, but I'm also very skeptical of AR as a primary computer interface. At minimum it must remain possible to fully utilize computers without it.

Of course, but then outside of your Dynamicland projectors room, you'll still need to do stuff also. Do you think DL is better than AR? Are you skeptical of DL as a primary computer interface?

AR doesn't have to be close-to-the-body devices. Using transparent screens, small projectors, etc., digital information can be added to the physical world in a more natural way, i.e. closer to what our senses handle best.

So a kinda halfway between an AR headset and DL? Interesting. Is there anything out there that works like this?

Dynamicland is a research project. As such, it starts by exploring extremes. Once you understand what you gain and loose from those extremes, you can explore compromises. Which in the case of Dynamicland includes re-integrating tradtional computing technology.

That's exactly how I'm now seeing my own work. It's very freeing. I recommend it to all FoCcers!

I'm having trouble reconciling:

Dynamicland could be done better with Augmented Reality specs.

…with:

All that frayable, water- and fire-damageable stuff. No version control? No backups? Those little test tube doodads will fall apart after a few months.

You're suggesting we use AR specs (or whatever) instead of projectors — that covers the output side of the system. So what do we use instead of physical materials for input side?

So what do we use instead of physical materials for input side?

I think with good hand recognition you could simulate physical objects digitally that would be needed for input (e.g. pieces of paper, buttons, knobs). The main thing missing would be tactile feedback.

I think the way that physical objects benefit from, you know, physics , and that you get this benefit for free , is just as big or bigger than the tactile feedback. That's why I'm curious about Duncan's contention that Dynamicland could be done better with AR specs. DL seems to be largely about embracing the real world, and the human beings in it. It defines itself in contrast to traditional computers. So I want to know if by "better" Duncan means (to be a bit glib) "get rid of all that stuff that makes DL what it is and just go back to a more traditional computer approach, but with AR specs, because traditional computers are better", or if he means "here's a way to satisfy the goals of DL without as many downsides"

AR is both output /and/ input as @Irvin Hwang said, and yes, we're still not fully there with tactile feedback, but there is already work in this area. It would basically work the same as in DL: the camera picks up what's going on (both with hands and with physical objects on the table). AR "embraces the real world" by definition, but can also allow someone remote to be present.

I just think the "stuff that makes DL what it is" isn't the blobby paper, which I think is quite a distraction. If you allow AR instead of all the blobby paper then the real points can come across.

The real points being Three in number, and the number of real points is 3:

1: the pervasive mashability of DATA, of real stuff - just point things at each other, grab, throw aside, reassemble

2: the lab-wide accessibility of the stuff and instant knowledge of its current state anywhere on any table: it's a stuff fabric or landscape of live doodaddery

3: the state- (NOT event-) oriented little encapsulated programs that give behaviour based on current state - similar to the way you program a spreadsheet and having the same latest-state-propagation benefit

So, having unconfused myself by the AR trick, I now see how close Dynamicland is to my own Object Network.

It's important for what they are researching that it is a shared physical reality. They wanted the lowest possible barrier for participation (other than physically being present), so I don't think it was an acceptable solution to require headsets, although I think a sufficiently cheap headset (think paper red/green 3d glasses) would have been an ok solution.

They wanted it to be the kind of thing you could invite a whole class of 7 year olds to and they could jump right in, with instruction/teaching following after.

Chris Knott OK, that's a good test: throwing 7 year olds in and they get cracking right away. It's both an AR glasses tech challenge to make the headwear robust and light and unintrusive, plus an HX/UX challenge, to make the virtual world overlay be instantly interactive and intuitive, by following the conventions of familiar physics.

Not there yet but my own interest would be that HX/UX aspect.

Anyone have responses to my responses to their responses? There's a few outstanding here! 🤗

as Stefan Lesser pointed out here , its about the culture.. 💬 #linking-together@2023-06-26T11:51:28.915Z

Which is why I searched for this video in the dynamic land context: hcii.cmu.edu/news/on/event/2020/09/seminar-chris-martens

I have a friend which has some relations to the internet archive. Its kind of interesting to see how all these efforts somewhat converging towards library economies youtube.com/watch?v=NOYa3YzVtyk

Duncan Cragg I think people get caught up in the current implementation aspects and lose sight of the big idea - what if all our real world objects could compute? The projectors and cameras and papers are just trying to simulate that reality.

@Naveen Michaud-Agrawal yes, that's a logical endpoint, and you wouldn't need to talk about AR or VR, just the New Reality of enriched matter. Houses that could reassemble themselves when you got bored of their layout. So I do think the paper and projectors /are/ a distraction from that deeper vision. And we could still have the exact same conversation in IoT, AR, VR and (dare I say it) The Metaverse!

Andreas S I don't know if Bret sees it as so much of a social project as you are implying? I personally do very much buy in to the ideas of library culture, diversity, inclusivity, empowerment, etc. I was lucky enough to work at ThoughtWorks, where all these values were a daily reality and I was usually in a team where I was in the minority with my (cis, white, male) demographic! On library culture: there's a danger now I may go down the rabbit hole of "Intellectual Property", so I'll stop there...

Yes “property” is something which can be discussed about a lot ;)

Property works as long as "the people" own it collectively, not Big Global Corps, or even Big Unaccountable Governments, come to that. But having said that, I'm a property investor so I'm also one of the bad guys... I think it's about scale, rather than property itself. Of course, IP is a tool/scam that benefits the Big Global Corps.

This should probably be a discussion for the pub not FoC, but I just can't help myself! 😄

I think participating in something as dynamicland will show people after some time that many property constructs we use today are not fitting to that way of workers and living together. So there is a natural transformation going on…

Little, Local and Live not Big, Global and Canned, is my preference. Dynamicland does fit that model.

Nominally, everything after "what is claimed is." How protection works in practice is beyond me.

This is from intentional software right?

Intentional software have been real innovators in this field since 2002, so it’s possible that their work precedes tree-sitter.

Of course that doesn’t change the fact that software patents make no sense.

Yes, or at least from people who used to run Intentional Software. Intentional was acquired by Microsoft around the time this patent was filed. I'm not necessarily so much against software patents, but my understanding is that what you're trying to patent can't exist in the wild at the time of sending the patent application. So I'm puzzled how this got accepted. Maybe Jason Morris can clear things up for us a bit?

No such luck. Studied IP in law school, but software patents never made any sense to me. I suspect a lot more patents get approved than are enforceable, but I have no real clue.

But even "enforcement" has gotten pretty fuzzy because I suspect many software patents aren't intended to ever see the light of a court room... Rather they're just a hedge against accidentally infringing someone else's patent, so you have something to horse trade with them if you need to.

Think of patents as one of the many legal mechanisms larger firms use to communicate with one another.

We talk about them a bit in the crosscut paper: inkandswitch.com/crosscut

First place I saw them was in Toby's Apparatus: aprt.us

I believe he talked about them in more depth... somewhere. Can't quite remember.

Joshua correctly guessed I was thinking about this joshuahhh.notion.site/Spreads-in-Apparatus-50c116eaeed0457d87da8180c2dc151f

Yeah! That's the thing I was thinking about. Thanks for sharing that back here.

Hope you enjoy! For future reference, Dynamicland work hasn’t made use of spreads (yet) – the only place I’ve seen them is Apparatus.

was it OpenAI’s Whisper? github.com/openai/whisper

There is a very easy to work with implementation of whisper called whisper.cpp. Had no trouble installing it personally. github.com/ggerganov/whisper.cpp

have you looked into the indieweb stuff?

their focus on POSSE seems well aligned with this effort.

there are a lot of existing indieweb compatible blogging setups, and many more folks who’ve spun up their home-grown solutions (myself included).

I am familiar with the indieweb stuff, thank you! I am talking about POSSE on one hand — and yet, I'm interested in approaches that are more robust than corporate APIs integrations, especially in the face of API policy changes (e.g. Twitter breaking all of the Mastodon-Twitter crossposters overnight). I'm also interested in apps/clients/extentions that people will be able to use with ease (especially on the non-technical side), given the situation we're all in together.

Any technical solution to this problem is a hack. It will be brittle and subject to legal attacks if nothing else.

The only real long-term solution is to move society away from walled gardens. Tell everyone you know, every time they mention anything negative about a walled garden, about the superior open alternatives. Tell them about the joys of a simple reverse chronological timeline, where the vendor doesn't decide which posts to show you first. Tell them about the flexibility and compatibility that comes from open standards. Tell them about how decentralized systems are resilient against corporate censorship.

And most importantly, don't ever build your own community within a walled garden like slack. 😉

I used to agree re: push away from walled gardens (see my website with like 5000 posts on it) but lately I’ve been wondering if doing things in the public, while big, centralized players still exists, dooms us to just generate more and more fodder for the centralized beasties?

is there another way of “open walled gardens?”

things to keep the big-bad out, but elsewise interop in the open?

I appreciate that perspective Personal Dynamic Media — at the same time, there are projects like github.com/dimdenGD/OldTwitter and Nitter and LibRedirect that have worked well for very long times and have held up. So there are degrees to these things. Gets into what Doctorow describes as "adversarial interoperability / competitive compatibility" — he shares a great anecdote about I think Apple reverse-engineering .doc format, to make it so that .doc was compatible on Apple OSes in the early days, as that was a huge necessity for people. Wanted to share here in case there are any other folks with similar interests in this area.

Interesting questions Eli. Also, practical and timely, as this Slack is synced to linen.dev now — which means contents are public and web-indexable. (Here is this thread, outside the walled garden! linen.futureofcoding.org/t/13090838/i-want-to-be-able-to-post-microblog-style-content-and-have-i#3e1e4f35-3c4e-4f33-8e46-202d7eacc5c7.) I generally agree with PDM about not building community within a walled garden, and yet there are contexts where some degrees of friction or privacy could matter to the community. This was the context which Discord originated in, I guess. It's sort of a parallel thread Eli, maybe deserving of its own post and thread so it isn't buried and others can see — I'd be glad to hear any thoughts of yours for how to prevent harm while talking in the open, and different possible approaches.

Wildebeest from Cloudflare looks good.

Wildebeest indeed looks great. I worry about Cloudflare monopolizing the infrastructure of the Internet though

@Eli Mellen No, there's no such thing as open walled gardens. I don't think there's any keeping the big bad out. Someone with more resources can deploy those resources. Either go private or give up on privacy. Even in a private group, nation states will just pay someone in your group or supply chain to get in every so often.

If you want to be discoverable, if you want to open yourself up to serendipity, avoiding walled gardens is as good as it gets. You can't avoid others using what you put out. All you can do is ensure you have more robust access to it.

Now, what about making our own walled gardens to keep the big stuff out?

I see this as a mostly surmountable issue as long as you walk away from “growth” as a driving factor. Being cozy with a niche enclave.

I know it's boring but manually cross-posting stuff has worked great for me :saluting_face:

@Eli Mellen Cozy is definitely an option. But it also eliminates much of the serendipity that seems to draw people to microblogging. Arguably microblogging is not a cozy activity.

I start wondering what "walled garden" means. I don't think it means, "nobody can get in." Facebook has had pretty terrible security at various points in its life, to the extent that other companies were able to crawl vast swathes of it. Rather, in a walled garden information is being created within at such a prodigious rate that it takes a lot of resources for an attacker to keep up. Walls are for the plebes. So "walling off against Facebook" seems like an ill-posed idea.

(I'm basically regurgitating blog.bloonface.com/2023/07/04/the-fediverse-is-a-privacy-nightmare, except I think the Fediverse is a privacy nightmare exactly to the extent that Facebook or Twitter is. No more.)

I start to wonder what “walled garden” means.

:pixel-chickadee: yes!

I think there are 2 things a walled garden is:

• a physical (or digital) apparatus of separation (so that there can be an “in” and an “out”)
• and a set of “rules” or norms that govern the interior space

Gates and gate keeping.

So, an alternative: (heavy handed)

Lighthouses and ships.

The boundary is softer here. There’s not a magic circle (uh, oh, danger term) but there’s a discrete node (lighthouse) that connects the ships — makes them aware of one another and some geography.

I think a planet is like this. A thing that connects a bunch of otherwise discrete folks around a common facet — webrings, too

(Also, sorry for slightly hijacking this thread, Sam Butler)

to kick off, a bit of a wishy-washy, hand-wavy example: currently computation is a relatively “localized” thing — the types of environments where code to be run is created are pretty similar (broad strokes) to the environments where the code is run, sort of like subjectivity, what if it wasn’t always localized to a single head, or even a head-shaped head?

(which also leads me to wonder what psychedelic computing would look like, but that is perhaps a digression for another day)

Old ideas in the non-local space, which still exist on the fringe, are in the coordination space. e.g. the Linda language and Gelernter's Mirror Worlds idea. Basically a blackboard system, but in addition to putting data there, you can put code to eval "in the space".

I have yet to find something that helps me "think" with others better than being together. Collaborative spaces step things up, but missing DoFs/OOB-info we get in real life makes them, to me, simply "at the same time", which is not "together".

I wish I had better concrete ideas for how to do it, but getting all your thoughts out, to share with others, can move so fast, in so many directions, with so much information, that even just a phone chat is worlds better for me than online chat and edit at the same time. It's also about how well you know people, and how can tools (maybe this is a wedge to drive) help us get to know each other better when not in person? Make it about the social aspect in the context of coding/creation, as we do informally today. For me, a big mismatch there is the flow of chat, but hard to mark things like in a transcript so they don't get lost.

Things like read.ai are pretty amazing for meeting notes. If it could identify "issue X was talked about and functions Y and Z are suspects for an off by one error", along with links, that might be a small step for those who work with it.

Glad you enjoyed the episode, and thanks for sharing these thoughts!

One thought that I had meant to share in the show, but forgot to mention, is that there is actually one escape hatch available to us web developers — the browser dev tools! I'm sure we've all skipped a paywall or fixed a broken form by popping the hood and tweaking the HTML/CSS of some page.

I'm not familiar enough with CL to follow the idea of "restarts" as you've described them. But I like the idea about fuzzy logic + allowing the user to specify data in a that satisfies some program in a format that works for the user.

And yes — "Computer says no" — absolute classic!

I really should mess with the browser dev tools more; I am usually focused on back-end interactions, tormenting the services by proxying through Burp Suite and fiddling with the requests.

On the CL side, that restart example looks at reading files with an invalid entry, and three basic options: skip the entry, skip the file, or provide some default value. A handler is added for each, and the caller can choose which one to use... or none of them, and call another handler function of its own choice.

Choosing no handler, an interactive debugger gives the programmer the option to browse through the calling stack, look at local variables, and edit the definition of one of the functions in the chain. Sounds basic, except that it can be recompiled on the fly, and then the newly-edited function can be called again by restarting that stack frame, and continuing as if nothing had ever been wrong. I find this sort of thing very useful when it might be difficult to get to the specific state that triggered a condition. Maybe the browser debugger can do something similar?

I love anchors, as my brain doesn't like it when things move around and aren't "where I left them". I want to add a table type to our language, like you can have a table in a spreadsheet (at least in Excel), which gives you this sub-thing that is a logical unit and structure, which can grow or change shape.

On the viz side, the trick is how to improve this. Today, at least in Excel, you have the worksheet model, and that's all you get for UI (bear with me). e.g. you can't make a table and pop it up in it's own window. Worksheets are a flat stack, rather than something like MDI child windows. But what if you could do that, maybe something like Oberon or totally free-form. If you want to merge them all into a flat worksheet, their range IDs provide the layout positions, but they also have names and can be addressed relatively that way as well.

An interesting historical point is that the earlier language JOSS (from Rand Corporation, quite similar to BASIC except for syntax detaid) used floating point line numbers, which means that already written statements didn't need to be renumbered.

Though limited in many ways, I do like how Numbers on macOS can use column/row headers as names in formulas.

Thinking more, thes might avoid relavite/absolute B$4 notation due to relocation, but it'll still be needed for replicated formulas when mixing cscalars/vectors/matrixes :-(

E.g. if you have a column of prices * scalar tax rate stored in single cell, the reference to that cell must be absolute.

I'm a big fan. I've tried to shift my mindset more into this space when building gnocchi.club, especially relating to only providing features to help accomplish the task at hand as a contrast against the increasingly chaotic nature of most cooking sites (because of their reliance on ads and the engagement spiral).

It's still hard for me to think outside the box of traditional web apps, but mainly I tried to focus on trying to end up in a usable state no matter what when interpreting user actions, limiting notifications and re-engagement junk, and generally trying to be utilitarian and minimalist as a product by avoiding ambitious features.

We have such a TV, which we bought because of its form factor rather than for the artwork feature. We didn't expect to use it initially. But of course we couldn't resist playing with it, and now we appreciate it for exactly the reason you cite.

If you don't mind me asking, what reaction do you get from visitors? Do they think of it as a piece of art or is it apparent that it is a TV?

We also have a frame, situated on a wall full of actual art/photos in similar frames, so we do use the art display mode on it. The driver was mostly to have it blend in and for the wall to look cohesive when not being used for tv, as opposed to just being a parking lot for a big device. When the light is just right, it really does look like just another art piece, but mostly you can tell it’s a screen, and other cues like it’s position relative to the sofa, being the largest frame on the wall, etc give it a way. No visitors have ever mistaken it for actual art

@Martin Shaw Nobody ever mistook it for a piece of art. Comments are usually of the type "that's a nice way to use a TV".

:heart_hands: Yes yes yes! A lot to this. I have a silly shell script I use to sort of support this.

It allows me to attach arbitrary files to any other files and open them in concert. I use this for comments, scratch spaces, experiments and generally muddying the waters.

I started trying to make my own editor to support this workflow, but found that everything I wanted already existed within the OS itself, so, instead, tried to leverage those and not re-create the wheel (also, I'm allowed to run this on my work computer where I use it the most 😆)

Re: Ivan Reese

Re: @Eli Mellen — That absolutely rules! What's the editor experience like? Like, when you're looking at some code, how do you know that it has a moon?

The editor experience is…uneven. For the most part I rely on my memory to know if there are existing moons for a given file, but I also have a command to list available moons by given file name. Eg, I can check if app dot tee es has any moons, and then open em or not. It’s not super useful for folks other than me, these days. I also tend to do things with window systems that folks find alarming (aka, never a tab, a million windows) I manually arrange moons near or around files, usually in smaller, as close to square as I can get, windows.

(aka, never a tab, a million windows)

A, a citizen of Siracusa county :)

Tax paying, flag waving, patriot of it, yes.

Swift/Xcode has some kinda Markdown-formatted comments thing. That’s not specifically about size , but it’s related, right? Rich formatting embedded into the source-of-truth code?

I’ve been thinking that we should have and use more formatting (fonts, sizes, weights, layout, etc.) in code. Why shouldn’t my code look as good as a professionally typeset manuscript?

Has anyone tried this?

I’ve been thinking that we should have and use more formatting (fonts, sizes, weights, layout, etc.) in code. Why shouldn’t my code look as good as a professionally typeset manuscript?

Has anyone tried this?

I use acme, a text editor from plan9 pretty much daily. By default it uses proportional fonts. Not exactly the same since everything is the same text weight, but, I find it nice for the most part.

I also write a lot of apl. The dyalog interpreter uses sort of proportional fonts for the glyphs. But there there’s a pretty stark aesthetic distinction between code and everything that isn’t code.

The visual design needs of prose and code are very different I think, applying similar tools without analysing those differences feels like it would quickly become counter-productive imo

Building UI with some great designers taught me that visual hierarchy and typography are really deep skillsets. In some ways I feel fortunate that language design (i.e. use of symbols for structure) and syntax highlighting gives us a lot of good visual design for source files without having to consciously make decisions about things like heading sizes, flow, spacing, etc.

Funny enough it was one of those designers who first complained to me as he was starting to code, "why can't I make comments a larger font size" though. I do agree comments could benefit from more visual emphasis, particularly. But he intuited this problem because he had the skills and experience to understand it and fix it. IDK if I could be trusted to use those same tools.

Maybe linking the visual design to semantic meaning would help the idea fit better into the mental model of coding. Like classifying multiple kinds of comments... Your classic TODO, FIXME, but also ASIDE, TIP, WARNING, etc. These get emphasized or de-emphasized accordingly.

I do have a VSCode plugin which color highlights some of those tags which does help me.

I feel — though I’ve not explored the idea much — that formatting could indicate some of the semantics of a program ~in place of~ some of the symbols we currently use. For instance, indicate a function declaration by the name of the function being on its own line in larger, bolder text. I’m not sure how far this goes. It does seem to end with some sort of structured editor if you want to edit code with formatting like that.

Or, maybe just having a way to take some source code and typeset it for easier reading? ( ~If~ it would actually be easier instead of frivolous.)

There are a couple entwined questions here. One is varying prominence of comments and (presumably other language features). The other is traditional text formatting for code. I like the idea of supporting different types of documentation at the language level, and potentially different display, if it's standardized , or if I can uniformly configure it in my editor.

For general formatting, the conventional wisdom is already to enforce most formatting questions via linter. I think adding more degrees of freedom will make things worse for all but the most artisanal coders.

Appreciate all the comments!

If you, humble reader, find yourself thinking "not sure if that'd fit well with the tools I use, or my team culture, or the broader ecosystem of my PL", then by all means deeply consider the reasons that it won't work. If that leads you to a realization about how to make programming better with a few minor tweaks on the status quo, awesome!

But also—if you'll allow yourself—indulge in a bit of wild speculation about how things could be radically different.

For instance: I arrived at this "hey, why no sense of scale?" thought by actually imagining tucking a booklet into the back pocket of a function. I picture the booklet as being about the size of my hand, maybe 50 pages with a nice flat binding, and the function is something made out of cloth and metal and it's about the size of a large dog. It feels a bit like remembering a dream — the details don't need to be clear, they just need to motivate me to ask "why?" about something I've taken for granted for * checks watch * about 20 years now.

Maybe linking the visual design to semantic meaning would help the idea fit better into the mental model of coding.

I quite like this thought from @Grant Forrest. This is one of the big critiques of node-wire visual programming — it's "visual" in only the shallowest sense, because the visual design is half-devoid of semantics. The spatial arrangement of nodes has meaning to the human programmer, but not to the computer. It would be nice to play with a visual programming system that allowed for both.

For instance, indicate a function declaration by the name of the function being on its own line in larger, bolder text.

This comment from @David Alan Hjelle makes me think of literate programming. I'd love to try writing in a literate language that expected rich text. I'm sure such a thing exists, I've just never used one.

On the topic of TBD: FIX: ... I started using a couple functions named e.g. n.b. for this purpose. Tooling can find them, but their argument can be anything. e.g. , of course, is almost always an inline example, but may refer to a file, url, or hashtag.

While it may make sense to change how things look, I imagine many of us remember the early days of desktop publishing, 3D borders in GUIs, circus-inspired web pages, etc. The goal is to communicate meaning and intent clearly, in context, but also let people find more information as needed or desired. So, rather than text size, what if this content became links, maybe with a preview popup? Things can be smaller, but still a paragraph long, which makes them either hard to read or take up so much space that you lose more active content. What I try to do is minimize the size of the comment content, though sometimes I still do entire paras and have 5:1 comments to code by line.

Why shouldn’t my code look as good as a professionally typeset manuscript?

A good experiment would be to take a non-tiny piece of software and do this. It's largely aligned with Literate Programming, so yes it's been done. Why didn't LP win? Many reasons and mine would only be anecdotal. I love the idea in theory but, having tech edited and co-authored books, I'm much happier writing code. I'm also a lot better at it. There are two different skills at play.

Another pretty easy experiment is to take a codebase and simply write a ToC and index for it, like a book would have.

Consider, also, that formatting is intended to aid the reader. This is what we should all do. Who us our reader? It's not a novel, or a play, or a textbook, or a newspaper. But if we take those as examples, how much variety is there in typography? Not much. Mostly it's about structure.

I think LP would have been better served by getting rid of the whole typographical angle: akkartik.name/post/literate-programming

This isn't to say typography doesn't matter. I love OP. I just consider any connection to LP to be a red herring that will lead you astray. LP's notion of typography was much weaker than Ivan's vision.

This matters because I think this is a misguided question:

Why shouldn’t my code look as good as a professionally typeset manuscript?

Why should code look like manuscript? The use case and needs are very different. Code is fundamentally non-linear.

I mean, to the extent that we have zero typography in code, sure, anything would be an improvement. But I think it would quickly hit diminishing returns. It would be a strategic dead end. The typographic needs of code need to be rethought from scratch.

Makes me wonder about other ways that being able to choose the size of representation in a program — independently from typical size units of code (ie: lines) — could be useful.

One place I would have loved this is when I was trying to grok Lisp interpreters. The classic Lisp interpreter looks something like this:

def eval(form, env):

  case

    ... -> eval(..., env)

    ... -> eval(..., env)

    ...

  end

end

Basically you have a large number of branches, and each of them has some complicated expression that passes env around. For more real-world codebases (like github.com/arclanguage/anarki or paulgraham.com/bel.html) each case might be complex enough to require a helper. In which case you now have a maze of mutually recursive calls. And often the case that actually uses env is just one line deep inside one of the helpers. All the other mentions of env exist just to plumb it through to that one line. It would be great to typeset all the mentions of env in small font size, but magnify the font size of env in that one line.

And this is just one argument. If you look at Bel's source code, there's a half dozen such arguments being plumbed through in a similar pattern that would benefit from this sort of visual salience management.

cough, cough

px23.clerk.vision

a little pocketbook tucked into the back flap of a function?

Reminds me of some paper I've seen attaching hand-written ink annotations to code. don't remember the specific paper, but found now several on Beryl Plimmer's publications, sounds like a good starting point...

(I have to question the long-term accuracy of anything you can't grep, but actually handwriting recognition might mean you can, and anyway there is interesting value in enabling the kind illustrations we tend to draw on whiteboards but rarely commit.)

Varying font size go nicely with zooming! Code Canvas tried quite a lot of that. Imperfect aesthetics, but some interesting gradual-reveal functionality 👍

eaglemode.sourceforge.net file manager does quite unusual UI tricks with zooming and font sizes – e.g. instead of tooltips, UI elements (buttons etc) documentation is engraved right on them in tiny font. See "project philosophy" there.

And museapp.com.

Prototyping tips: (1) Emacs supports varying fonts. The poster child is latex but you can apply it to any kind of syntax-highlight. Plus various support for folding. (2) on the web, CodeMirror.

a emacs screenshot with rather ugly mix of fonts I just tweaked away:

Emacs has many packages to add custom "faces" (its term for stylable fonts, a-la CSS class) to things like "TODO" or any regexp really, so you could add some custom "constructs". (OTOH really customizing the font-lock parsing is ...ad-hoc pain. maybe LSP-mode makes that more approachable?)

Common writing advice says to delay styling until the writing is done. Most code is never finished; it's merely released, to be edited again soon.

Re: Nodes and wires. I think text is already very good at visualizing code. The visual programming that is of interest to me visualizes the ~data~ flowing through the program, rather than the code itself.

Of course emacs can do it. 😄 I'd imagine it gets progressively harder to do "fancier" layouts, though — some because of the limitations of the language's syntax, and some because of emac's limitations (uh, if it has any…). Out of curiosity, can comments be formatted as some sort of aside or margin notes in emacs?

So many interesting thoughts and takes in this thread! Thank you all!

having tech edited and co-authored books, I'm much happier writing code. I'm also a lot better at it. There are two different skills at play.

I definitely think there is an element to this. I am certainly more verbose than most of my co-workers — well, oddly, maybe more verbose in issues and merge requests, and perhaps more terse in code. That said — I'm personally thinking less of literate programming and more of fancy syntax highlighting.

Mostly it's about structure.

Yes, exactly! What ways can we devise to communicate that structure more effectively to our brains?

Have you seen quickcheck (in Haskell) or similarly inspired libraries in other languages (like hypothesis for python)?

hypothesis.readthedocs.io/en/latest

Those are new to me but I have heard of property based testing! It was on my list of things to learn about, then I forgot. Thanks for the pointer!

“generative testing” is the broadest umbrella term

wiki.haskell.org/QuickCheck_as_a_test_set_generator

I mean, I have every unhandled exception on my SaaS app fire an email to me.

Some days, I wake up with 2000 emails.

But most days, if there's any error email at all, it's a good "huh — didn't know that was a thing that could happen. Let me go fix that!"

So I think yours is a good idea.

Maybe my first takeaway is, I would totally alarm on 500s, but the address thing would be codified as a 400. I wonder if there is a scalable model of validation that doesn't rely on the certainty of "not recognized = invalid" and puts you in the loop. Or an LLM in the loop, maybe (although that just seems to pass the buck a bit).