What I find most shocking about Excel is how often you conceptually have regions with the "same" formula (just references varying) with very little help from the tool to maintain the integrity of this "formula."

An earlier thread I started asked why people thought so little progress has been made in “future of coding” style dev tools. After seeing how spreadsheets are being used, I’m starting to think the answer is that spreadsheets have been a good enough solution to saturate this part of the dev ecosystem and that’s made for relatively few opportunities in the space.

I'm not sure how big a "part of the dev ecosystem" that spreadsheets consume... A lot of the "run your business" cases, definitely, but not that much in terms of how humans can use computers.

Do you think there are more commercial apps than apps made within spreadsheets?

I couldn't say... I guess I'm thinking more of the mind-share of what people could think up and want to build. Like graphics, for instance — a lot of great advances there, a lot of FoC projects. Or big data / data analysis. As many different areas as there are, there should be FoC approaches and innovations.

Feels like spreadsheets would mostly only encroach and suck up oxygen of business applications — but even there, projects like Coda succeed (or at least survive in the ecosystem).

In fact, I'm of the mind that spreadsheets haven't even started to soak up the mind-share that they should. So many possibilities that haven't even been explored. https://futureofcoding.slack.com/archives/C5U3SEW6A/p1595371343178500

Wouldn't the super complex excel programs be using macros and are more visual basic than excel at that point?

What does "self-describing" mean? Are you going to label every number what it is? A price? A price in dollars? A price of a TV in dollars? A price of a Sony TV in dollars? A price of a Sony TV model KHL123456 in dollars? etc...

How about this other number. It's an area of a house floor plan in square meters. Will it be labeled how accurate it is? Is it rounded to the nearest square meter? Is all area inside the outside edges of the walls (so it includes the walls?) or is the space between walls? Does unusable space like a staircase get included?

Just trying to clarify what "self-describing" means

Do you need a giant taxonomy of categories?

Taxonomies are an orthogonal issue. A self-describing data object is (according to me) just one that contains all the metadata (e.g. references to standardised attribute definitions) needed to determine the information it contains. The actual amount of information stored in the object (level of detail) is also an orthogonal issue.

http://ivizlab.sfu.ca/arya/Papers/SW/SOP.pdf

Subject-Oriented Programming (A Critique of Pure Objects)

This essay critiques the idea that it is possible and desirable to put all of the information needed to interpret an object inside the object itself. Different applications or modules may interpret the same data in different ways, and you can't always plan for all of these interpretations in advance.

If you have too much self description, it's cumbersome: code can get very verbose with all the adding and removing of tags. I've seen class libraries for computer graphics where there are separate Point3 and Vector3 classes (for points and vectors in 3D space). That's too much self-description for my taste. In the graphics languages I use, a point and a vector have the same representation, as a generic 1D array of numbers, viz: [x,y,z]. If I store one of these values in a record, then the field name will informally indicate whether the value is being interpreted as a vector or a point. No need for the value [x,y,z] to be self describing as well.

If you have too little self description, code gets cryptic. Like in old-style Lisp programming, where you use lists for everything (no records or maps).

@Nick Smith I'm interested in this as well. Mostly from the perspective of resilience and as a way to separate content from structure.

You set aside taxonomies and level of detail as orthogonal. Would you mind elaborating what you'd consider essential? And are you by any chance currently experimenting with this?

Stefan Lesser The "essential" definition of self-describing data is (to my understanding) the one I gave earlier in the thread. The data must (at the UI level, not the DRAM level) contain references to well-known attributes that have an agreed meaning within a certain community/context. I haven't been able to think of any alternative definition.

This requires that attributes have IDs (potentially UUIDs) that can be looked up in some kind of registry.

Doug Moen I agree with the premise that a data set may be perceived differently at different places/times within an application/system. Though that doesn't obsolesce this discussion: we can refine it to be about self-describing views (derived/reactive data sets). Though such a perspective won't necessarily aid us here. The problem I'm trying to solve is: when you give a data set to someone (a human or a device), how are they supposed to figure out its meaning? Or rather, what is the best way to do so? Send them an email explaining the meaning? Or something more formal and machine-friendly.

references to well-known attributes that have an agreed meaning within a certain community/context.

@Nick Smith Isn’t that what a taxonomy is all about?

When I think about self-describing data, I’m most interested in in-band vs. out-of-band transmission.

Some parts of a data format need to be agreed on out-of-band. That could be generic assumptions like endianess, that a string is encoded in UTF-8 or that a field in the UI only takes a valid email address. If that’s just assumed, these assumptions need to be transmitted out-of-band, i.e. on a different channel which could be that email you mentioned or is just “obvious” within a community (side note: there’s danger of exclusion here).

Self-describing data formats transmit more information in-band, as part of the data. So there is an explicit part of the data that says what follows is UTF-8 or there’s a mime type that indicates here comes an image or JavaScript, or you go all the way and end up in semantic web land with those unique, agreed upon entities described in RDF and OWL.

The question to me is: how much of a data format can and should be described explicitly in-band?

And the interesting challenges hiding under there are: encoding structure vs. content and what is data vs. what is metadata?

I'm trying to avoid the baggage associated with the term "taxonomy", since the most common usage implies "hierarchy" and declarations from some authority (and I don't want the discussion to veer off in that direction). We can use the term https://en.wikipedia.org/wiki/Folksonomy if we want a specific term (thanks to Jack Rusher). What's important here is not the characteristics/structure of a classification scheme (which is what taxonomy/folksonomy is concerned with), but the mere existence of such a scheme.

The question to me is: how much of a data format can and should be described explicitly in-band?Serialisation formats are not a language or environment concern, they're an implementation concern, and I'm acting as a language/environment designer rather than implementer as of late, so I'm not focusing on that stuff. But I'm interested in how the semantics of a data object are presented to the user! Which is closely related. If you're on that bandwagon, then sure, that's the question 🙂

(Btw, if one was to argue that data formats are part of the user interface, then my retort would be that your programming environment is too small in scope)

@Nick Smith If you're interested which "bandwagon I'm on", the second half of this post explains it better: https://stefan-lesser.com/2019/12/06/structure-and-behavior/

While I do see a distinction between data format and UI, I don't think that's just two different categories, but more like several layers, almost like a gradient. If a string is ASCII or UTF-8 is probably just an implementation detail (until we talk about import/export). Requiring an email in a form field, not so much. Although it's still just some bytes being parsed in a certain way.

So I wouldn't exactly claim that "data formats are part of the user interface", but I wouldn't claim that these things are completely separable either.

There’s this very intriguing bijection happening between maps and Lambda Calculus. Linking to my tweet as I have collected some relevant stuff connected with Lambda Calculus and Graph theory there: https://twitter.com/prathyvsh/status/1284124568831975425

With regards to how one might have the benefits of market societies without the inhumanity of them, I rather like https://www.globalutmaning.se/wp-content/uploads/sites/8/2011/01/Davos-The-nordic-way-final.pdf as a starting point:

[O]ne can discern over the course of the twentieth century an overarching ambition in the Nordic countries not to socialize the economy but to > liberate the individual citizen from all forms of subordination and dependency>  within the family and in civil society: > the poor from charity, the workers from their employers, wives from their husbands, children from parents – and vice versa when the parents become elderly>  […] legislation has made the Nordic countries into the least family-dependent and most individualized societies on the face of the earth. To be sure, the family remains a central social institution in the Nordic countries, but it too is infused with the same moral logic stressing autonomy and equality. The ideal family is made up of adults who work and are not financially dependent on the other, and children who are encouraged to be as independent as early as possible.

[... and particularly this statement about love ...]

[A]uthentic relationships of love and friendship are only possible between individuals who do not depend on each other or stand in unequal power relations. Thus autonomy, equality and (statist) individualism are inextricably linked to each other.That said, I also have sympathy for Freinacht's concerns about personal freedoms within these sorts of structures.

One very interesting approach that I have found so far is John Vervaekes - Awakening from the meaning crisis series https://m.youtube.com/watch?v=54l8_ewcOlY and his work in general. He is a cognitive scientist and in search of practices to tackle the challenges of the meaning crisis.

To “steal” the culture - https://m.youtube.com/watch?v=Q9AZZI6PPRQ

This might all be too academic feeling but stick with me here, because scholarly academic politics outside of partisan bleh is quite a nice place to visit...

1. We (humanity) live in a neoliberal world, A word that has lost its meaning and is obscured from general discussion and even thought so our only hope is to look to academia.

Neoliberalism: the reigning philosophy of life, politics, society and economics since the 70s-80s. get an overview https://www.theguardian.com/news/2017/aug/18/neoliberalism-the-idea-that-changed-the-world?CMP=Share_iOSApp_Other.

2. We will eventually (and I’m arguing here for ‘imminently’) need a coherent, scalable alternative.

• This is something that should be thought about and discussed and yet we have forgotten it’s an ideology in the first place.

More specifically with all the reading n’ stuff...

https://en.m.wikipedia.org/wiki/Inventing_the_Future:_Postcapitalism_and_a_World_Without_Work [wikipedia summary] It's openly partisan but isn’t a partisan discussion.

Less likely to sit as well universally are the https://criticallegalthinking.com/2013/05/14/accelerate-manifesto-for-an-accelerationist-politics/ and https://en.wikipedia.org/wiki/Capitalist_Realism.

But really any of the work that’s yet to escape the lab of politics departments that is working to build a truly coherent politics beyond neoliberal capitalism in all its many forms is worthy of reading and bringing into general discussion.

@Andreas S.

To help connect the dots, do you see ways that any of these scholarly academic ideas have implications for technical research? Like, if someone is pro-accelerationism, would certain kinds of projects be more or less difficult in such a world? If the political future I believe in is incompatible with the technological future I'm exploring, that would be super useful to know early. If there are no such constraints, then this feels like a complementary subject where we can "cleave nature at the joints".

As an example, I think a fundamental property of software is that it can't be delegated without exposing oneself to unbounded risk of being pwned, at some point in the long-term future. This leads me to trust extrinsically motivated (for pay) software less than intrinsically motivated, and small-scale software over large (because of the need to maintain relationships with one's dependencies). That worldview further leads, inevitably, to a world where software is developed primarily by those who can make ends meet by other means besides the software they write. If you trust someone enough to use their software, it seems to me, money can't be more than a tiny part of that relationship. This is an uncomfortable realization for me, because I'd love to live in a world where everyone can contribute to open source, rather than just the modern equivalent of gentleperson scientists in the Enlightenment. More background reading on my worldview: https://en.wikipedia.org/wiki/Gemeinschaft_and_Gesellschaft; https://en.wikipedia.org/wiki/Guanxi

We don't need to debate the pros and cons of different schools here, but it might be interesting to take on frames of reference and explore implications.

Kartik Agaram my Zettelkasten repo is called - connecting dots 😅

I will put this here too but I guess it’s interesting enough to discuss on its own. How to connect these threads?

https://twitter.com/smdiehl/status/1288106450707873794?s=21

Code of conduct - surveillance state how does it fit together?

Kartik Agaram I do see a possible alternative to your trust scenario. Software could be written by paid professionals but be independently audited for various quality criteria, including privacy. Clients would then have to trust at least one certificate issued after an audit. This is in fact not very different from how we evaluate complex physical artifacts coming from industrial production lines.

Kartik Agaram to join some dots, there are several ways we can help:

by building software, languages and ideas that make it possible for smaller groups of people to build larger systems

By aligning our software projects with ideas that are compatible with a good future (truly owning data, trustless systems like decentralised apps, avoiding centralised platforms, making sure user data is not central to profit incentives)

And perhaps most significantly, help ourselves and each other understand long-term possibilities in the transformation of our collective political philosophy so that we can (as individuals and collectively) help to transform politics and political discussion to change what’s possible in terms of the projects, organisations, and companies that we build.

An example of this would be a nation transitioning to an economics build around automation, universal basic income and an intentional move towards eradicating work (wage labour).

You may not think that’s the way to go, and that’s fine because the point is that it’s an example of a long-term philosophical shift that changes the things we can do, we’d all have different constraints on time and money which would change a lot of what we can do (in real-world, practical terms). This is sometimes referred to as a type of freedom. Today we have negative freedom, this would be a type of synthetic freedom. https://plato.stanford.edu/entries/liberty-positive-negative/ the ideas are explained well in a different context. An example would be that any US citizen is free to run for president in the negative sense (free from things that would stop you like laws excluding you) but they’re not free to do so in the positive sense (you need enough time, enough campaign finance, etc)

It may not be entirely satisfying but regardless of political affiliation politics sets many of the constraints that manifest in the things we do as programmers and people in computing in many forms. So any discussion will be incomplete without some purely-political discussion too. We may be more interested in changing programming and computing, but must acknowledge and act on the underlying politics too if we are to make lasting significant worldly changes.

I would argue that politics dictates software more than software dictates politics. Even with magical future programming systems, by themselves they are not capable of radically transforming politics and therefor not sufficient to truly transform programming.

@Orion Reed To connect some more dots: remember Conway’s law. A software architecture favorable to out goals (whatever they may be) can only be developed and maintained by organizations that have a corresponding structure.

Konrad Hinsen yes exactly, and I would extend ‘organisational structure’ to include the political and economic system that organisations exist within.

Also worth mentioning research funding, which has almost disappeared for truly long term computing projects. Hard to image a Xerox PARC right now.

I'm keenly interested in the question of how we can create a better future for all of humanity, but the conversation we would need to have to scratch the surface of what that might mean in practice seems too large for this venue.

I'm enjoying the continued discussion!

A fantastic fresh perspective can be found in the book Walden 2.0, written by one of the top behavioral theorists of the last 100 years. It's a utopian novel that wrestles very well with the implications of things like universal basic income, but has I think a superior model. It is however a difficult book to come by.

@Jack Rusher great point, and you’ve clarified an organising principle for my thoughts here.

Let me try and connect the discussion to this community:

Within our political economic system we are by default second hand dealers in ideas. We are not the source of impactful political ideas because we think of computing, not of politics.

Importantly, we do interact with the people and knowledge within political thinking, but usually through media, conversations, social media, etcetera.

Regardless of what we do we will be thinking about, spreading and interacting with deep systems of political theory, economics, and so on.

Work by people in the field where politics is almost as code is to us. It is knowable, sometimes objective and academic political thinking accumulates and spreads over time.

So for us, who already have a world of things to do and think about, it is not a world we can really participate in. But if we take it as true that we interact with political research, theory, and philosophy indirectly, I think we owe it to ourselves to try.

This can’t be done by trying to get everyone to discuss thousands of papers, research, blog posts and articles so it seems the best thing we can do as a community is focus directly on facilitating and understand the hard work others are doing.

If I were to start this thread again the above is maybe where I’d start.

Maybe this:

Political theory and discussion to our everyday life is analogous to type systems and static analysis but without the formality of mathematics.

Maybe the best thing is to focus on facilitating further discussion and discovery of that discussion so those that are able and willing to contribute further can do so.

Curious to hear thoughts on this one if you have them.

@Tim Lipp https://www.amazon.com/Walden-Two-Hackett-Classics-Skinner-ebook-dp-B003GEKL10/dp/B003GEKL10 purchased!

@Orion Reed I mostly agree with you on the goals. Amplifying small groups, data sovereignty, avoiding centralization, UBI, these are all the way to go for sure. The challenge for me is how to discuss these ideas in a productive way without pulling in the whole universe into this thread. (Paraphrasing Carl Sagan, step 1 to baking apple pie is a big bang.) How can we programmers here ease into the practice of reasoning about the political "type systems" that influence our lives?

The way I've been trying to manage complexity is to have some hazy sense that the software I create is likely to foster the world I want to move towards, and then forget about politics and focus on the thing I can contribute. But this doesn't feel like an ideal level of integration for sure. How can it be improved?

You're right that software depends more on politics than the other way around. But it also depends more on physics than the other way around. Does that mean we need to also discuss physics? Or is there a different, less reductionist, axis that matters more?

At the risk of seeming to toot my own horn, I recently described how my political goals drive my side project in http://akkartik.name/akkartik-convivial-20200607.pdf. Hopefully it shows that we share many of the same political goals, and that I'm not averse to discussing capitalism here. I've expressed similar sentiments to yours in the past in this group, about the need to discuss the context software is embedded in. Another recent thread that you may like is https://futureofcoding.slack.com/archives/C5T9GPWFL/p1595017818433700

Konrad Hinsen my reaction to independent bodies auditing code is twofold:

• Ugh, that'll squeeze out all that's new and great about software.

• That'll never never work, because software is changing too fast, and auditors will always lag auditees in knowhow.

Perhaps my opinion is colored by only having experienced regulation in India and the US.

Kartik Agaram that’s a great quote and is exactly the kind of base starting point here.

Maybe remixing and collecting thoughts above and putting them in an order that helps us know how to facilitate the conversation.

(Coalescing comments after Orion coalesced intervening questions.)

On a tangent, can I recommend batching up your comments? I think that will help facilitate the discussion you want to have. Just hit send less often 🙂 It'll make the conversation seem more balanced between different voices. I also find that it naturally makes the prose tighter (I'm more likely to edit text I haven't sent yet), and so easier for someone to follow. This thread is now at a forbidding length for someone just encountering it for the first time. And I imagine you'd want more people reading it.

My concern about scope is similar to what Kartik Agaram articulated above. This topic area -- once it escapes Red/Blue tribal poo flinging -- starts from the already deep question of "What is a Person" and then expands to touch pretty much everything else.

Kartik Agaram, I downloaded your article and can't wait to read it. The title is genius.

I used to work professionally as an auditor, and agree with you completely in your critiques. The focus on the "physics" side rather then the "politics" side of programming is what makes it so magical. It is much easier for politicians to lie than it is for scientists.

In an effort to support future discussion —and as proctrastination— I tried to slightly condense and annotate this comment thread, I removed a few things that I think weren’t central, such as some meta-conversation and reactions.

It’s color coded, red means I still have to find a good short paragraph or link. yellow is open questions ripe for potential further discussion. I also tried to preserve some of the original context by keeping the bulk of this thread preserved.

Have a look. notes, additions, edits welcome. (I’m thinking of making a more condensed version with few or no messages) if there are no objections and you think some of the questions are good ones I’ll post it as a new thread to give others a chance to get an overview and hopefully help guide this community towards good future discussions.

@Orion Reed have you heard of the Zettelkasten method? https://andreass.gitlab.io/Zettelkasten.html

Tools like zettlr or roam research can help you organise your thoughts into Zettel. Then you can use transclusion to create persistent snapshots that are quite similar to your PDF

I would love to see more tools from the FoC community helping to create personal Zettelkasten and inter Zettelkasten communication Ivan Reese

@Andreas S. yes I have, I use Obsidian extensively (I have about 2,000 notes) but didn’t for this because it was more of a mental process and I didn’t feel there was a good tool for the job. Do you see any key questions or pieces of insight I should pull out of the thread still?

@Orion Reed I like the structure of your PDF. 🙂

@Orion Reed is your Zettelkasten or parts of it public available? Here is an example from a friend from the sense making community- nick redmark, interestingly he uses his public twitter account as a data backend and then tries transclusion/aggregates like this later: https://tweetliner.com/nickredmark/1275500762173341698

(@Andreas S. — Please move this discussion about zettels to DMs, or to a new thread — this thread is about capitalism. Let me know when it's safe to delete your above message and this reply)

I'm a huge podcast fan. Here is comes the deluge 🙂

"https://corecursive.com/" is a good overview of a wide range of "survey of different programming languages" type topics.

"https://oxide.computer/podcast/" by Oxide computer company is amazing if you are interested in hardware at all. Even if you aren't, it's worth listening to for the history. They interview some real giants from the early days of Silicon Valley. Jeff Rothschild for example, as well as Jonathan Blow.

"https://artmusictech.libsyn.com/" - I found out about this podcast from the Miller Puckette episode of FOC. It's centered around an electronic music niche, but there are some fascinating nuggets there.

"https://brainsciencepodcast.com/" - not directly CS or Code related, but if you are interested in AI or Philosophy of Mind, or anything related to how the brain works, this podcast is highly underrated. Dr. Campbell is a medical doctor, and she interviews many top neuroscience researchers. It can get a bit technical with some neuro-science specific jargon, but she always makes an effort to make it understandable to wider audience.

The latest I have tried is, "https://generativeartistry.com/episodes/". I just started this one. It is interesting, but I'm not sure of the substantive content yet.

This episode of 99 Percent Invisible is one of my favourites. It's on the invention of the computer mouse and ideas around simplicity / ease of learning vs. complexity / longer term productivity

https://99percentinvisible.org/episode/of-mice-and-men/

more recommendations (in youtube format): Jonathan Blow's channel and Tools and Craft (https://www.youtube.com/watch?v=3HPriE2a5yc&list=PLzaYMdbJMZW1KYU52yJvYVo-DStoY7UMH)

More about systems design, but definitely related (adding a reference here so it’s all in one place): https://futureofcoding.slack.com/archives/C5T9GPWFL/p1595578576302300

that's a great example Kartik Agaram. Saving that info in a comment looks like a great hack, but also makes me sad not having a nicer way to do it 😢

Your example also made me think of having benchmarks against "branches", as performance could change with upgrades of packages/language or rewrites of other parts of the codebase 🤔

Yeah, performance is a common scenario here, or to be precise how performance interacts with complexity. On many occasions I've seen someone introduce a lot of complexity for performance, but the measurements that drove it are never revisited. Eventually we find that the performance benefits no longer accrue, while the complexity cost continues to be paid.

Ideally we'd be able to constantly track performance benefits of the trunk over alternatives. Using our existing CI system.

I secretly hate that now is so common to run everything in a CI server 😂 , but yep I can see how it can be useful doing performance benchmarks in multiple branches.

This convo has been great Kartik Agaram, I got so many good ideas from it!

No I didn't mean compression tho that was important too. The problem with Unity/Unreal for the web is their based around heavy assets and textures so even simple games end up being 10-20-50meg. Of course someone with experience can design a game around small assets but the default is encourage large bitmapped assets whereas Flash defaulted to vectors and yes, vectors are both small and very compressible

Flash did "stream". It ordered the data in the order of the timeline and would execute frames as soon as they downloaded without having to wait for the entire file to download. If you put a script on one of those early frames it would execute immediately. This made it trivial to have a 8meg file but present the user an interactive experience when only 50k or 100k of that 8meg file had downloaded.

The most common usage was just to display a custom progress bar. You'd put a script on the first frame that just watched the rest the file load and drew some kind of progress bar but there were plenty of flash files that started the first part of their game or gave you a character editing screen or something else while they continued to download the rest of the file.

In any case. The important part is the user not having to wait to start interacting. Compression is important but not sufficient. Just the ability to start before loading everything is also not sufficient IMO. The tools need to make this dead simple. In raw JS and with most JS based engines this is entirely left as an exercise for advanced users only. In Flash it was the norm. The format started as streamed vector graphics without scripting. Scripting was bolted on later but because it started as a streamed format that ability to give the user an interactive experience quickly ended up being built in from the start.

If It's not clear you can almost think of flash as a video format except for vector graphics. The rest was added later. But as an example if you add music to a flash file the music data will be interleaved in each frame for streaming. HTML/JS provides no native way to do this. You'd have to make your own file format and then parse the packets of the file yourself and pass off the audio packets to the WebAudio API via the JavaScriptProcessNode or an AudioWorker. In other words it would be a fairly advanced HTML/JS library whereas in Flash it was built in. This is why embedding WASM as in HTML or even putting assets in a WASM file isn't a solution.

You can read about all this stuff in the docs for the format. From the intro

It is designed to meet the following goals:

• Network delivery—The format can travel over a network with limited and unpredictable bandwidth. The files are compressed to be small and support incremental rendering through streaming....

Streamed audio packets interleaved with the frames are covered around page 181

https://www.adobe.com/content/dam/acom/en/devnet/pdf/swf-file-format-spec.pdf

How much of this stuff is important in 2020 I have no idea. Flash started in the 90s when having a modem was still the most common way to connect. But still, it definitely streamed and designed around getting something to the user as fast as possible.

Thanks for the reference! I wasn't aware that Flash supported streaming in that way. That was very advanced for the time.

The interleaved audio implementation is also very interesting! It's something I hadn't considered.

The important part is the user not having to wait to start interacting.I used the phrase, "time to first interaction". But I think we agree here. :amiga-tick:

In other words it would be a fairly advanced HTML/JS library whereas in Flash it was built in.I agree, that kind of streaming would be fairly complex to emulate, but It is technically possible to with today's technology (at least for desktop). The implementation would probably be a nightmare, but it's technically doable...

How much of this stuff is important in 2020 I have no idea.

The billion dollar question is, is it worth emulating?

To clarify, the reason I'm digging into this so hard is because I'm trying to see what if any useful bits of wisdom are worth taking from Flash as a technology that may have been passed over in modern tech.

Gregg Tavares You have been a really good sport about the whole thing! I appreciate your time and responses.

Thanks for the invite. That was awesome, and quite inspirational.

I always find out about these things at the last minute! Someone here needs to make that great web service that knows my interests and let’s me know about things I want to attend.... ;-)

The course nand2tetris is tough but you learn so much.

Did it. Well up to chapter 5. Wasn’t interested in software stack then https://github.com/opethe1st/Nand2Tetris 🙂🙂

Since you include "things that you have [...] done", which is an interestingly open-ended prompt...

This might seem to some like a joke (and I don't want to derail the topic — if this is something others here would like to discuss, we should spin up a separate thread), but I'm being sincere.

LSD!

It's a crying shame that it is so heavily criminalized, and so taboo, and associated with (frankly) very tacky parts of culture. Taking it was a revelatory experience, and offered me a sort of "everything all at once" frame of mind that I can now tap into whenever I need.

I'd rank it up there with (say) acting in plays and travel, as experiences which are accessible only to very fortunate people, which can offer profound awareness of life and humanity (though do not guarantee it, of course).

I'm sure many of us have seen many of these but don't know who's seen what so I'm going to recommend the 'usual suspects' here.

The most influential things for me are probably Alan Kay's videos and writings (e.g. https://vimeo.com/82301919). They're what really what sparked the search for new perspectives. I also like all of Bret Victor's stuff (e.g. https://vimeo.com/36579366). For other forums I'd recommend looking at LIVE (http://liveprog.org/), PPIG (https://ppig.org/) and the "Salon" track at the <Programming> conference (most recently called Convivial Computing Salon, previously Salon de Refuses: https://2020.programming-conference.org/home/salon-2020, https://www.shift-society.org/salon/)

Ivan Reese I remember a certain Richard Feynman did some experimenting

Shalabh Chaturvedi I really love Alan Kay's talks, but I always finish the talk thinking that he could give some ideas on how to fix the mess we're in (I'm sure he has great ideas on how to fix it), instead of just pointing at all the things that we're doing wrong.

Interesting. I do think he doesn't provide concrete action items but certainly provides direction - both in terms of what kinds of ideas to pursue, what kinds of design attributes to look for, and what kinds of institutions and processes may work. It's true most of this talks are like Kay 101, and mostly intended to 'hook' the audience into 'recognizing the problem'. Some VPRI writings get more into ideas on fixing things - though looks like that part of the site is gone unfortunately.

Kay has mentioned before that he does that on purpose to let people think for themselves. Socratic method and all that

In addition to what's been mentioned (+💯 to Brett Victor's work), I like the writing that comes out of Ink & Switch https://www.inkandswitch.com/

Likewise, Michael Neilson's work is worth checking out.

Daniel Garcia The actionable version of Kay's position has been visible in various VPRI projects for many years! 🙂

Thanks @Jack Rusher, I guess the actionable version is not on any talk and I should dive into the writings and projects of VPRI

I take some inspiration from Christopher Alexander.

The only reason I even heard of Alan Kay and Christopher Alexander though, is through Jim Coplien's assessments of how the software industry has taken their stuff in bad directions:

https://www.infoq.com/presentations/Reflection-OOP-Social/

https://www.infoq.com/interviews/coplien-dci-architecture/

There's also this random gem of interesting videos and articles (which is how I came across Bret Victor):

https://www.ybrikman.com/writing/2014/05/29/must-see-tech-talks-for-every-programmer/

If you are looking for something interesting to watch while you eat or commute, Strange Loop talks are the most consistently high quality in my experience.

To add to the already great collection here, Joe Armstrong’s talk https://youtu.be/lKXe3HUG2l4 is definitely worth checking out (also Strange Loop is a great conference to check out, https://www.youtube.com/channel/UC_QIfHvN9auy2CoOdSfMWDw has some true gems)

I also love Ted Nelson for his passion and refusal to accept the status quo as acceptable or inevitable. I recommend http://hyperland.com/TedCompOneLiners. He also made quite a fun series called https://youtu.be/hZ3gmh-d9oI that I think has a lot of value.

Unrelated to FoC, but I was lucky to do this course while it was free and learned a lot: https://learn.particular.net/courses/adsd-online

Also @James Koppel's online course. And Hillel Wayne's blog (both were on the podcast)

There's an increasing trend of programming playgrounds hooked up to Minecraft. Maybe that's just because the game is so popular, open ended, and scriptable, and because the JVM is fairly accessible.

i’m glad that people keep trying to attack this problem but i’m frustrated that a vowel game with stereoscopic 3d went with a 2d block language! i want a VR game where i hand crabs my function arguments and they scurry off and literally return with my transformed data

Code of conduct - surveillance state how does it fit together?

[moved message, originally by @Andrew F]

That's a deeply unfair question, much like asking a cryptography developer why their code is used to let criminals operate without getting caught. It fits together because the Rust community doesn't have control over everyone who downloads the code, just the interactions in official forums. This is implicit in the concept of an open source project.

More on topic, everyone in this community should be reconciled with the fact that if they are sufficiently successful, their work will eventually be used for evil and they won't be able to stop it. That's what it means to build tools.

To answer his question directly, the Rust CoC is to make explicit how you are expected to behave as part of the community developing rustc.

It has essentially nothing to do with how people use rustc.

A CoC offers protection to those on the losing end of power imbalances. Communities with a good CoC have in them a recognition of such power dynamics, since that's what the CoC would have emerged from. Surveillance is a tool that reinforces and entrenches similar power imbalances in the broader public sphere — so it'd make sense for the folks who write these CoCs, who have this sensitivity to power, to want to do what they can to protest surveillance. To me, the tweet makes perfect sense and I completely see the connection.

The question becomes, what can those CoC-authoring, power-levelling folks do about the problem of their work being coopted for https://futureofcoding.slack.com/archives/C5T9GPWFL/p1595686084036400?

That might seem like an irrelevant matter. If so, you probably first need to decide how you feel about power imbalances in general.

It might seem like an intractable problem. Well, computing cultures through history are full of people making great efforts, some more successful than others, to address these exact sorts of issues. Decentralization, copyleft, FOSS, ubiquitous CoCs, the startup model, torrenting, tor, hacking, C3, the list goes on and on. I think it's totally within the realm of possibility that if a community like Rust wanted to take a stand against surveillance, or the military-industrial complex, folks within that community (or adjacent to it, or intersecting with it) might birth such a movement that produces a new counterculture.

I'm super interested in the idea of programmable documents and think this concept is great! I find this horizontal / vertical tree layout very interesting - it's a bit like microsoft publisher and css flexbox had a baby.

However, I'm curious what benefits having the layout structured as a tree has over placing elements on the page wherever one chooses? Is it an unnecessary constraint?

I also agree with the premise that the best horizontal apps like excel and trello are simple data structures made of atomic units - simple but flexible enough to fit almost any use case. That's the direction I'm heading towards with my personal work and would be interested to hear other thoughts around that idea.

• i think i’ve saved the link to dango four different times on at least two platforms (here and twitter for sure). it’s so cool
• my main thought on the atomic data stuff is that the common feature of the successful horizontal apps is actually a UX that makes using the data structures in flexible ways discoverable to a user. usually starting with one thing (lists in the cases of excel and trello) that gets extended, usually by enabling filtering and transformation of those simple data structures

Ryan King At the time I couldn't imagine a good way to add absolute/relative positioning with the structure I designed, and didn't think it was that important compared to the structured layout. Now I think that both are important. https://www.figma.com/blog/announcing-auto-layout/ shows how the two can coexist and play different roles depending on context.

yoshiki that makes sense. Thanks for the insight!

On a related one, one of the things I recently thought about was how would programming look like the input mechanism was a pen. Would that have a greater affordance for visual programming for example?

As a pen is great at drawing things, when programming can benefit from a drawing input device? Maybe one can imagine a visual language that accepts fuzzy drawing of programming artifacts, when "drawn" characteristics (size, shape...) can be part of the language? Bonus: a program can be on paper sheet or whiteboard, scanned and executed.

Yeah, actually someone shared a video of this in the group earlier, a prototype from xerox I think (so not entirely my original idea). I will look for it

I am struggling with this feature for the visual programming tool that I am building , there's already some touch support but not 100% as great as the mouse support. But the small screen is the biggest challenge. What I want to try is to have a collapsable tree instead of the nodes with arrows on a small screen. The challenge there is pieces of flow that represent a loop or a node that is connected to from multiple nodes. I would love to be able to do some programming work on my mobile

The shade app (https://shade.to/) that was shared on the #graphics channel looks awesome, but on mobile the small screen is an issue I think

Found it by checking my YouTube history instead https://www.youtube.com/watch?v=QQhVQ1UG6aM

Ivan Sutherland's https://en.wikipedia.org/wiki/Sketchpad is the classic "programming with a pen" example.

In an earlier thread someone linked the metamuse podcast and in the first episode they talk about some stylus interfaces they've been experimenting with and how input compares to the desktop. We're still in the early days of touch interfaces and they're ripe for innovation!

https://www.listennotes.com/podcasts/metamuse/1-tool-switching-GYobjearH3_/

To make the small screen work, you probably want a ZUI for browsing the code. For touch/pen, I think the end state is a rich (i.e. with steep learning curve) gesture language for control structures, et al, otherwise you're wasting a lot of the potential bandwidth of touch. For identifiers (variables, library functions), maybe select from a menu of things in scope? Btw, radial menus are criminally underused IMO. :)

Relating more directly to drawn visual languages, here's an example of a graphical human conlang: https://s.ai/nlws/ (I think someone posted it here not too long ago, so you may have seen it already (: ). Along other things, it features (essentially) higher-order glyphs, which I think would be important for a drawn programming language.

I think voice input is also still quite underutilized. I think it makes sense to augment the UI with voice commands too, so not exclusively audio commands. I gather the speed of interacting with an app would be greatly increased, while still having a small surface audio language that could be easily deciphered by the app.

+1 for that a ZUI is needed. And a good one that can really change program artifacts representation based on zoom level.

Anyone know of any modern equivalents of Microsoft's Code Canvas? https://www.microsoft.com/en-us/research/project/code-canvas/

It's not particularly innovative when considering touch and stylus as an interface, or even exploring the possibilities of a visual system - but I see it as a incremental and practical step in moving from a fully-featured document based coding system to fully-featured canvas based coding system.

@Ionuț G. Stan I found https://serenade.ai recently, and it looks really cool

Daniel Garcia oh, never heard of it! Thanks for the pointer, I'll investigate 👀

since we are talking about alternative computer interaction and VR, I am excited about eye tracking. Eye tracking is getting a lot of development because of VR, but I thinking it's an underrated interaction paradigm on it's own.

Here is a simple example:

I have two monitors set up while coding. On one monitor I have my code editor, and the other monitor has some reference. This is all fairly standard.

I can't tell you how many times I wanted to scroll or do some operation on the reference monitor, but the text editor was set to the active application, so I accidentally scrolled the code instead of the reference, loosing my place. Harmless, but quite annoying, especially in a complicated code base.

If I had eye tracking, the interface could detect what I was looking at, and keep the correct window active.

This is a pedestrian example, but I think there is a lot of powerful UX that could be enabled through decent eye tracking.

I wanted to buy an eye tracking device from https://theeyetribe.com/theeyetribe.com/about/index.html some time ago, I'm not sure if they are still selling them.

I have imagined interacting with computers only with eye tracking and BCI's (Brain Computer Interface)!!

Looks like they were bought and absorbed by Facebook and Oculus

https://en.wikipedia.org/wiki/The_Eye_Tribe

BCI is cool but also scary. What’s to say the input would be one way? 😬😬😬😬😬😬

https://en.wikipedia.org/wiki/Transcranial_magnetic_stimulation is indeed scary

@Ionuț G. Stan Strong agree! In my early experiments with building gestural interfaces I quickly found that gesture + voice was way more effective than either alone.

Alternatively, I would love a “physical” programming language that you could arrange with your hands in VR. Something like Wiremod for Garry’s Mod with haptic feedback.

It seems like an interesting idea, but I worry that it would be too much at once? I kinda stopped using two monitors recently because of that. But a documentation screen and a code screen seems like a good idea

I've wondered what this will be like; I have a text editor that could in theory render inside a 3D world easily enough; and I'd like to try having it be wrapped around the viewer, etc. The interesting part is the input. For me that would probably be fine, since I'm a touch typist and like to use Keystrokes/vim for navigation; but I'm not sure how anyone would cope without those things. I'm also not sure how tiring it would be ; I imagine being locked in a world like that would be become quite draining if you did it for the usual amount of hours.... The text editing isn't the only problem of course; you'd need debugger, etc; and presumably the application you were working on would have to present itself inside VR.

I've spent quite a while thinking about live coding inside such a thing. I posted a link to Media Molecule's Dreams VR. I don't know how they handle such things; I haven't watched it all yet.

Eventhough just placing many screens in VR isn't really pushing the medium in very interesting way, I think I would find it incredibly useful. In much the same way an architect / graphic design can scatter their drawings across the table and pin the to the wall, and they can reference all that at once while creating something new. In contrast a software developer would be typically limited to the equivalent 1-3 pieces of paper.

VR could be the more affordable version of Bret Victor's Seeing Spaces https://vimeo.com/97903574

I've seen a couple of (very) primitive prototypes. I'd go with something like PS' Dreams. And if you could interact with something physical a la B. Victor, that would be just Star Trek stuff. In general, I think it would be incredibly useful for all the reasons mentioned; our visual bandwidth is much higher than our little screens provide. My biggest prejudgement is the physical ergonomics of user interaction. The same way touch screens across keyboards are only marginally useful.

I feel like the work being done at https://dynamicland.org/ (which is for good reasons is focused on not locking us into isolated islands) could actually be quite compatible with VR.

I definitely dream about it, being able to dynamically switch from 2D screens, 3D, spacial, even tactile modes of interaction with code or operating systems.

Having lots of text in VR is rough because the current gen hardware does not have enough pixel density, the words need to be enormous to be readable. But a physical-metaphor UI could be awesome.

That's a good point; I work on a 4K screen these days, and wouldn't want to go back!

Alternatively, I would love a “physical” programming language that you could arrange with your hands in VR. Something like Wiremod for Garry’s Mod with haptic feedback.Vi Hart has worked on that, some objects in virtual reality that you arrange to create programs. I can't find the the article about this specifically (anyone?), but found this other one that talk about it in the beginning (first image in the introduction):

https://theartofresearch.org/combination-physical-and-virtual-tools-for-spatial-computation/

And this article talks also about nice AR programming stuff! 🙂

The current attempts I'm aware of are safespaces: https://www.youtube.com/watch?v=Js7Y1H5D8cY and xrdesktop: https://www.youtube.com/watch?v=RXQnWJpMLn4

Of course, these just kind of extend the traditional desktop metaphor, but you can already do some pretty neat stuff, for example, natural workspaces. I was watching a livestream by one of the devs working on wayland vr, drew devault, and he just casually puts background stuff like music players and chat clients to the side, vaugely in peripheral vision, and then turns his head when he wants to see them.

(Here is the stream in question, if anyone is interested (vim in vr!): https://spacepub.space/videos/watch/691f2bc1-d4bf-4051-a035-035388a059b0)

https://futureofcoding.slack.com/archives/C5T9GPWFL/p1596071465341800?thread_ts=1596005605.232600&channel=C5T9GPWFL&message_ts=1596071465.341800

The moment a company releases a wireless AR/VR device that doesn't give you eyestrain when you're trying to look at small glyphs at close distances, I'll definitely be using it. We need varifocal devices with a pixel density equivalent to at least that of a 1080p monitor at typical viewing distances.

But my ideal device is a pair of AR glasses complemented by an input device that allows me to work from anywhere (standing, sitting, indoors, outdoors...). I'd love to not be desk-bound whilst I work.

Until then, I've stopped caring about the AR/VR space. The hardware just isn't good enough.

Now is love to see some good sense making tools like Argument maps applied to this whole discussion such that we can have a meta discussion of were are discussing in posi to be ways or just talking past each other.

I’m deeply interested in the motivation - misunderstanding of what S. Diehl articulates here. This is the fundamental discussion we just had here a few days ago. there approaching from the surveillance capitalism tangent —- again where are “our” future of coding tools to show which members ant which month over the years had which opinions. Which books / materials where recommended ? Where other habits changed? How do measure meaningful impact?

Here is a reply from Charles H. https://www.youtube.com/watch?v=dHo_EUyShOg

It seems if we cannot even talk to each other then we are in really big trouble...

I will try to explain what I agree /disagree with regarding Stevens critique or perspective. As a general perspective I really like the conceptual overview of Yuval Noah harari - sapiens https://www.goodreads.com/book/show/23692271-sapiens from which I borrow from the chapter - the unification of mankind -three orders: 1. Empire 2. Religious order 3. Money. Now it’s really interesting how money and coinage was linked to empire (faking coins would harshly be punished as crime against the crown) so from the beginning there is a interesting interplay between monopolies of power and aspects of collaboration. Now lately there have been people explaining crypto currencies as a kind of printing press technology which means it posses the potential of democratising access to currencies. I think in the capitalism thread we had arguments stating that culture is largely an emergent phenomenon. As such our “current” state of civilisation is , well , our best effort and a aggregation of all that had come before. Even now for a single person to perceive the culture of science is quite a difficult adventure. (Though I would it really recommend it to Steven diehl- but I think he somehow likes to remain in the doing science space rather then introspecting science space ) So as a technology for potential impact on culture crypto currencies have huge potential to be used for actual a better and more positive live. And it this that I miss from Stevens criticism. That he acknowledges that crypto could have positive impact. I agree with him that “non-productive” assets are a failure of the economic system. I also agree with him that most crypto projects are sadly located near that realm.

Now as crypto is a technology so is Haskell or other programming / software systems. And it now seems that we?(who is we here? Who is we in Stevens post?) want to think about ethical impacts of technology on society and culture.

How do we create meaningful practices to steal the culture ?

https://m.youtube.com/watch?v=Q9AZZI6PPRQ

The rabbit hole for anyone interested:

https://www.reddit.com/r/haskell/comments/i0uufb/the_haskell_elephant_in_the_room_response_from/

https://www.reddit.com/r/haskell/comments/i0m6n5/the_haskell_elephant_in_the_room/

My perception here is that discussion around the current apps and services that typically call themselves personal knowledge management tools aren’t really the center of interest here. I think many are looking at the fields and work from knowledge representation, expert systems, intelligence augmentation, logical reasoning, complex systems, networks, and others and seeing their immense potential and importance for the future of coding. Knowledge representation has a long history going as far back as mathematics itself. We really haven’t scratched the surface in terms of the actual tools available, but can see that the wealth of possibilities in that area is almost unlimited.

I was going to start a discussion on this exact topic this week, wondering how people feel about patterns of tools of thought / PKM being shared here since they seem to have so much overlap with FoC notions - visual layouts, open data structures (enables things like transclusion), chaining behaviors, storage models, more -

I've seen many of the people on this forum also post on PKM on twitter, so I'm sure there's latent interest.

It feels borderline as a full community discussion - this thread alone might get relocated over to #random - but I wonder if there should be a #thought-tools or #knowledge-management channel so we can freely explore frontiers of knowledge tools & concepts that aren't necessarily coding-based. cc Ivan Reese

i think that a lot of the cognitive load of programming comes from bad ux on the information management side of how we interact with codebases—and most of what i’d like to do with computers could be achieved with a “sufficiently smart” PKM, eg “show me all the websites i’ve visited when looking for an ice cream maker organized by review score and favorite reviews”

I agree with @Orion Reed that there's considerable overlap between these tools and what we're all trying to do. For example, there are certain kinds of questions that are hard to answer with most programming environments that become quiet easy if the data is handled differently. For example, queries by analogy or complex integrative queries as seen here (using my https://github.com/jackrusher/mundaneum):

It's not hard to imagine how these sorts of things might be integrated more deeply into a programming environment (they are so integrated with Wolfram Alpha, for example).

Tools for thought is the single greatest shared area of interest according to https://futureofcoding.org/episodes/046#question-thirteen-what-foc-topics-interest-you-most earlier this year, so I wouldn't regard it as borderline. I do think there's getting to be enough discussion about it that it might be worth trying a #tools-for-thought channel — not because it isn't on-topic enough for #general (or whatever we https://futureofcoding.slack.com/archives/CEXED56UR/p1595571837137000), but because it's worth collecting all that knowledge and enthusiasm together in one place.

Gerry Sussman makes the case that the legacy of computer is that as a medium for clearer thinking which is what we want from tools for thought

https://futureofcoding.slack.com/archives/C5T9GPWFL/p1593862391299700?thread_ts=1593794600.262800&channel=C5T9GPWFL&message_ts=1593862391.299700

👍 for #tools-for-thought channel, that seems like a great idea

Ivan Reese Tools for thought is such a profound idea I just gotta give a shoutout to the term mediums of/for thought.

Alan Kay argued that “the term ‘tool’ implies a certain narrowness. A more powerful aim is to develop a new medium for thought.” and I believe Bret Victor seems to also use medium as the more denotational term. Another used by Alan, Bret, and others is new representations.

I feel like ‘representations’ are the concrete language of the medium, ‘tools’ are like applied representations (i.e. Illustrator is kinda like an applied but restricted tool for bezier curves and vector geometry with extra bits). The idea of a medium being computational and dynamic seems to demand a higher bar when evaluating future projects.

I think you can argue that Illustrator is a tool for thought more easily than a medium for thought, as the medium would map to the domain-space of vector geometry itself.

Not suggesting a name change, just a thought worth mentioning.

@Orion Reed That's a very enticing framing. I'll fold that in to my proposal.

My own project (https://github.com/khinsen/leibniz) in the FoC space (where I take the c to mean computing rather than coding) is all about integrating formal and informal knowledge. For now I am at the single page document stage, but I am aiming at putting formal code into digital gardens.

So I just listened to a podcast where their CEO featured and they are actually going to open source it (or already have because I found the github repo)

https://www.software-engineering-unlocked.com/episode-15-successful-dev-tooling-peter-pezaris/

Did this thread reach anyone's conclusion? 😊

It gave me stuff to think about at least!

Although Alan Kay doesn't admit this, I think OOP stopped being about message-passing when they changed Smalltalk from asynchronous to synchronous. This happened between Smalltalk '74 and '76 I believe.

I agree with you, I think the best way that I avoided that narrowness was by seeing talks and reading about the bigger picture examples. Not current apps, but alphabets, algebra, calculus, geometry, etc.

There was a talk posted recently, Legacy of Computing that compellingly covered some historical examples, and Bret Victor, Alan Kay and others have covered many examples too. I’d love to put together a collection of these examples as a way to more properly introduce people to the idea.

@Nick Smith do you have any links on asynchronous Smalltalk? Sounds tantalizing.

Was reading the summary of this book and it’s really good - https://commoncog.com/blog/teaching-tech-together/

And @Ray Imber I think you were the first to intro me to the common place blog with the link you posted in the thread above. Really really good blog. Thanks!

“A comprehensive political and design theory of planetary-scale computation proposing that The Stack—an accidental megastructure—is both a technological apparatus and a model for a new geopolitical architecture.”

It does get technical too (there are chapters on IpV6, addressing, architectures, etc)

From the foreword, introducing the field of software studies:

“Software is deeply woven into contemporary life—economically, culturally, creatively, politically—in manners both obvious and nearly invisible. Yet while much is written about how software is used, and the activities that it supports and shapes, thinking about software itself has remained largely technical for much of its history. Increasingly, however, artists, scientists, engineers, hackers, designers, and scholars in the humanities and social sciences are finding that for the questions they face, and the things they need to build, an expanded understanding of software is necessary. For such understanding they can call upon a strand of texts in the history of computing and new media, they can take part in the rich implicit culture of software, and they also can take part in the development of an “emerging, fundamentally transdisciplinary, computational literacy. These provide the foundation for software studies.”

This looks fascinating, thank you for sharing!!!!

Yeah this looks crazy, definitely need to read it when I get a chance

Does it say anything about how category theory is relevant to real life / software engineering?

"how can we swing back to a more remix-friendly environment? What creates incentives for that?"

errr... pay developers to use a remix-friendly style?

Open standards and open source are approaches that (at least to a greater extent than proprietary products) are remix-friendly. Beyond that, we need people to work on platforms designed from the ground up for 'remixing'. But rarely is any private company willing to pay for that sort of thing. The idea I've always had in mind is government funding for "open engineering", the same way science is funded, except that the work products would be FOSS instead of PDFs.

To make sure the work products are labors of love ... people working on them should be underpaid, but on the other hand the barrier to entry should be as low as the pay scale. I'd sign up immediately.

I like how your comment talks about government funding but emphasizes underpaying people. That connection needs to be drawn more often.

The main GPT-3 is said to have cost $5 million (in electricity?) to train, so don't expect you'd be able to do what OpenAI did with it, even if it were open-source.

I think you're too focused on metrics. Feedback channels in this universe work too imprecisely for this level of focus. For all our society's emphasis on being data-driven, there often isn't good enough data. In this case, HN behavior is often highly dependent on the first 2 or 3 votes a story gets. If they come quickly it has more time to rise. Selection bias on who happens to be browsing the new page at any time compounds the noisiness of this signal.

You should just write about what you think is important. You may be surprised by how this sed posting does when somebody submits it to HN in 6 months time.

Sounds like I need more data to have a meaningful conclusion, and in the absence of said data, I completely agree, what I think is important (and like) takes priority

(i agree with kartik, but) i think the biggest issue from a marketing perspective is that jq has some mindshare with motivations already. it would be helpful if this article started with some info about why i should care about send when i have more modern text transformation tools available

sent it to my partner who spends a lot of time in awk and she was excited to read it… but she’ll never ever be a HN reader 🙂

I dream of making a language in the last category, where

• The syntax is switchable (plug in a parser you want), syntax conversions are plausible, and multiple syntaxes can be used in a single proram
• The semantics are customizable (e.g. the concept of a "function call" is broken down into parts that can be customized) and multiple semantics can be combined in a single program...
• The language is designed to support and encourage "parameterized" libraries, whose exact behavior and interface can be customized by a user of the library (e.g. libraries that let you select between different kinds of floating-point math after-the-fact, instead of hard-coding float or double)
• The standard library is designed to evolve over time by supporting "skinnable" types. A simple example would be that in version 1.0 we have Array.shift and Array.unshift , but in a later version we decide those were terrible names and change them to Array.popFirst and Array.pushFirst
  • but old code can use the old names by continuing to import the older "skin" of the Array type.
• Advanced metaprogramming including compile-time code execution is supported

I want a language that takes the best ideas around and combines them with my own ideas ... an ultimate language. The really key part, which is maybe the hardest thing to get right, is to set it up so that some of the best features of the language can be designed and built by other people, because the foundation is good enough to make this possible.

It was an interesting article partly because it taught me about encrypted virtualization, where a hosting provider can guarantee to customers that they can't peek inside their VMs: https://arstechnica.com/gadgets/2019/08/a-detailed-look-at-amds-new-epyc-rome-7nm-server-cpus/2

oh lord

Oh it's all good.

The "I didn't read the article" hot takes have become gradually more positive. IIRC the first time this thing showed up on HN the result was mostly a confused shrug.

Also, if anyone does read the comments, please consider upvoting my reply which adds links to our other work. Thanks.

caveat: to me they seem getting re-invented given my currently shallow literature e.g.

• clojure's transducers => contortions to express CPS using anonymous functions
• monads => reinvention of CPS
• effect handlers => constrained CPS?

https://en.wikipedia.org/wiki/Delimited_continuation

I think it's a little bit like the koan of objects vs closures: http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg03277.html

maybe this is useful to you: http://wingolog.org/archives/2015/07/27/cps-soup

and http://mlton.org/pipermail/mlton/2003-January/023054.html

👍 thanks, reading them now

is there modern "consensus" on what the RightWay™ is today? or phrased another way from my limited pov:

• continuations => bad and hard to reason about ~= goto
• delimited continuations => better, more expressive ~= jump but still unpleasant to reason about/still forced to play human compiler
• effect handlers => human usable, layman grokkable within 10 mins without esoteric knowledge about type theory/categories/monads/etc, so the RightWay™?

context: 3 days old exposure to effect handlers are from http://mikeinnes.github.io/2020/06/12/transducers.html

followed by https://speakerdeck.com/paperswelove/brandon-bloom-on-programming-with-algebraic-effects-and-handlers-by-andrej-bauer-and-matija-pretnar