<Cue flashbacks to the “what should we use instead of Slack?” discussions>

Exactly!

I am curious what you think about harassment? Not quite trolling, not quite vanity.

Moderation in general is the single biggest thing that has always put me off from creating any public forum of any sort across any modality. I have a lot of appreciation for people who do it, like Ivan here -- and have successfully mooched off of their labors all these years.

And yet, it's starting to feel like my projects need a central place of their own where someone can come see past questions and discussions that are currently only centralized in my notes. (And if it gets people here off Slack, I wouldn't be above spinning up a forum that forks this place.)

So I have zero grounds to pretend at any sort of knowledge or expertise on moderation. Mostly I figure, it looks like I have to get to this some time, the sooner I start, the more of a hope I have of learning to not suck at it. So your question about these gradations completely goes over my head. But ask me after I've been running something for a year.

Oh, one random note: Maybe pseudonymity makes harassment more difficult? It's easier in my system to create a new handle than it is on say ActivityPub. Does that seem to move the needle?

My naive plan for moderation is: make commits in git. By nature, this moderation log will be totally public, just the git log.

But by the same token, for any sort of scale I can hope for, it should be super easy to detect and delete harassment?

Probably. I’ve never run a community. If you’re going to comb git logs before harassment hits anyone’s inboxes, I don’t see anything wrong with starting there.

A common kind of harassment that drives people away from online communities is, in its simplest form, randos dropping slurs then poofing. So long as I’m me and want others to know I’m me, the people who do that sort of thing can find me too. I don’t see that accounted for in the four-point framework you mentioned, and that’s what makes me curious.

That's a good point. I don't think attacked from within is trying to be perfect, or to guarantee absence of various sorts of dysfunctions. It seems to be trying rather to sculpt energy barriers for good vs bad actions. So yes, you're going to need moderation independent of the auth mechanism.

Have you considered? en.m.wikipedia.org/wiki/Usenet_newsgroup

No! 📝

My very boring question would be why not an email list?

I was wondering as well what you want to do differently from existing approaches. The obvious part is lightweight software, and that's something I like very much. But then? What are the specific features you want to have? Which ones you definitely do not want to have?

I'd also add what features are you willing to walk away from?

Why not an email list: lot of work to self-host, kinda like a proprietary service if you don't self-host, and it excludes large swathes of people who just don't like it.

For a long time my twin reasons for not creating any community were:

• Any medium I choose excludes a majority of people who don't care for it.
• Moderation headaches.

The big insight here is realizing that these reasons are in opposition. Excluding people reduces my moderation headaches 😄 So I just need a way to avoid excluding the people I want to hear from. Requiring people to install LÖVE seems like a good filter. The goal is a place to ask questions after you've run one of my freewheeling apps, and making the communication tool itself a freewheeling app seems like an elegant solution.

What features I am willing to walk away from: how much time do you have? 😄 archive.org/details/akkartik-freewheeling-2023-07-06 demonstrates a tiny browser replacement UI that might give you a sense for how bare-bones this might start out as. Really the only thing missing in git.sr.ht/~akkartik/pothi.love is a server for requesting posts/comments from and some way to tell that two comments are by the same person. And maybe I don't even care about guarantees on that?!

I might still end up holding my nose and creating a new community on Discord, just because that seems most popular in the LÖVE community.

Cozy Web by design - interesting! Plus dogfooding.

In that context, your question about authentication becomes: which sign-up effort will my intended audience accept?

Example: assuming your audience is proficient with a Unix shell, you could use shell accounts with ssh access and use the ssh keys for authentication. That also scares a lot of people away, but if you don't care about such people, that's fine.

Yeah, I don't want to make any assumptions about my audience beyond a willingness to install the tool.

Though now I'm reading what I wrote and imagining someone modifying the client to automate sending spam to the forum. Good thing the code is so hackable! :lolsob:

Seriously, though, I would love to get lots of Windows people.

Yeah, I don’t want to make any assumptions about my audience beyond a willingness to install the tool.

The biggest assumption to me here is around accessibility — while an OS or browser brings a TON of headaches and complexity, it also brings with it a TON of accessibility tooling that love2d has none of. I can’t change the text appearance of a love2d application without modifying the application, and while I know how to do that, it isn’t necessarily as easy as using my operating system’s zoom capabilities.

You're absolutely right, and this very much wears on my mind.

Is there any good history of accessibility efforts in web browsers? How did this highly capitalist-owned product end up achieving so much for accessibility.

One correction: all my LÖVE apps support ctrl+= and ctrl+- for increasing or decreasing the font size. So at least I have that covered..

and, also, that wasn't meant as a judgement, I love what you do with love2d, btw

I didn't know that about your love apps! That is rad

as for how accessibility was achieved in browsers, my honest guess is that it was an accident of history more than it was intentional.

Like, if you think through the architecture, it is sort of backwards how we apply accessibility as sort of a veneer on top of a finished product, even WCAG is this -- it is accessibility guidance when a standard already exists. Why not bake it into the standard? Why not have a standard for how to implement accessible rendering of an element like they do for browsers, instead most accessibility tech (even the stuff baked into browsers a lot of the time) mostly function as a black box. It is hard to tell what they do and why

Yeah, my goal is to judge myself so that nobody else has to. Or before anybody else does. 🙂

I would love to have a set of criteria (say in the form of behavioral tests) that my app has to hit to be accessible.

For example, screen readers. My app has text. I can provide the text in any API you like. But I don't know anything about how say a text to speech generator would hook up to a web browser. But this feels like it should be easy? I'm just missing some key knowledge.

I, too, would have to have that level of detailed knowledge about how such tools work 😆

I have tried to get it, and you can sort of get there, but, like, the way JAWS works versus NVDA versus VoiceOver are all different. There isn't a clear and easy path -- so, we're left with sort of heuristics and well known patterns for widely targeted system (e.g. web and "native")

the work some game studios are doing I think really highlights how this is mostly unexplored ground since they're all sort of having to invent it as they go along

whereas if you wanted to render HTML to pixel-based screen today that is relatively achievable

I would love to be bombarded with links!

I can't bombard ya with links at the moment, but I'll consider that a mission!

I think the path is well-lit if you target a single platform. I’ve followed accessibility tutorials on Android and Apple. I just have no idea how to make them all happy simultaneously without embedding a browser. :face_with_peeking_eye:

Probably the way to go is convince a government agency to build apps in LÖVE. Then someone has to make it happen.

Oops, I forgot you wanted this thread to be about identity.

@Eli Mellen Accessibility in browsers was no accident! We fought for that stuff for years , starting in the mid-90s. Here’s a web designer writing about it in 2000:

Designing adaptable pages is designing accessible pages. And perhaps the great promise of the web, far from fulfilled as yet, is accessibility, regardless of difficulties, to information. It’s an important belief of the World Wide Web Consortium , and is becoming an imperative of web design, as web pages will be required by law to provide universal access, just as building codes around the world require access to buildings.

Sorry, I didn’t mean to imply that the fight to bring it was an accident, but the way it was implemented, like so much of the web, seems sort of … layered on? Does that make sense? Again, this isn’t to belittle what we’ve got (I think the web is by and far the most accessible platform around). I should have used a less loaded word, for sure!

All the web stuff is definitely a bit ad hoc! I just wanted to point out that that particular thing wasn’t an emerging property, and that we can’t just assume that accessibility will happen 🙂

Yes! 100%

I must admit that I'm very wary of "anonymous by default" systems, given the horrible cess-pool that is chan boards.

Have you considered a petname system for user ids? It could be really interesting to see in practive

Thanks for reminding me to reread skyhunter.com/marcs/petnames/IntroPetNames.html! I got a lot more out of it this time.

4chan is indeed a concern. I don't quite (yet) buy fully into the worldview of "attacked from within". This is all an experiment I want to be very careful about scaling up.

I feel that data and metadata should be strictly separated so that I don't ever accidentally corrupt metadata by using a field that I'm not supposed to. This is the same kind of in-band signaling that made the old phone system vulnerable to blue boxes and that created SQL injection vulnerabilities all over the internet.

Not sure I follow that last part

When you mix data with metadata, you make it possible for certain values of the data to accidentally or deliberately corrupt the metadata.

With in band telephone signaling, telephone system devices communicated with each other using special tones that were sent over the same audio channel as the voice communications. This made it possible for people to manipulate the devices by playing tones into their telephone. The data is the voice communication, and the metadata is the phone system signaling information. By sending them in the same channel, it became possible for people to corrupt the metadata through carefully chosen values of data.

People who construct SQL queries by including user supplied data, rather than using placeholders, create the risk that carefully chosen values of data, namely the thing being searched for or stored, can corrupt the "metadata," (okay, I'm stretching a little here, but the principle is the same.) that being the structure of the SQL query itself.

Not sure about the database case but

I feel that too much implicit & hard to guess "magic" behaviour is generally a bad thing.

– Shell script is really bad at that in syntax interpretation (parse time).

– Python does a lot of implicit magic at runtime.

Even seen a video mocking this for a laugh (with a cringe & tear).

Personally I rather prefer more verbous expliciteness. Doing trice the work upfront instead of doing 30x the debugging work later.

Well, exaggerating a bit. Maybe.

I think progressive disclosure is what we need to get out of that misery conserving rut. But that needs structural-projectional editing.

–For C&C++ go no further than:

henning-thielemann.de/CHater.html

Super important part of the FOC, see some recent discussions below. Also check out Amy’s explorations linked in both!

💬 #linking-together@2023-09-28T00:25:49.288Z

futureofcoding.slack.com/archives/C5U3SEW6A/p1696137050571599

Thank you!

Also relevant are the explorations around non-English computation

💬 #linking-together@2023-09-16T04:59:58.848Z

I am pretty conflicted in this area, as one of the main aspects of my grand plan is a UX or HX (human experience) built around a shared space, which inevitably means 3D for me. But of course, people with reduced abilities around vision won't be able to access that as well as most. Of course, they still grasp the concept of a space, and there will be ways to allow them to enter, "see" what's there, and interact. But I spend a LOT of time planning the 3D stuff, and there's a lot of code around it.

It heads naturally towards AR and VR: which are very immersively 3D of course. Now, those with partial or no sight still belong in the real 3D world, but this means they have to have i/o that works for them: so probably sound, maybe touch and motion.

Nothing profound to say here, but wanted to raise my hand and let ya know I spend literally all day thinking about this everyday 😂

Always glad to chat about this aspect of the future of coding.

When I think about this, I try to approach accessibility as something that can be baked into the design of a thing, and not made to be just about I/O and UI -- while those are specific facets of accessibility, I think there is work to be done about creating pits of success that our foundational to a thing that lead to more accessible experiences for all.

@Eli Mellen need examples!

Here's a random idea: how about using LLMs to describe a UI to visually impaired readers? I've seen LLMs used for summarization in other contexts. Could it be a useful alternative to screen readers?

Could it be a useful alternative to screen readers?

In short, and sort of blunt terms, not really

In slightly longer terms, yes-ish. What an LLM describing an interface made exclusively for a sighted person to use would accomplish is insert an extra layer of mediation between user and interface

screen readers don’t reproduce a UI 1:1, instead they decompose it into a navigable tree, sort of like a DOM, but broken out by semantic (and ideally) interactive elements

I think that if an LLM could describe an interface, but I think it would be tricky not to sort of re-create a screen reader in an LLM if you want it to be useable, if that makes sense?

Duncan Cragg I think one of the only IRL examples I’ve seen in the future of coding space is @Amy Ko’s work with wordplay.dev, where, at least judging by the demo, it assumes various accessible outputs as default, it isn’t something the dev has to layer on

I've used screen readers on an accessibility project in the education domain. They are maddening, but I suppose a visually impaired reader may get used to them. I suggest that screen readers are less than ideal for certain information displays: graphs, tabular data, others? An LLM in certain contexts may provide a more accessible description: "Here is a graph with time on the x access and population on the y axis. The y access ranges from zero to 1 million in increments of one hundred thousand..."

One could also imagine an interaction with the LLM: "Tell me what the population value is for the year 1910?"...etc.

100% — as caveat this is what I do for work as an accessibility specialist for the US gov. — what I’ve seen in the research is that often times folks who rely on screen readers as their primary interface aren’t generally interested in interacting with a graph. Folks often propose audio solutions to graphs when, what most folks end up wanting is just a sentence describing it, so, an LLM that could do that would be pretty slick — maybe not even describe the graph, but sort of summarize it: “32% of respondents agree with the question” and then maybe an interface to inquire deeper

Yes, exactly what I am getting at. Something to provide an overview to orient the user.

@Greg Bylenok I came across this blog post that is interestingly connected to this discussion!

A related question I have about this is that I can imagine using a screen reader to write code being mind-numbingly awful, Christ Krycho talks in his "New Rustacean" podcast about one of the hardest things about it was explaining code with just his voice (for example "then type let x equals some struct colon colon new open paren close paren") is not very helpful or engaging. Does that mean the future of code is something more like literate programming?

Does that mean the future of code is something more like literate programming?

I dig this question so hard

Also relevant are the explorations around non-English computation

I always appreciated that Swift went with pure UTF-8 identifiers, that doesn't solve the keyword problem or even other language context concepts (RTL/LTR, or the existence or meaning of sigils)

Previously I didn't really see a lot of benefit to the Unison before but I wonder if there is a place for its "this is not text" approach to definitive source code?

We release Wordplay beta next Tuesday. It’s really only a glimpse of what’s needed for accessible, language-inclusive programming, but I’m looking forward to everyone’s thoughts!

I finally got a chance to watch the webinar and I am very excited about the work you are doing Amy. Thank you

I can only guess, but I suspect you will find that people don't do polymorphism because it solves writing problems they don't have, and creates reading problems they don't want. No reason for despair generally that bad ideas aren't widely adopted, particularly if you judge ideas by their adoption.

There are many kinds of OO, but the kind one mostly encounters is quite bad. Those who have programmed using Java/C++-style OO, or in languages that should be able to do better but are culturally poisoned by Java/C++ culture (Ruby, for example), often develop antipathy to the whole idea.

I was being too abstract, and unfortunately this topic sparks too much controversy to be useful but still thought I’d try.

Yes I’m talking about ruby, & JavaScript, Jack Rusher that makes sense.

What’s really bothering me here is a bigger question:

If people are so resistant to change & you propose a non-trivial idea which might actually get adoption how do you get people to not just use it like their previous thing.

Like to me the java/c++ thing is they are structured (c/basic/etc) programmers who do things with in objects now, in that case setting up & programming an interface is such an immense pain few people do it enough to get the epiphany.

What does it say about us that even an idea which had so much going for it, almost completely missed in practice? Was smalltalk in particular marketed poorly to make it more approachable than it was? Was it purely the confusion with Simula which shared the term “OO” & bjarne quotes as primary influence of c++v

I see loads of objects in Ruby and JS, just mostly for the worse. Can you give an example of this kinds of things you’re proposing that aren’t being taken up?

Not just objects, but actually doing work to define good interfaces. I’ve yet to see it in either.

The closest actually good example in rails is people creating custom form objects to do forms which don’t work exactly like the built in form objects - don’t map exactly to 1 model. This is just looking at existing interface & putting something in, and in practice its quite good.

I’m not just talking about using classes or objects, but actually spending the time to think about & design interfaces to make good generic code.

I fear I’m having trouble making my point, there is too much nuance in this topic for me to speak clearly about it. It goes beyond OO, but I think that’s lost, I apologize. Having a tough week, I need some time to think about how to phrase my thoughts on this.

API design is hard is every language/paradigm, yeah!

with the caveat that I’ve worked in very few code bases that are really “all in” on OO, the ones that I’ve seen come the closest to making it a good thing (good read here as “helpful”) are the teams that did the work ahead of time to model their domain, to define what an “object” was, and not sort of back into modeling objects just based off of some real world things like a lot of books suggests. Doing that, I’ve found, can dig ya into a wicked deep whole.

I think, OO, like a lot of design philosophies, can be a powerful tool, but can’t be applied without doing the design work, too, and not all devs are cozy or know how to do that level of design.

I think OO is pretty good as long as you layer on a couple of additional dogmas:

• Keep data and behaviour separate
• Everything is either abstract (designed for extensibility) or final (doesn't allow extensibility)

it's interesting that you bring up polymorphism...I've kind of been on this kick for a while too 🙂

There's this talk from a while back that I really like The Soul of Software where Avdi Grimm mentions this breakdown from Object Thinking of programming having two schools of thought: Formalists and the Informalists (Hermeneuticists)...and Avdi makes a comment that if you were taught inheritance before polymorphism, you were taught by a formalist, but if you were taught polymorphism before inheritance you were taught by an informalist...

Ultimately what I've found and that they mention in the book - programming/engineering is heavily dominated by the formalist world...so it can be hard if you find yourself as the only person in the team with the opposite view of programming

the way I see the answer to your original question though is that the pendulum kind of swings back and forth over time with one side being frustrated while the other is in their element and highly productive

like...Ruby in the late 00's/early 2010s was dominated by this culture of throwing off the constraints of java and having complete freedom...which led to a huge explosion of new concepts and tools and ideas hitting the mainstream...(at the same time making it possible to make horrible abominations - I was at Groupon in 2013)

and now you see those concepts and tools shifting more into the formal realm where variation and stability and correctness has become more important, because the patterns that work for the types of apps people are building have been found

Yes, inheritance will paint you into a corner, but you don't need to use inheritance all the time. Delegation, interfaces, etc. Rust traits, Go delegation, Haskell typeclasses. Polymorphism without the inheritance. Also related, of course, is the expression problem when talking about OO vs non-OO. giacomodebidda.com/posts/3-ways-to-solve-the-expression-problem

@Marcelle Rusu (they/them) You’re touching on something that resonates a lot with me. However I’m unsure if you talk about what I think you do, or if I’m just reading into your post what I want it to say.

Let me try a few seemingly random questions to tease out what you are trying to point at:

• The original Gang of Four ~Design Patterns~ , do they exemplify what you are trying to point at? Or are they irrelevant for that? Or are they perhaps even a counter example?
• Some ontologies try to categorize everything in one huge tree (eg. biological species). Others are just trying to paint a comprehensible picture of complex local relationships. One could say the former is more concerned with identifying all the nodes while the latter is more concerned with identifying all the edges. Would you agree that the former feels misguided or irrelevant for what you mean and the latter is closer to it? Does the former remind you of inheritance?
• Does a mathematical structure from group theory like a monoid (not a monad; although that’s adjacent I’m deliberately trying not to go there) feel related to your idea of power from polymorphism? For instance, adding integers and concatenating strings feels somehow similar, but yet clearly is also different. Does that map to what you have in mind? And furthermore, would you agree that it’s not about the formalism (that we call it “monoid” and can precisely describe what we mean), but about the intuition we can develop for it (“Ah, it’s the same thing! It works for integers, strings, and now I see how I can transfer it to this other type and it’s beneficial to see the connection and treat it the same way.”)?
• When you described that scenario where polymorphism is replaced with “a switch statement”, did you feel like the other person is just not “getting it”? Did you feel like your polymorphism way was simpler and more elegant, but the other person clearly thought it was more complex and argued that it’s hard to beat the simplicity of a switch or if statement? Do you happen to come across a different understanding of what is simple and what is complex more often?
• That kind of polymorphism you think of, how does it relate to beauty? Would you say it’s beautiful? Does that question even make any sense to you at all or do you think I’m taking it somewhere weird now?

Sorry if I throw around concepts you’re not familiar with. I’m just trying to cover some area, hoping I hit enough overlap with your experience to find out if we think about the same thing or not.

Really appreciate this framing, totally agree & feeling less dread ❤

This I think is a very common issue, how do we measure success of anything? If a sports team doesn't win the championship is that season a failure? If someone only stays at a workplace for 12 months, is that a failure? If a project only has 1 or 2 adopters was is a failure?

As someone who builds ambitiously in my free time, I can honestly say that adoption is not a great metric for success in software. I've spend 6 years working on a single open source suite and so far I know that there is 1 actual user. I learned sooo much along the way though and I choose that as the metric for success here because if I used adoption it would be an unequivocal failure.

I’d add that everything we have now passed through the filter of adoption. These processes are complicated and path dependent, but new things can survive and reach wide enough use to feel like they’ve made a difference in the world.

The way I see it, there is a layer of UX missing from what we call “programming”.

What we call “programming” is a way of scripting single-threaded[sic] CPUs in a fairly rigorous and efficient manner. What non-programmers want is not to be bothered with all of that bumph. BASIC and SpreadSheet language are sufficient and don’t involve deep thinking about the actual act of programming. The missing layer of UX is something like a mapping from BASIC to extreme lambda calculus. Example: in the Lisp world, FEXPRs are convenient, while hygienic macros are more rigorous, but, less convenient for non-zealots. How do we provide a method for programming that presents ultra-rigour as a convenient-to-use IDE? Forcing non-programmers to think deeply and rigorously about programming ain’t it. [My bet is on box-and-arrow diagrams using 0D, non-conventional uses of OhmJS, PEG, SVG, HTML, etc., but, YMMV].

For adoption, I see two levels that matter. The first level is "large enough mindshare to survive and prosper". The second level is "large enough to be considered mainstream", meaning among the top contenders.

My personal interest is in learning, discovering, improving. Technology in this space should reach the first level of adoption to stay useful in the long run, but stay well below the second level at which the practical needs of lots of users drown any interesting discussion of fundamentals.

I'm still optimistic that adoption barriers/network effects can be eliminated with wasm support and cross-language build systems.(cross-language build systems are currently just nix afaik, not the best, but building another one is not especially hard, you just need more than one compiler toolchain to have wasm versions and then you're basically there)

Though I've never seen a wasm gc interface language that was like "yes we're going to make gc and non-gc programs seamlessly interoperable"

I am not convinced yet that enough people in WASM space care enough about language interoperability to make it happen. WASM might just become “C for the browser”, with everyone providing an FFI for WASM binaries but no support for actually dealing with another language’s high-level data structures.

What makes you unconvinced, from my memory working on Rust's wasm-bindgen there was a lot of energy around interop, then it was "host bindings" now it seems to be components

• I don’t see who would have both the incentive and the means to do the job. 2. I don’t see multilingual WASM apps, nor toolchains to produce them. There is of course promising work, including components, but it’s not yet ready for real-life applications.

TBH you could say that about WASI (if not WASM) in its entirety

The podcast Advent of Computing had a couple good episodes about it.

adventofcomputing.libsyn.com/episode-19-plato-part-1-a-revolution-in-teaching

adventofcomputing.libsyn.com/episode-20-plato-part-2-an-online-revolution

It is discussed by Ted Nelson in Computer Lib/Dream Machines.

There's some information at platohistory.org

There's an emulated system you can connect to at cyber1.org

The book The Friendly Orange Glow is the most complete history of PLATO that I know of, but I did not enjoy reading it. It was very confusing.

Oh awesome! I've been playing around with irata.online, which is a plato system you can use today!

I really loved A Friendly Orange Glow! What made it confusing for you

I could never keep track of who was doing what in the stories he was telling.

Ah yeah, that’s always hard

REBL reminds me of en.wikipedia.org/wiki/Common_Lisp_Interface_Manager, not that I've used it but I know it supports a graphical cli. google.com/search?q=lisp+clim&tbm=isch

REBL looks like the poor man’s version of the Smalltalk inspector to me. The Common Lisp equivalent would be Clouseau: mcclim.common-lisp.dev/static/manual/mcclim.html#Inspector.

As a daily user of a next-generation Smalltalk inspector (in Glamorous Toolkit), I tend to be disappointed by these tools. Data Rabbit is a different story, it’s more a data exploration than a code development tool.