Aleks Litynski when it comes to human-scale automatic things (like layout), the computational complexity is never as hard as the finesse of finding the aesthetically right thing to optimize.

Aleks Litynski to add to William Taysom’s point, id also love to see a more dynamic approach to node and wire diagrams: why not float the original declaration of z next to ref z when you’re hovering the cursor over it, for example. i think node and wire works great for getting started, but i’m often disappointed by tools that use it but go no further with affordances and basically recreate an architecture diagram on a dead (even if zoomable, pannable, infinite) whiteboard

Been meaning to start with this soon. Did you start reading?

I have just started. Really nice. If you want we can discuss here. Also anyone who is interested.

Man, I already have a hundred things on my desktop that I really, really want to read.

Same to me. I have an Acrobat reader open with more than 20 tabs (all are really great reads, e.g. The Quark and the Jaguar by Murry Gell-Mann... 😑 )

Seeing this surface here has reminded me to mention my favorite "what if the shell was also an editor and the mouse was quite powerful" system, Acme. https://www.youtube.com/watch?v=dP1xVpMPn8M

love acme! yet another project that i wish there was more beginner-friendly documentation on

I would 1000% be streaming Hest development, but I have 1mbps upload bandwidth where I live. 😭

I'm still thinking about my "periodic solipsistic science fair" idea:

https://futureofcoding.slack.com/archives/C5T9GPWFL/p1592374703359400?thread_ts=1592330980.344100&cid=C5T9GPWFL

I plan to once things get a bit further along 🙂

I’ve never streamed on twitch. How does it even work? I’m sooo slow at coding I would probably give everyone a headache though LOL

Would be interesting to compare programming styles. I was debugging in front of my teammates last year and painfully self conscious of how slow I was. I kept asking them if they had some alternative approach to my printing log statements. But they didn't, and a year later we all use prints and the codebase has a decent amount of debug logging infrastructure.

Yep console.log still rules my world

There are coding streams.. and then there's XRA, who is working on the game Memory of a Broken Dimension. Instead of a webcam in the lower left corner, he had the pointcloud data of his face from a Microsoft Kinect rendered B&W with a slowly orbiting camera. When he needs to step away from the computer, he runs a generative video experiment of mutated VHS footage as an interstitial. His game looks like ghosts coming out of TV static. He plays music that would fit right in with (and is often made by) the people behind musicforprogramming. His streams are both a thing you can watch with full attention, and something to put on in the background while you work to feel like you're in the most Lynchian/Gibsonian coworking space. He's put a lot of thought and effort into the look and feel of his streams, his game, etc.

He also codes slowly, and mostly does print debugging, and struggles with dumb bugs. I think that's just... programming, today.

as someone working on a variety of extensions at this very moment i’d love to see more work in this area! i’ve trawled through quite a few githubs and found basically nothing that clicked with me

if you’re working on an extension yourself we should collaborate if you want! feel free to DM me

And now I miss Steve. 😢

This full interview is fantastic.

Here's the "free" version on YouTube.

Here's the version that requires giving YouTube money but likely doesn't have gradually shifting audio volume.

Another favourite from the same era, if you like hearing Steve Jobs peel back the curtain, is this video from WWDC '97 where he just.. sat down on stage and took questions from the (all-developer) audience about his plans for Apple's future. This came right after he returned to Apple, right as they were pulling back from losing a billion a quarter under the previous management, but before the iMac. Highlights include the justification for killing OpenDoc, and a rough sketch that Apple would move toward things like the iPod and iPhone.

somehow I disagree or at least want to emphasize a different perspective. I don't have a problem with jobs statement that there is a difference between an idea and the tangible implementation of an idea. But if you look at the conception of "personal computing" from J. C. R. Licklider's idea of a Dream machine to Xerox Parc to Apple and Microsoft. There are a couple of things that went "wrong". Is a company "body" like apple the best way in which people can communicate the gift of computation to other people (https://blog.anylist.com/2020/06/sign-in-with-apple/ ) ?

I think we need to think much more about the relationship between technology and society. Instead of selfcentered thinking in terms of: how can WE build better PRODUCTs

changing the computing narrative from WE(programmers) vs rest(society- the other) to more inclusive and much more deep thinking patterns seems imperative to me

My intuition always keeps reminding me of the first Chapter of Seymour Paperts - Mindstorms: Computers and Computer Cultures. And also why Dynamicland is conceived as a communal Computer, I think these are very interesting and import perspectives.

I am not trying to gloss over the many flaws in Jobs' personality. He was pretty difficult to work with, and the late Larry Tesler once told me that he was the worst boss he ever worked for. You can tell when you are in a dictatorship because there is no visible #2 waiting in the wings. And the cadre of VPs and lawyers underneath him at Apple were litigious and quite vindictive. But putting aside his personal foibles, the man was passionate about quality and tried to make things easier for the customer and he also created a publishing system with the iPhone App Store, that is the largest employer of independent programmers in the world. Nobody has ever been nicer to indie developers than Apple. When Jobs started the App store, at the time the only indie friendly publishing outlet was the Amazon Kindle bookstore, which paid a 30% royalty. After jobs launched his store paying 70%, Amazon had to backpedal and match that royalty rate. The prior CDROM industry of which i was a big participant in was destroyed by software piracy, and it is impossible for a small developer to handle distribution in over 100 countries, but that is what you get with Apple. A deposit in the bank every month with no funny business, with all the currency conversions done for you. The App store sells more software than the entire US paper publishing industry by my estimates. Apple is fairly tyrannical, and will steal ideas for their products gladly, as they live inside a hermetically sealed spaceship, and never see the outside world. So i am not some starry eyed sycophant. But let's acknowledge the great opportunities Apple is giving to independents to earn an honest living. In the famous play "Major Barbara" by GB Shaw, he has some great essays on how letting people earn an honest living is very good thing.

Just a last story on this point. I think that the sad story of Ted nelson and also Doug Engelbart, that they are indeed sad stories exactly because the "programming" culture does not make room for habits and thought oudside of the programming culture.

"Apple is giving to independents to earn an honest living." I think this is far too shortsighted.

There are so many flaws and problems with todays company-brand - culture that I can't enumerate them all. Even weaving them into a coherent story is difficult - which enabled it to grow to such an excessive extent in the first place

There where already some attempts towards a better relationship between computing culture and society - Efforts like postmarket OS . But if you are at the top of a mountain its really difficult to go back down and examine the foundation for aspects like sustainability. Open source is a important aspect of revisiting the foundations but its not enough .

I think the idea of permacomputing is going in a interesting direction http://viznut.fi/texts-en/permacomputing.html

Thanks for the quote! From my perspective, of engineer who has been in the world of startups and building products for some time now, the point I get from the quote is that when you start with an idea, you should be prepared for what comes next, and that is the idea changing a lot as you learn more about whatever you are working on. And while a lot of people have ideas, surviving through that process of change is much harder, and requires a lot of persistence and conviction to come through, if it is even possible. Personally I enjoy hearing about how others navigated this process, as I am always trying to learn more about it and to be better at it.

Jobs was a complex person, and many just criticisms have been written about him.

OTOH, talking to him around this time it was clear that he had a better vision for what computers should be (and do for their users) than anyone else running a large tech company.

While he gets too much credit for "inventing" the everything Apple did, he gets too little credit for being the "Chief Q/A Officer" -- essentially the spoiled user throwing tantrums until the experience was good enough. His absence is obvious in many small, annoying details of later product developments.

Per the conception of Apple as primarily about craftsmanship, there is of course the concept of Sherlocking (https://en.wikipedia.org/wiki/Sherlock_(software)#Sherlocked_as_a_term): A term used when Apple copies an existing product and bundles it into one of their other offerings (thus "sherlocking" the original product). Some notable examples: (The eponymous) Watson -> Sherlock, Konfabulator -> Dashboard, LaunchBar -> Spotlight, Growl -> Notification Center. Then of course, there are the foundational elements of the OS UI itself: Xerox Parc -> Mac Desktop, Jeff Han's Multi-Touch Work -> iPhone.

Generally, what Apple excels at is taking an existing good idea, and polishing and popularizing it, which is commendable (although I wish they were better about giving credit to their sources). I actually only really think of Exposé as an innovative UI feature that (as far as I know) originated inside Apple. I'd love to hear if anyone has some other good examples?

Cover flow, the column browser (perhaps), the magnetic timeline in FCP/iMovie, the gestural UI of iPhone X (not every aspect, but many of them and their unification), the genie effect, inertial scrolling (arguably — I know), proxy icons in Get Info and window title bars, the iPod click wheel, Siri, direction-based cursor movement to submenus, the cursor shapes on iPad, HyperCard stacks / edit-mode, dragging disks to the trash to eject them & round mice (who said they had to be good), Desk Accessories, (AFAIK) hiding power-user features behind option-click

(Cover Flow was created by a third-party developer, and was purchased by Apple https://en.wikipedia.org/wiki/Cover_Flow)

From my perspective, most of the items on that list I'd categorize as iterative improvements to existing earlier ideas, e.g., refining menu movement and cursor hover states, adding to the implications of draggable icons. But this definitely brings up a problem I have: How do you differentiate between innovation and iterative improvements? Maybe there's not even a difference?

History of the column browser: Mark Miller 1980 -> NeXT -> MacOS X. A more detailed history here: https://en.wikipedia.org/wiki/Miller_columns

How do you differentiate between innovation and iterative improvements? Maybe there's not even a difference? There is definitely a difference. You can innovate by exploring new design alternatives that are the opposite of what the mainstream is doing. If you make a series of these contrary design choices, you'll find yourself exploring a part of the design space where no one else is looking. It's not guaranteed that what you'll find is an improvement, but it's how real progress is made. We and our ancestor species spent maybe a million years doing iterative improvement on stone knives, and at the end... we had really good stone knives. It was the innovators who discovered metal forging.

If we looked at the history of metal forging, we'd probably also see a series of incremental improvements on incremental improvements, leading back to before even the first time metal was hammered or smelted. And there would have been the people saying "let's take existing object X and make it out of metal", or maybe "what other materials can we make knives out of?", which is how you'd arrive at metal knives — the confluence of separate incremental ancestries.

I personally believe that the terms innovation and invention are used in situations where people are not seeing (or sharing) the true context within which an invention was merely an increment. In other words, innovation is largely an act of recontextualization.

There are two important modes at work in invention/innovation, both of which require considerable creativity.

The first, which typically happens in places shielded from commerce (e.g. universities, personal projects, rare industrial labs like Bell and Xerox), is a kind of mad-eyed push into the unknown that produces novelties.

The second is a process whereby people with good taste curate and refine those novelties, ultimately turning them into products.

I think of these two activities as a cultural analogy to seeding and harvesting. We need support for both of these modes to get the good stuff into general use.

When looked at from this perspective, Apple was one of the best harvesters we've ever seen in consumer technology.

(Aside: there's been an ideological shift since the 80s that attributes all value creation to harvesting, which in turn has led to a tremendous reduction in funding for seeders. This is my guess as to why we're still using 40 year old technology today.)

This document has silly pronouncements like "General-purpose communication platforms would not have entertainment as a design priority".

Sorry but Netflix is more than 25% of the entire internet and when you add all the streaming video guys together it is probably half the entire internet, and over time, will likely grow to 75%. If the internet had been designed with entertainment in mind, it would have been a lot more efficient to push video around. They didn't think about it much, and as a result we have a very wasteful system. Of course our communication systems should have as a design priority entertainment, because that is what people are using them for. And it's none of our business to tell people what to do with their time. That is their free choice, and TikTok is evidently the answer for kids below 12 who are on that service for 80 minutes a day average.

The energy expended on stupid bitcoin proof of work is the biggest waste of energy on the planet, and just getting rid of that ridiculous thing would help. Proving your worthiness by wasting energy computing nonsense values has to be the dumbest thing ever to catch on in a big way. Later generations will wonder what we were thinking. It was already more energy than all of Ireland 2 years ago, who knows what it is now.

Also, if we could crack the dumb monopoly that Google and the other browser companies have on only allowing JS in the browser, and let us use more efficient technologies, we could compile ahead of time our code, and not download massive tens of gigabytes to do a signon screen, that takes 100MB of RAM to run.

I can think of gigantic puddles of inefficiency in our current systems that should be addressed. We all should tread lightly on the earth, and leave it in a better condition than when we started. Computing is saving physical movement to a massive degree, but we can be a lot better.

"Sorry but Netflix is more than 25% of the entire internet and when you add all the streaming video guys together it is probably half the entire internet, and over time, will likely grow to 75%" I think this hints towards timewellspent by tristan Harris - https://www.youtube.com/watch?v=ES6bJgUETT8 https://humanetech.com/

recently someone asked me if "Blockchain" is used in any way and while I can not say much about Bitcoin I answered this:

So you are basically asking if there is any (valid) use case of blockchain technology. It is not easy question. Many subtle issues playing a role... Blockchains represent a digital global consistent creation. The digital seems to human nature as something almost impossible to sense. Something very fluent , ethereal. So this global consistence gives people a more tangible handle for digital technology If we zoom out a bit further we can acknowledge that technology always simply reflects on people and society. And blockchain enables for very interesting experiments regarding either transparency or privacy.

So bitcoin maybe very very energy inefficient but it runs in my opinion very necessary experiments for society. Does this somehow sounds reasonable to you?

"Also, if we could crack the dumb monopoly that Google and the other browser companies have on only allowing JS in the browser, and let us use more efficient technologies, we could compile ahead of time our code, and not download massive tens of gigabytes to do a signon screen, that takes 100MB of RAM to run." I fully agree with you here - the web is a mess and hardware as software monopolies created a really strange reality that we find us in.

Thank you for sharing, Andreas! Very interesting read and way of seeing things. In particular: > Programmability is the core of computing and the essence of computer literacy. Therefore, users must not be deliberately distanced from it. Instead, computer systems and user cultures should make programming as relevant, useful and accessible as possible. I agree that if the users are not distanced from programming, they can have an impact on the efficiency, because they won't be forced to use huge complex programs for simple needs.

I also like how he distinguishes softwares based on how they help: > There are many kinds of software, and very few principles apply to all of them. Some programs are like handheld tools, some programs are like intelligent problem-solvers, some programs are like gears in an engine, and some programs are nothing like any of those.

An based on an actual computing need what to use? Say you need to compute 42 times 50, you can: • compute it in your head • use a pen and a paper • use an abacus • use a slide rule • use a calculator • use a dumb phone • use a smart phone • use a computer with the calculator from the OS • use Excel • open a web browser, open the dev tools and use the JS console • open a web browser, and type "42 * 5" in Google Search

Edward de Jong FYI work is being done on sending JS VM bytecode to the browser, and to make it streamable.

Andreas S. Thanks for sharing, this is an interesting perspective on computing and technology in general. There are many similar domains where we see both yin and yang approaches (to borrow the author's labels which as a Tai-Chi practitioner I find very appropriate) with the yang approach being currently dominant. There's breeding vs. GMOs, herbalism vs. chemical pharmacology, bicyles vs. motorized vehicles, and of course the author's permaculture vs industrial agriculture. Ivan Illich's "Tools for conviviality", which has been discussed here before, also argues for yin technologies.

I won't repeat past rants here, just point out that going anywhere near this vision requires as a prerequisite the willingness to move away from the herd a bit. To make thoughtful choices about what to fork so you're not at the mercy of where the world decides to go. Even if that means becoming more self-sufficient about managing incoming patches, deciding what to include for yourself, and so on.

a software program is much easier to (re)create from scratch than a garden. Only if you don't implicitly assume that you have to get permission from the mainstream to recreate it.

That holds more generally: minimally invasive yin technologies differ completely from yang technologies that have roughly the same purpose, down to the foundations. In the case of computing, even the hardware must be different.

hi Konrad Hinsen "Ivan Illich's "Tools for conviviality, which has been discussed here before," can you point me to the discussions here on that topic , I would be interested in that. Thank you!

Andreas S. A search for "convival" on this Slack will show you the most recent discussions, including a few around the Convivial Computing Salon whose name was chosen as a reference to Illich's book. Unfortunately the Slack archive doesn't go back very far. I have vague memories of someone having set up a more durable archive on GitHub, but I can't find the link, sorry!

Thank you Konrad Hinsen for introducing me to Ivan Illich ! Now I have some things to read...

Yeah — by all means, spin off a new thread if you want to take an existing thread in a new direction. But don't make more than 1 new post at the top level. Otherwise, people visiting the new thread via our archive won't be able to read the full initial thought(s) that initiated the thread, or people might reply in multiple places and scatter the discussion. Thanks!

Something you could do, if you wanted to repair the timeline a bit (so to speak), would be to edit your post with the permaculture link so it also included the text from your previous posts (which do not have threads), and then delete those posts. That'd help us keep general tidy.

hey I'm not 100% sure what you mean by this. Would it ok for you to edit my posts in such a way that you see it fitting?

I would, but I can't! Slack doesn't offer that ability. No worries.

i wish i was using it—will definitely suggest it next time i work with a group

I installed and tried it this morning. It has lots of promise, but my two gripes were: • Comments, etc. are stored on codestream servers. What if they go bust? Why not inside a git file? • Issues can be created in code and created in git issues at the same time, but editing the issue afterwards doesn't sync up with the one in git. I think these are mostly living on their servers If this utility worked directly with git, I would pay for it. Being able to edit git issues and have them highlighted on lines in Visual Studio would be awesome, and building documentation in a file on github by typing in code comments would also be great.

Interesting comments. Wish more people bet on open protocols. Imagine how the world would be like if git was proprietary and could only use git by using Github.

Yep; I think the value of codestream may well be that someone spots an opportunity to do it right 😉

This has been referenced here a few times. I think we also had a discussion about it once, but it's lost behind the ancient fog.

What was the YouTube video?

It was an ad before a video actually! I did not know that is has been discussed here before.

Oh weird, haha. Yeah, it seems like the sort of project that should appeal to this community in particular, but for some reason.. doesn't. Perhaps folks here have, like me, an excessive predisposition to Not Invented Here.

hahaha. That can be a good reason. I agree. I did not dig deep in it, I have to admit

I’m in touch with their founders, if anyone has questions or has critical feedback to deliver.

I like the website, it makes you want to dive straight in and start playing.

Srini Kadamati have you seen this?

Garth Goldwater yup I’m connected to their head of devrel and tried to woek here. It’s pretty popular amongst pytonista data peeps!

I haven’t used it yet tho

My biggest question: is this intended as a replacement/augmentation for Jupyter notebooks? i.e. creating interactive apps just for the data scientist to make themselves more productive. Or is it for building apps that you distribute to other people, like dashboard for management, labeling tools for crowdsourcing, etc.

Will Crichton I’ll ask 🙂

AFAIK it’s more a deployment solution / the interactive apps bit

I’m many orgs, the people doing the data science aren’t in the eng org / have the knowledge of dealing with all the BS needed to deploy something to the cloud

People have been trying this ML as a Service, model as a service etc play for a while.

Pachyderm.io is also here, but it’s way way heavier. You have to dockerize stuff and they have a complex “git for data” file system etc. it’s for more eng savvy data scientists

Don't miss this comment about how its differentiable backprop works.

cool, the chain rule approach

It reminds me of this project http://aprt.us/ , diagrams are made of shapes, you can click and drag on diagrams, and it knows how to update variables based on the dragging

link?

Oh that was a great post!

https://codefaster.substack.com/p/mastering-jq-part-1-59c

Thanks Joe!

tool tutorials are the most undervalued, undercovered form of content on the net IMO! I would immediately subscribe to a tool-tutorial-focused newsletter

many interesting projects and approaches don’t take for me because although I might agree with the motivations and approaches I can’t figure out how to get started with them in a reasonable amount of time

I've been thinking a lot lately about the 4 kinds of documentation: https://documentation.divio.com.

jq is actually a great example of this—I’ve found approximately eight tutorials of relatively high quality on the web and none of them go through an entire pipeline

great article Kartik Agaram! I can’t believe I’ve never seen this framework before

dang my happy path through the quadrants is definitely bottom left, top left, top right, bottom right

I love this

Thanks Kartik Agaram, that reference was worth a few hours lost to this Slack 😉

Working for me right now..

working for me too! i’m on the eastern seaboard of the US, in case it’s regional

Oh, I think I figured it out

It has TLS misconfigured, and I had a browser extension that switched it to https

works over http

(I should note hyperapp isn't a 1:1 clone of React's behavior. They have differences.)

Also for the purposes of discussion two topics that spring to mind from this for me: • the benefits of small, easy to understand systems for remixing • what other systems out there have this quality? Why do most popular systems seem to not care about this? cc J. Ryan Stinnett

I like the fact that this thing is only 500 lines of code:

https://github.com/jorgebucaran/hyperapp/blob/master/src/index.js

but another aspect is that the code is not well documented. I think having another 500 lines of comments would add value here

well, just an expression, not really suggesting commenting every single line :-)

consider: https://gist.github.com/Avaq/1f0636ec5c8d6aed2e45#file-combinators-js

it is "only 10 lines of code", and yet you could write whole tomes about how that code work.

specially line 10 🙂

I have this as a pinned tab and I just stare at it sometimes like the obelisk in 2001. https://gist.github.com/Avaq/1f0636ec5c8d6aed2e45#gistcomment-1830845

Backing up to yoshiki's question:

Why do most popular systems seem to not care about [being small/simple/comprehensible]? Popularity seems uncorrelated with remixability. At best some projects treat it like rocket fuel, to give a project an initial burst of contribution. But the mainstream view seems to be that what gets you to the big leagues is appealing to people who want to use an interface without trying to remix it. Grabbing the long tail of feature requests. Often these people are employed and using the interface to do their jobs faster or better.

tl;dr - extrinsic motivation is more common than intrinsic motivation. (I'd love to be proven wrong.)

Adding to Kartik Agaram's paragraph: very few people have ever experienced remixability. It's not something you miss if you haven't seen it before.

As for yoshiki's question about other small and understandable systems, I'd say minimalist languages such as Forth or early Scheme qualify, as do their implementations. And RnRS Scheme nicely illustrates how this quality gets lost when priorities shift to robustness and ease of use for specific real-life scenarios.

Popular systems today are most often built by a product team at some company that believes they figured out some core set of feature that will appeal to a wide audience so they get lots of people to subscribe / give away personal data (depending on business models). It has become entrenched in tech culture that that's just how you do things: you build a single product with a single team in control, so the only path available is to find the most common set of features and build those. The long tail of niche requests from smaller segments is effectively impossible and always ignored in today's most common way of building things.

Occasionally, someone on the product team realises the network effects of supporting a plug-in / add-on style API, but often this is done only to ensure the new product becomes entrenched, rather than to allow for powerful customisation and remixing. Many of these product-specific add-on APIs are actually quite limited. For example, maybe you can add new UI via an add-on, but it's trapped to a specific frame (Figma). These barriers get in the way of more creative, powerful ideas to remix and reuse software.

I agree with Konrad Hinsen that most people simply haven't experienced an ecosystem that supports remixing and reuse in a natural, elegant way, so perhaps it doesn't even occur to them. The current way of building also makes such remixing quite hard to support on all sides (original team and remixers). The Basman and Tchernavskij paper "What Lies in the Path of the Revolution" (https://malleable.systems/catalog/#revolution) goes into more detail on the many layers of obstacles currently in the way. I believe it will be a very long time before product teams wake up to the power of remixing, so I am instead building tools to take back control and enable changing and remixing without the original team's involvement.

the examples that immediately occur to me for remixability are minecraft and hypercard. things i’ve noticed: both felt like toys, had extremely weird and nontraditional economic incentives, were directed primarily at curious but extremely nontechnical users, originated as hobby projects, and expressly DID NOT have clear use cases

I don't know there is an easy answer. Coming from the perspective of games would I rather have 1000 systems from which I must choose 50-150 and then manually "mix them" (probably man years of work to really understand all the ins and outs of each system). Or do I just want Unreal/Unity which already made the choices and I can start immediately on the core of the experience I'm trying to provide instead of man years of engineering prep first. I'm not saying one is good and one is bad. Only that reasonable people can choose choose either the large system or the individual systems. Individual small flexible systems are not unambiguously better.

So, that to me is a counterexample to small mixable pieces.

On the other hand, it's rare to find good libraries that don't try to do too much or are flexible and off the top of my head I see at least 2 common reasons. Reason 1, the writer of the library is not experienced enough to write a simple, flexible library. Reason 2, the less experience you have the more you like handrails so there is both the incentive from yourself since you lack experience you think handrails are good and the incentive from the millions of inexperienced developers who will judge your library poorly if they need any coding experience to use it.

To give an example of this second issue, imagine any library that processes data. I think the experienced programmer (maybe you'll disagree) might prefer that the only input to this system is a an abstract "Reader" (or a function to read if you want to think in functional terms). The user can then provide a "reader" to read a file, read from memory, read from the network, and probably do that in as little as a 1-3 lines of code. This means the library is easily remixed in any environment.

But the inexperienced programmer doesn't know how to write that line of code to provide the reader so they'll hate on your library and prefer the one that takes a filename, or a network address or a binary array, or a websocket, and because of that the library will need to pull in 100k lines of support code for file i/o and networking etc... and therefore tying it to specific implementations of those features and then when someone suggests they need it to work with different implementations they'll hack in some afterthought of a configuration option instead of realizing they shouldn't have tied things together in the first place.

Garth Goldwater what's super interesting about both Minecraft and Hypercard are the strong and unique cultures of amateur remixing that sprung up around them. I don't think this happens just by accident, nor entirely by the creator's intent(Notch was not very supportive of Minecraft mods at first), I think a lot about what conditions foster it.

definitely! both seem to have been limited in scope enough to both require customization/creativity and also limited enough to make that feasible for hobbyists. another thing is that those mods or hypercard stacks ended up being likewise limited enough that they were amenable to further remixing by other hobbyists for like refinements on refinements

Thanks for this! I'm only just discovering Zettlekasten techniques and wish it could permeate and organise all aspects of my life.

I'd be curious if the community had a list of implementations somewhere? The implementations I've seen are very heavily text-based for someone who likes to sketch like myself.

Since the original concept came out of the text-academia context this is where most software currently available is focused on

Interesting, thanks Andreas - I'm expecting to see similar methods spread to other domains in the not too distant future 🤔

Ok I watched the gtoolkit video. This feels like an exploratory programming interface. Has anyone here actually used it?

none of the core technologies has a sustainable development model other than "I work at Big Corp and they allow me to work on it" or "begging 2.0" (aka patreon, github sponsors)

there's no sustainable open source business model that is not another way of saying "consulting" or what I call "complexity capture"[1] which goes against the objectives of FoC

1(https://twitter.com/warianoguerra/status/1271383461945884672)

software that is simple to learn and use and doesn't require maintainance is a hard sell for support licenses

you can see it in this group, when someone says that they would like to do it full time the most common strategy is to save money and use it to sustain development for a period of time or to interleave it with consulting.

Very good critiques and observations Mariano, what are some favourite path out of these dilemmas so far?

the way I did it is to "grow out of consulting" by building tools to work faster and bill the consulting part until the tools were good enough to be sold by themselves, then partner for the "consulting on the ground" part (installation, setup, migrations, upgrade) and keep focusing on product development.

but still it's easier to sell your product in a package with the consulting stuff than via a license of any sort, licensing goes through a different channel inside companies, it's pretty easy to charge X for consulting hours and really hard to charge the same X for a license, so sometimes the price is "product + consulting hours" and they just pay for the hours (training, setup, workshops, support)

but still doesn't answer the part of how to make it open source, I was evaluating something like https://mariadb.com/bsl-faq-mariadb/ with an extra clause where it's free for non for profit activities (education, ngos, personal use)

the other one is one that some companies now do which is to do it "open source-ish", with an extra clause that you can't build SaaS solutions with the product

Crafting a business model around something that's not just open source but actively remix friendly is one of the big open questions that (I assume) is why it's currently rare to see such tools come to light.

A model like the following seems to me like a possible path for some tools:

• free, local-first tools that deliver most of the value on your personal hardware
• sharing / team / premium features which require a server component available as a default hosted version with pricing that supports development of all components
• all components (local and server) are open source and can be self-hosted

This does run the risk of becoming "complexity capture" like Mariano Guerra mentioned, but I think it could be pulled off in an elegant way with the right team culture and values, where you really do value and consider the self-hosted case, rather just throwing it up as effectively PR for how "open" you "are".

That seems like decent approach, but of course it's somewhat complex, doesn't apply to every possible product, etc. In general, I'd like to see a lot more innovative ways to fund malleable / remixable software.

There's also various alternate licenses that may work for this case, like the BSL, no-SaaS, etc. ones Mariano Guerra mentioned. Kyle E. Mitchell has several interesting "alternative" licensing schemes (https://projects.kemitchell.com/) that could work well, like the PolyForm licenses (https://polyformproject.org/licenses/) that e.g. allow you to do anything as long as you don't compete.

I think it could be pulled off in an elegant way with the right team culture and values, where you really do value and consider the self-hosted case, rather just throwing it up as effectively PR for how "open" you "are". Yeah, the crucial challenge here for me is that most customers don't truly internalize the value of openness beyond superficial aspects. As a result, an organization trying to truly do the right/sustainable thing is often at a disadvantage relative to one that's just performing 'open!'. For this reason I think the society we live in isn't mature enough for sustainable open commercial businesses in most industry segments. To get there we need a more appreciative, thoughtful audience/consumer base. Which isn't the sort of thing one can just magic into existence.

Chris Maughan just reminded me of an older post of mine that might be relevant: https://futureofcoding.slack.com/archives/C5U3SEW6A/p1587746535114000

Hi everyone, really happy to hear you all discussing this. This is actually an existential question right now for me. I’m working on Athens, which is effectively “open-source Roam” at the moment (but hopefully can become something much more in the future). I’m currently thinking about what open-source licenses make sense for Athens, what biz models are possible if the software is free, and how we could compete against Roam long-term when they’ve already raised from VCs. Would love your help here haha…

I can share more about where my head is at regarding these questions as it pertains to Athens. It could make for a specific case study rather than thinking about this problem in the abstract. But I also don’t want to make this about me. 🙂

I mainly agree with what everyone has said already

| most customers don’t truly internalize the value of openness beyond superficial aspects (Kartik Agaram) User’s don’t care about open-source the same way they don’t care if your app uses blockchain and AI. Perhaps slightly different depending on how much sensitive data you put into the app (e.g. a note taking app). This is more relevant to the people here because FoC peeps seem to be especially interested in end-user software, whereas the successful open-source companies so far have been building developer infrastructure. Here, open-source is more of a requirement from the developers. “Successful” open-source end-user apps: LibreOffice, VLC Media Player… GIMP

I really haven’t looked at these other open-source licenses, but I think Apache is generally the most business friendly. Not saying there’s anything wrong with other licenses, but there’s an extreme power law distribution of them

Does “open standards” automatically mean “open source implementations” of those standards? Does something have to be open source to qualify as remixable?

Nope, in the same way that “local-first” software doesn’t have to be open-source

Who benefits from the standards though? As https://rosenzweig.io/blog/the-federation-fallacy.html points out, XMPP and email are open-standards but have nonetheless been monopolized by WhatsApp and Gmail. Although we have hey and superhuman now

jeff tang (Just to be clear: I was responding generally to all previous replies, not specifically to you. Love the work you do with Athens. I’m following that, #roamcult, and the Digital Garden “scene” very closely.)

Stefan Lesser There's a fundamental tension between remixability and interop. Proprietary implementations of open standards have a huge incentive to parley user bases of their implementations into incompatible forks for locking in their customers. So I consider standards to be a waste of time. Either everyone's on the same implementation and the standard is irrelevant (CPython), or it's slowly becoming irrelevant (Common Lisp). See also https://xkcd.com/927.

Kartik Agaram Yes! That’s the kind of opinionated responses I was hoping for (which btw doesn’t mean I agree). Keep it coming!

one place where open source has worked out ok for the maintainers is ruby on rails. very weird situation

Is it possible we're just done with standards because it's too easy to switch?

We needed a standard for phones because everyone needed to be able to call everyone else. Now I can talk to people for free on 1000 different apps, emphasis on free. Someone tells me contact me on "Kik" (never heard of it) and I install "Kik" and start talking to them. As a geek I hate installing stuff and signing up for new services to be tracked but I'm going to guess most people don't think twice about it.

Standards can also stifle innovation because instead of just adding the feature you want you have to argue about it for years in standards committees. Sure maybe you can come up with some extension mechanism but then you're kind of back to the same thing, only people with your app can use your special extension.

OTOH I'm happy HTML exists and is a standard. It enables all kinds of things because it's in a standard format used in a standard environment. All the browser extensions like Rikaikun (japanese to english helper) and even Ublock Origin (the element zapper) and I'm guessing the password managers only work because everything is running in a standard environment with a standard data representation. If everything was native apps that ability disappears.

Garth Goldwater RoR was "extracted" from the work 37 signals (now basecamp) did while developing basecamp, so it's similar to the model I mentioned about developing open source while doing your day job at a company. Or do you refer to something else?

“Big” standards like TCP/IP, HTTP, HTML, etc. seem to be the infrastructure that was built in the past that everything today still mostly depends on. We wouldn’t have been able to get to today without them. But there seems to be a pattern where the heavy lifting is done by visionaries motivated by ideals (and backed by governments and/or large corporations’ R&D budget) and then capitalism swooping in, taking over, and making their foundational work look like it’s no longer necessary (and perhaps it is no longer necessary?).

Maybe a good strategy would be to listen to people like Mariana Mazzucato https://marianamazzucato.com/ and people researching how to manage "the commons" more 🙂

Mariano Guerra the weird part about it is that 1. a ton of their money comes from the original product (basecamp) rather than rails itself 2. both the product and the open source stuff did really well and 3. they built the product and the open source platform at pretty much the same time

Just found out about Sponsorware. It’s sort of like MassDrop or Kickstarter but perhaps works better with software. Probably wouldn’t work for every project, but seems like a good balance between openness and value capture

Well I am not sure we have walled gardens. Npm, container repos and others let anyone make their own version of a repo library if they wish don’t they? Or am I misunderstanding the thesis? Like Facebook did with npm and yarn

Thanks for posting! I'd encourage more posts about FoC virtual conferences and symposia.

Thanks for sharing! 🙂 It is good to see that the WebAssembly path is taken seriously from the Python community. And it is interesting that such question make people take some side step to see what is essential and what is not in their programming language.

Looking back on when I used to code for fun vs. Professionally the biggest one is definitely evolution over time. I certainly wasn’t thinking about if a thing was easy to read, modify or understand. The task was just make it work. I think that’s the central difference.

I really like these.

I might add: * Understand the bug before you fix it.

In the same idea than Ope, one that comes to my mind: good naming is important but hard.

I'd say a newbie by definition does not know which way is up. Cannot tell good practice from bad. At least that was my path. 😉

• controlling invariants

• maintaining performance

A possible issue with such a list is that different people can interpret these items in opposing ways. For example, “catching problems early” to one person might mean catching typing bugs, to which they might propose a strict type system, while to another it might mean catching design flaws, which might lead them to favor a more flexible type (dynamic or optional) system.

Steve Dekorte Yeah, that's becoming clear to me as well. I intended "controlling evolution over time" to mean just a low-level sense of tracking the past rather than maintainability in the future. Not that maintainability is unimportant, of course.

Your example is actually not that serious. I was deliberately trying to focus on the shared activities we perform as programmers rather than the diverse tools we may use to help us do them. Things that require manual consideration regardless of what tooling we may use to reduce the effort of acting on this consideration.

But yeah, it's clearly a question in progress, and I'm failing to articulate boundaries crisply. Basically I'm imagining a series of yes/no questions of the form "do you think about ___?" What would all programmers above some level say yes to that programmers below wouldn't? In what ways does the practice of programming rewire our brains? Quite possible my initial answers don't fit.

I’d guess I’d file these under “managing complexity”. The other under appreciated sub-areas I’d add are maintainability, portability, persistence, synchronization, communication, and security.

I don't have much experience dealing with parallel or distributed computing, and I have zero experience with security. I think portability is irrelevant to 90% of programmers today. So -- to the extent that I'm a programmer -- your list seems quite aspirational.

When was parallel/distributed computing mentioned?

Dang! I was hoping this would automatically put the message in the feedback channel and make #zettelkasten clickable. Points for trying i suppose. Perhaps a future plugin...

if we can solve that problem we should just incorporate and build a social zettlekasten (i’m serious)

Sounds really cool to me! I've been keen to play with building a zettelkasten app. Anyone else interested in the idea? I'm good with UI / Frontend 💪

It would be great all those github compendiums people have been making easily extendible and in on one place

Steve Peak has told me in the past that Chet Corcos and Nikolas Martens are both interested in collaboration and aggregating persona data — any interest?

I can do full stack and light devops

That'd be awesome! We would need all the hands we could get! I think we'd have enough skills to execute between us otherwise (I can also do basic backend / devops)

🙂

I’ve been particularly focused on the “inbox” layer of systems like this—information coming in from the outside world, like with browsers. I’d like to preserve references and collect components of things rather than, eg, entire websites. demo:

demo with wacky debug colors

That's awesome! Easy web-clipping is a big reason I haven't adopted a Zettelkasten system yet. You're already solving the hard stuff!

oh and the clips are pretty easy to parse structurally

end of videos

at the moment i’m a bit stuck on the interface for saving clips/organizing them—i think that kind of “piling them” like you might do for “read & reply later” in in the hey email app might be a good start, provided that you can kind of stack them in different places. but how that then forms into like useful aggregates (eg here’s a list of links on visual programming environments that run on the web) is where im struggling a bit

and that all is to say absolutely nothing about the social/collaborative aspect of it

I do like the collect now, tag later approach. It allows you to save data when you're interested in finding it and organise when you have a spare moment. I imagine you could just tag it with "vis prog" unless I'm missing something?

Social/collab will be an interesting problem to solve and I imagine will take a bit of trial and error to get right. Especially considering moderation, ownership, longform vs chat.

Perhaps we can see who else is interested and set up a doc / arrange a call to discuss details.

I have a lot of feelings about tags—would love to discuss more on a call with anyone interested

Garth Goldwater I made some cool designs for saving web history that I think you’d like. I’ll have to dig them up later.

I’m also learning some cool stuff about datalog and want to build a personal database for all this kind of stuff

awesome! datalog rules—and i think it’s super amenable to graphical user interfaces

Agreed!

Are you a clojure person?

I’ve played with clojure but not deployed to production

I like any programming language with a strong point of view

Yeah, I’ve struggle to get into it. I love rich hickey and his talks though. But getting a full stack dev environment and dealing with the JVM has been a hurdle. Plus I’ve become a TypeScript wizard so it’s hard to walk away from the type system.

if you know of any good introductions to typescript i’d love to get into it

Oh it’s amazing. Honestly, just read the documentation on the website and start off with all strictness off. Then eventually turn strict null check on and you can learn all the ins and outs at your own pace without holding you back.

Also, feel free to DM me with any typescript issues! When learning generic types, there can be some tricky parts.

ah thank you! my biggest hurdle has been tooling… I’ve recently become addicted to writing all of my code interactively in the js console lol

Haha wow. Well with incremental webpack builds, you can do this in your code editor just by refreshing the browser whenever you want to rerun

Here’s the starter I use: https://github.com/ccorcos/typescript-boilerplate

It’s pretty simple. No backend. I would open up the tsconfig file and turn off any of the strict flags. And also check if any packages could be upgraded.

I think about this a lot! There's a lot of folks in this community making better tools, but less focus on making better users-of-tools.

A tough part of this is that learning isn't a domain that technology alone can solve. Learning is social, so improvements will involve people and organizations.

Yeah, definitely not just tech but tech can help with gathering data figuring out what’s effective etc. Also reminds me of this - https://youtu.be/uEFrE6cgVNY?t=1229 . Perhaps more gathering of evidence of what works for learning to code and perhaps systems that are personalised and know about you in particular etc and perhaps even the design of languages in the first place to make them easier to learn

"design of languages in the first place to make them easier to learn" is the crux of it. Forgetting that leads us to the false dichotomy of "making tools" vs "making users of tools". There's no such dichotomy, because there are no tools without users. What we have today are tools that everybody uses that are unnecessarily hard to learn, tools that are easy to learn but less powerful (dumbed down), and tools that try to be easy to learn but nobody uses.

As a learner, it's sometimes worth learning a tool that's easy to learn even if nobody uses it. Because it can give you something more timeless than just the incantation needed to perform some task. Some concept or some way of thinking. I tried to list a few important ones above (https://futureofcoding.slack.com/archives/C5T9GPWFL/p1593722002162200)

Reminds me of this I found yesterday. So much easier to read even though it’s verbose. That’s a design thing - shouldn’t just be optimising for brevity or shortcuts when it makes things harder to learn and grasp - https://tonsky.me/blog/dsl/

Indeed. I get polarizing comments on the names I choose in Mu. For example, see http://akkartik.github.io/mu/html/apps/tile.mu.html. Some people say the commands are too long to type. Others love that they can tell what the commands do without having to spend a lot of time with my project.

It’s also the same thing with stuff like operators in Haskell - how do you pronounce this ‘@&£’ operator (I made it up btw)? Sure it is brief but it’s three characters in my head and doesn’t have a real name(I am convinced with Haskell it should be possible to give operators aliases, funny thing is ‘>>=‘ is ‘bind’. Being able to pronounce things is vital for chunking I think. Again, wish we had a more data driven approach to these questions.

Indeed! Pronunciation is key, and picking up how to say something often requires being inside a community. That's one reason I tend to be skeptical of visual programming. We all use language to reason, and if it's not obvious how a construct translates to language, that can be accidentally excluding.

Tbh, skeptical too for that reason. Visual programming seems ideal for figuring out stuff in the large (so visual documentation perhaps?) even then probably doesn’t help if you have a huge ball of spaghetti.

i think an analogy might be that visual programming systems ought be very legible in gif form or similar—there are a few indie games that have gotten really big just because the developers were able to make really compelling gifs that went viral. communicability is really important but i’m not sure spoken language is the only route (although the haskell situation seems like the worst of both worlds)

Definitely don’t think text is sufficient or good enough on its own. Just that it can be the foundation and other mediums augment it - when I hear Visual Programming sounds like the visuals are the main thing

Something I think about a lot is how we can increase software literacy, and I don't know if "learning how to code" is actually what we mostly want. Both my parents and my grandmother learned to code in the 80s, but only one of them is even approaching software literate. People need to be given an understanding of what computers are and what they are capable of, probably through integrating some automation or similar into their ordinary workflows. Advanced spreadsheets you use every day will inform your ability to understand that software exists and can be built and combined and changed a lot more than knowing how to write basic code that you never actually do in real life. I fear that far from building the LOGO or etoys-inspired "computer culture" of Mindstorms we are instead teaching elementary students JS in the same way that the 80s taught highschool students BASIC -- and then none of them actually got any use out of it in their real lives

That's a high bar. I think nobody is software literate today. Someone literate in english can read any individual paragraph in english and answer some simple comprehension questions about it. And students learn to read two books and compare and contrast features of their prose. Most people don't write novels, but many people can read novels and talk about them with each other.

Can anybody do that today with software they didn't write? Even software they wrote a year or two ago? Substitute 'software' with 'spreadsheet' to taste. I sure can't claim anything like it. Any time I try to read somebody else's novel-length code I have to spend weeks to understand what it does. I imagine people from a thousand years ago may have felt the same way, laboriously reading a tablet character by character, tongue sticking out, trying to figure out where the word boundaries are, reading a line over and over again until the meaning sinks in.

Garth Goldwater "i think an analogy might be that visual programming systems ought be very legible in gif form or similar—there are a few indie games that have gotten really big just because the developers were able to make really compelling gifs that went viral."

Forgive me if I'm reading too much into your response. I don't love this analogy. I think it misses a lot of the subtle issues here. It's important to realize that different methods of communication have a "knowledge bandwidth". Those viral gifs all communicated ideas that "could fit in a gif" so to speak. Your comment implies that we just need to find some better way of making an image that communicates the ideas better, but I suspect representing code might fundamentally be an idea that doesn't "fit on a gif". And that's not necessarily a bad thing! It just means we have to find other ways to communicate those ideas.

For the same reason, we didn't just stop writing books after we invented cinema. Different ideas work better in different mediums.

damn Kartik Agaram that really hits home. remembering a few historical figures now who were renowned for their ability to read without speaking—and also that multiplication and division were basically magic or rocket science before arabic numerals.

Ray Imber no disagreement there—I don’t think the gif is the universal form of visual communication or anything (just an example)—but I do think that it’s not surprising that some ideas fit differently in different media. I don’t think I’d be super successful at learning to throw a ball by reading a textbook. I’m just suspicious that “stuff that’s hard to describe with speech” means non-transmissible, unlearnable, simple, or unsophisticated

Garth Goldwater Definitely. I believe the future is a hybrid. Text is an important part, but with lots of visual aids (or audio or tactile aids even). "Stuff that's hard to describe with speech" reminds me of the concept of "tacit knowledge": https://commoncog.com/blog/tacit-knowledge-is-a-real-thing/

Ray Imber thanks for that article!

Duolingo for programming languages: https://getmimo.com/

My wife told me about this (she choose to start with Python).

It's an interesting approach. Some people really do well with Duolingo (e.g. my wife has a 1000+ day streak).

I was watching her do a lesson and it was quite well structured. The questions were set up to test common beginner mistakes.

What I thought was nice about that is that if you get it wrong, the app can tell you exactly why you got it wrong (since they know exactly what bit of understanding they were testing, and control the answer space).

If you made the same mistake in e.g. a REPL, the error message might not be as informative.

Very interesting discussions and links (thanks Ray Imber for the Tacit Knowledge article)! 🙂

I agree part the future of coding should think about making learning easier. That is why I like Vue.js and the way this framework is designed with an objective to be easy to learn. The features are very focused, you don't have to use all of them to start being efficient and the documentation is of very high quality (with some decent effort to translate it), one that you can read like a novel (which I did before writing a line of code).

Xandor Schiefer thanks for that link! It’s precisely the direction we should heading towards. Imagine, if the results from a large number of students also fed back to language designers so they could make better decisions up front + perhaps trial new features and figure out if they were easy to learn - need to be careful - something might be hard to learn because it’s not taught properly too but sometimes the construct is complicated and perhaps there is a less complicated alternative

i have such a strong wish that documentation had built-in annotations and questions for that exact reason Ope so that students could put their confusion in the docs directly

Love the idea of a PL where the basic types are variable sized (and/or small scalar vectors), and made a few designs in that direction.. the hard part (for me) is always making it fast. My last attempts try to solve that by putting such values on a stack (as opposed to dynamic allocation fallback). Something similar to "small object optimization" of e.g. Clang's std::string implementation is also a good direction.

Tim Babb looks like my comment was too ambiguous 🙂 ... donotpay solves the ambiguously problem by having a conversation. It asks you questions to resolve ambiguously. ... I am not sure how else you could do it, because, as you say, many English statements are ambiguous. donotpay uses the IBM Watson software - there are quite a few podcasts about it https://www.listennotes.com/podcasts/415-stories/e7-joshua-browder-of-DL2dXgmfvPr/

Tom Lieber and others: I work on Wasm tooling (LLVM) at Google, so let me know if you have any specific questions

most Wasm VMs that are mature and fast are also large complex beasts, so integration isn't easy.. though that is something we're working on making easier (in V8)

there are interepreter options that would be easier to integrate, but Wasm really takes a huge performance hit when interpreted

Edward de Jong Wasm runs on the same thread as JS, and can interleave calls and integrate tightly with JS

What you see as "braindead" is actually Wasms greatest feature: secure by design. it has NO API surface, thus can actually pretty easily be shown to be secure, unlike other VMs (like e.g. the JVM) that can never be fully declared secure because of its endless API surface

that currently means to access the DOM you need to go thru JS, but more direct access (thru "interface types") is coming, all while keeping that rock solid sandbox you think is braindead

and yes, it is intended to let all languages play

What stack would you start with if you suspected that interpretation overhead wouldn't be overwhelming?

contrary to your belief, the DOM is not the only thing you might want to access.. for example apps built on top of OpenGL port pretty nicely to Wasm already thru emscripten

and of course it was intended to run outside the browser, in any environment

Tom Lieber if you were ok with an interpreter, I would either integrate the one in WABT https://github.com/WebAssembly/wabt which I would have the most faith in being "correct" w.r.t. the spec. but is definitely not fast, or wasm3 https://github.com/wasm3/wasm3 which seems to be the current king of speed in interpreterland

what is the language you're integrating into?

In general, it helps to see Wasm as a "secure virtual CPU", not as a "batteries included VM" like JVM or even JS. I guess that is where a lot of confusion comes from.

Wouter van Oortmerssen Go, ideally, but I'm flexible because I just want to prototype. 🙂

well there's https://github.com/go-interpreter/wagon, but hard to tell how robust it is.. when evaluating runtimes, you generally want to check how many of the "spec tests" it is able to pass.

is it easy to link in C/C++ libs in Go?

Wasmtime seems a pretty well designed runtime that is also fast, if Rust is an option

I’m not dead set against learning Rust. 😅 C is pretty easy to use in Go.

Wagon is one of the ones that felt half-finished. I have a test program that just tries to initialize and invoke various wasm VMs in Go and the lack of documentation / examples tripped me up in every single one.

I haven’t tried a few of your recommendations, so I’ll give those a shot!

I struggle with this because at least with the examples in the demo - with haskell I could have produced the code for the same effort it took to write the comment. Plus English is ambiguous and not precise enough. What I want stuff like to be applied to is generating more efficient versions of the same code or efficient code from a specification or from a test. Like you shouldn’t really have to write the tail recursive version of a function if there are tools can help you do that.

Cool demo, but I think it's another example of too much AI/ML hype.

The most telling example for me was the part where the model made an error in the demo on the "compute_total_price" function.

First, note that it's guided by doc string comments. This very quickly devolves into a classic black box optimization problem.

I can easily imagine someone spending hours tweaking the wording in their comment to try and get the model to generate the right code. How is that better than what we do today where we tweak code or add annotations to try and get the compiler to produce more optimal code? This is worse because natural language is not nearly as structured (The search space is much larger) and the ML model is much more stochastic than an optimizing compiler.

Second, think about when, even after the presenter "fixed" the comment, the model produced code that was almost right, but had a bug. The 80% off instead of 20% off.

The presenter writes that off as no big deal, and in a small toy example like this it is easy to find and correct the error. But can you imagine that situation in a much larger code base? Or even a single moderately complex function? It's well known that reading code (and understanding it) is much harder than writing it. Anybody who has had to fix a bug in a dense legacy code base will tell you, it's way harder to find the bug than it is to fix it. Often, even if you were the original author!

This feels less like "pair programming" from the future, and more like "instant legacy code generation". 😢

I think ML is good in general, but I personally feel like this is a case where more black box magic makes things worse.

This seems like the fallacy that programming is hard because you need to master the syntax of your language. But programming is actually hard because it’s hard to express things precisely. Like, stop hiring senior developers to write your code because look, a junior developer can also write that code. Sure, it has a few errors ¯_(ツ)_/¯

I agree with you guys, however, I still find this demo impressive and although it does promote some kind of hype over ML/DL I do believe some parts of developer experience should be automated. May be one day in the future that will happen. However, I do not believe that it can be achieved via just a Deep Learning model (however big the parameter space can be). I believe, we will need to mix Symbolic Reasoning in this somehow.

I think a better application of this kind of technique is tabNine It is a more fine grained ML based autocomplete plugin.

I think kite does this for python and intellicode was supposed to do it. In practise, I believe I tried them out and they were buggy and I never looked back. Perhaps they are better now.

http://www.cs.utexas.edu/users/EWD/transcriptions/EWD06xx/EWD667.html

“A short look at the history of mathematics shows how justified this challenge is. Greek mathematics got stuck because it remained a verbal, pictorial activity, Moslem "algebra", after a timid attempt at symbolism, died when it returned to the rhetoric style, and the modern civilized world could only emerge —for better or for worse— when Western Europe could free itself from the fetters of medieval scholasticism —a vain attempt at verbal precision!— thanks to the carefully, or at least consciously designed formal symbolisms that we owe to people like Vieta, Descartes, Leibniz, and (later) Boole.”

“Instead of regarding the obligation to use formal symbols as a burden, we should regard the convenience of using them as a privilege: thanks to them, school children can learn to do what in earlier days only genius could achieve. “

“When all is said and told, the "naturalness" with which we use our native tongues boils down to the ease with which we can use them for making statements the nonsense of which is not obvious.”

Jared Windover you make a good point. Far better than help with syntax, a better programming language/tool/environment would help you see the consequences and inconsistencies of your logic.

On the other hand, it's easy to forget how much basic syntax holds up beginners. Semantics probably holds them up more, but they don't get that far.

Ray Imber TabNine is a delightful little assistant for its occasional strokes of genius. I have a collection of these, all Ruby...

Typing {"B1" => "X", "B2" => "Y", " gave me the suggested completion B3" => "Z"}.

Starting with product_demands.map{| TabNine recommended |k, v| then after adding " it went on with #{k}=#{v}"}.

Or there was the time I got to bidding_credit_discounted(bidder, [gross - incentive_payment, 0].max) from typing b\t\t g\t \t.

Ope Thanks for nice piece by Dijkstra. Now, I agree with that of course. A formal system and rules to manipulate symbols are the ONLY way you can probably express a concept beyond any doubt and universally. So, as I mentioned, I do not think just naturalness and optimising a particular function is the ultimate answer. We may need to wait for the genius of someone to come up with a solution to this problem. But the way I see it, this is the only way forward. A little write up by Gary Marcus in this context - https://arxiv.org/ftp/arxiv/papers/2002/2002.06177.pdf

Long read so I just skimmed the first 10 pages. What he said about it being reliable reminds me of a talk Gery Sussman gave once. Actually this talk would be relevant to the group - https://youtu.be/O3tVctB_VSU - one of the things he talks about that is important is that these programs should behave reasonably even if they aren’t programmed in detail.

Also there is this also this - https://youtu.be/fAY0_pesZ6s . We should probably be moving towards being as precise as we have to be with computers with our language too. In this video, Sussman talks about how Maths notation is horrible - and that's maths. Natural language is worse. He argues that the legacy of programming is teaching us how to think precisely.

If this could have been like the following (suggesting the string "main" from the usage pattern of this expression over a large corpora of code) then it would have saved me 10 keystrokes!

Yeah. Also seems like a lot of people are fans of tabNine so I’m going to try it out. Advanced autocomplete is pretty cool.

https://twitter.com/KevlinHenney/status/1279368060336553985?s=19

Here is my take on it: https://twitter.com/girba/status/1279298566981378048

Another old favorite I'm thinking about: https://web.archive.org/web/20150905171238/http://www.soe.berkeley.edu/boxer/20reasons.pdf

(Be careful, though, of taking claims of pegagogical efficacy at face value: https://dl.acm.org/doi/pdf/10.1145/3274287 via Will Crichton's https://futureofcoding.slack.com/archives/C5T9GPWFL/p1591498636036100)

Lotus made a spreadsheet called Improv for the NextStep OS that was to my thinking the next evolution of the spreadsheet. Unfortunately when Jobs got rehired by Apple, the Next computer was tossed aside, as he had bigger fish to fry, and the tiny installed base of NextStep programmers were left adrift, teams disbanded, etc. Then Lotus was sold to IBM which was the final blow because new products have great difficulty escaping the mediocrity machine that is the current IBM. I was around when IBM was the greatest company in the world, with constant breakthroughs of fundamental technologies. As others have pointed out Apple was a harvester of existing technology, but IBM invented things. They had virtual machines in the 60's (CP/CMS), 30 years before VMware. Too bad they didn't push CP/CMS more, it was better than their lousy TSO time sharing system.

Most interesting: https://en.wikipedia.org/wiki/Lotus_Improv

I cannot understand why someone doesn't copy Improv. There is a spreadsheet for Windows from a small firm that does very similar things; can't remember the name. It's a very expensive enterprise type of pricing product. I know Mitch got rich from the sale to IBM, but I wish he hadn't because Lotus was a real high quality software company, and merging them with IBM was like what Vivendi did to Broderbund and the dozens of other educational software companies, destroy them in the end. Mergers among software companies have a nasty habit of destroying the teams that made the firm great in the first place.

Thanks Kartik Agaram for reposting this article. I didn't have time to read it when Mariano Guerra first shared it, and it is very interesting. In fact at leats I learned "intensional" and even if it the advanced spreadsheet presented here seems powerful, I don't see very well how it is really useful to solve real problems. But I must confess that the spreadsheet is a programming tool that I am less incline to use...

"intensional logic, the logic of values that vary over a coordinate space." Maybe a nitpick, but this feels like a weird definition of intensional logic (here's a better explanation: intensional logic has to do with words having more meaning than mere reference). I don't think I want actual intensional logic in my sheets; I want referential transparency. I want 1+1 to always equal 2.

Beyond that, I think there are some interesting ideas in the there although it feels like someone who doesn't use spreadsheets trying to fix them: excel has some tools like pivot tables, what-if analysis, and table objects that accomplish a lot some of what the author is asserting spreadsheets can't do...in addition to RC notation, that he admitted not knowing about.

Just saw this. Zubair Quraishi yes they are. We also removed the vesting “cliff” for people who had not been here a year (so eg they’d get 7 months of options if they’d been there 7 months, as opposed to nothing)

Yep sorry I forgot to update it here. I posted here and On Hacker news

also, Tudor Girba i’d be stoked if you could add control of the slideshow with left and right arrows instead of just mouse. if you wanted, I’d even love to walk through implementing it in a recording for gtoolkit intro materials

Garth Goldwater pragmas are called annotations in other languages. In Pharo, pragmas can be attached to methods. This paper describes the mechanism in a little more details: https://hal.inria.fr/hal-01353592/document.

I waas trying to understand that paper—are they intended purely for smalltalky reflection, eg “list all the methods in the image with the <3d-viewable> pragma”? or does it do other stuff? Do they get evaluated? I understand that they involve message sends, but I’m having trouble wrapping my head around how/why they’re dynamic

they do not get evaluated. yes, they are intended for discovery.

eg “it may be queried for senders, executed, etc”—does that mean objects who use the pragmas to query objects in the image, or the objects with the pragmas themselves?

```LargeInteger >> // anInteger

"Primitive. Divide the receiver by the argument and return the result. Round the result down towards negative infinity to make it a whole integer. Fail if the argument is 0. Fail if either the argument or the result is not a SmallInteger or a LargePositiveInteger less than 2-to-the-30th (1073741824)."

<primitive: 32> ^ super // anInteger`` so… i get that you’re sending 32 to the object primitive` … when does that message send get executed? on instance creation? or just during queries?

no. primitive: is a message. 32 is an argument.

hooo boy i’m very turned around

ok im going to read more stuff thanks for your help

if you look for the senders of primitive: you will get the locations in code that are using this message as pragma.

<primitive: 32> would be equivalent to @primitive(32) in Java.

if you are playing with Glamorous Toolkit, you can also query for it explicitly. For example, inspect #primitive: gtPragmas in a Playground

so in that example, you’re sending the symbol primitive the argument gtPragmas and getting a list of all the methods that use primitives?

sorry, I need to break stuff down a whole lot in order to make sure i’m not using the wrong schema when i’m trying to learn something at first

yes. this is a fluent API. In this case, it’s implemented like this:

You can learn about this querying API through the slideshow from the home tab entitled Querying Code

I use this occurrence-based highlighting (giving it the semantic attribute seems a bit of an overstatement to me) in IntellIJ IDEA with Scala. Honestly, I haven't felt any improvement, but i'm also not bothered by it, so I kept it active. I guess I should disable it and see whether I'll be missing it.

What I'd love to see, though, is a plugin that colors identifiers based on types, so that I can see how types flow through an implementation. I've created a couple images at some point to show this idea. I needed this when I was attempting to explain the implementation of a Cartesian product function to some people at a coding dojo.

The language in the screenshots is Haskell.

In the example above, the type-based highlighting makes it easier to notice that the first and second pattern matches of [] are on different type occurences.

Few ideas:

The value for beginners shouldnt be underestimated because anybody in a new codebase or language is like a beginner. Having colors for keywords and meaning makes it easier to learn the language.

highlighting helps with writing code. I find it helps me identify typos while typing because the word is the wrong color. Similarly it helps me identify keywords I forgot were keywords.

Semantic highlighting can be thought of as something to strengthen code smell. If code looks the wrong color, it has a very bad smell that's easy to spot, whereas code with a single letter missing has a very subtle bad smell.

I'd imagine highlighting would be most helpful for debugging.

I find it varies with language—in C for example, I find it very helpful, quite often I'll find myself in a conversation of sorts with my editor to make sure the highlighting match up, if it doesn't highlight like I expect, I know I've made a syntactic error somewhere. On the other hand, take any lisp, I don't find highlighting tokens to be too useful at all, but I find myself doing a similar thing with the autoindenter, though rainbow parens are also great.

I personally find tooling quite important

My experience is that syntax highlighting really helps spotting some errors quickly. If the syntax highlighting is even slightly off, it really confuses me. For example, when I started learning Rust, the VS Code incorrectly highlighted some regular names as built-ins. So before thinking of "semantic highlighting", I think it's more important to do "correct highlighting" first. For most languages, this means that you can't simply use Regex highlighting rules. I've used individually-colored names in Jetbrains products and liked it, but it wasn't a huge productivity boost. Rainbow-Parens are also helpful IMO.

When talking about syntax highlighting, it's usually about text / background color and font variants (bold/italic) only. My hypothesis is that source code readablility could benefit from using different fonts for different syntactic elements. Identifiers and literals could use a sans-serif font, documentation a serif one and keywords / punctuation a monospace font. I'm currently building a prototype that uses different fonts depending on the element type. I can hopefully show something next week.

Douglas Crockford has a similar opinion as Rob Pike about normal syntax highlighting. He discusses his system in his "monads and gonads" video. In it he uses color to signify scope. Here is a vscode plugin based on that idea: https://github.com/azz/vscode-levels

I haven't used it myself, but I wonder whether non-traditional syntax highlighting schemes wouldn't have the same level of utility as traditional ones (which I agree is low; though I also use the "wrong" color as a signal that something is syntactically wrong with my code, there are better ways my editor can and does use to inform me of such problems).

There is a small set of limited colors that can be unambiguously used at the same time (say max 7ish), incidentally about the same as the limit of how many things I can hold in my head at the same time (7, plus or minus two). This color limit is especially true if I'm using different colors for the same syntax elements (to indicate something other than syntax, such as scope or other semantics).

In order to program I need to build up a mental model of the code. Highlighting will only help me if it can extend the capability of my brain to do that beyond its natural limits, e.g. work with a partial mental model, supported by "color context", or help me build up a regular mental model more quickly.

Another thought on this: even if studies showed that there was no productivity increase when using syntax highlighting, I'd still want to use it just for the aesthetics.

I originally had the same opinion as Rob Pike. Now, I'm programming in C++, and I sometimes disable blocks of code using #if 1 try this #else old code #endif when I am experimenting with a new implementation. Vim colours the disabled old code differently, so I can quickly see that a large block of code is disabled even if I can't see the preprocessor # tags that disabled it. That's useful. Ditto for colouring block comments and multiline string literals. On the other hand, giving each token on a line a different colour is just visual noise.