Kartik Agaram I don’t have any resources handy (not sure if any code was publicly released) but with a bit of google-fu you can verify that Smalltalk used to work that way

Kartik Agaram Erlang models that original async message passing pretty much to the original definition if you're curious about the original idea of OOP.

Kartik Agaram, Joe Armstrong (co-designer of Erlang) talked briefly about this in an old email list http://erlang.org/pipermail/erlang-questions/2009-November/047748.html

https://news.ycombinator.com/item?id=24027663

Keeping my eye on https://web.dev/native-file-system/

Local-first is a great value to uphold. I’m also a believer in 1-user software and plain text. For all of those, files, folders, and even zip still feel like the way. Let Dropbox/iCloud/whatever take care of sync and share.

What we really need is an open Dropbox, as a web standard and common service.

The problem with local first seems to be that not enough users value it. It reminds of the move from websites at a domain to services like Facebook, Twitter, and Medium (captured well in this Oatmeal comic https://theoatmeal.com/comics/reaching_people).

I'm not sure what the solutions to this problem is. And, in fact, for most people, having everything owned and managed by a cloud provider is probably a better arrangement than having them manage their own backup system with local files.

I'm aware that the paper solves all these issues at once, but the real issue is that it's not valued by enough customers to get the software providers to implement it, and I don't know how to solve that.

My core belief is that local-first, and decentralized software are meaningless jargon to users.

Privacy and security don't really sell to consumers either.

What users do value is the ineffable feeling of confidence that comes from using software that meets their needs. You get that when software has consistent design, low latency, and reliable behaviour.

I believe local-first software will prove in time to be the most cost-effective way for developers to meet their users' needs and so that local-first programs will in time naturally out-compete cloud software.

That said, cloud-based software is a mature paradigm with plenty of refinement. Local-first software still requires careful attention from system designers to identify and satisfy user expectations. That's the problem I'm focused on at Ink & Switch.

And cloud-based and local-first can coexist. A local first editor can still persist data on a "robust centralized cloud". Well, writing this I realize that in fact that depends what one understand by "cloud-based"... Here, I only mean that local first allows to work even when a centralized repository is not available or is not trusted, but at some time it is still useful to have your data stored "non locally", and cloud hosting can then be desirable.

Agree. I think Apple's iCloud model is pretty close to right, and we know how highly the company regards "great experience" (all caveats & multiple lapses notwithstanding) -

iCloud aggressively seeks to ensure that data is pulled and pushed frequently enough that all devices' local versions of file data are available and ready - of course there are still so many failure scenarios that it's easy to spot when one device's app's doc is definitely not up-to-date

That all said, even a stellar solution within a closed ecosystem is no good to us - but I think iCloud highlights the attitude that "local files up-to-date and available before you need them" is the right one

Yes, if iCloud worked it would be pretty good.

Obviously whatever we build will absolutely include remote nodes that we hope will always be available performing all kinds of tasks. The question is what their role is.

I think the steelman question here is: can a remote-first app with offline mode be good enough? If so, companies will gravitate to that so they can maintain control over people's data. But the outcome isn't certain yet by any means.

Certainly I think many of our CRDT projects can make that better, and arguably that's what roomservice.dev and replicache are working towards.

Also, if you look at, say, Actual Budget there's an example of production software following that model. It's a local-first style client but the data only replicates through a proprietary service they run.

Has anyone explored IPFS as a storage layer for local-first? It looks like a perfect fit in theory.

I came here to say what the slides to of compilers: that static-single assignment is easier to think about. Though continuations have a certain theoretical elegance, they generally mismatch use-cases so that you always end up wrapping them. Common Lisp conditions have always seemed better to me than exception mechanisms. Most exception (maybe just my exceptions) are bugs, and then you want to keep the stack, be able to drop into a REPL, figure out what's going on. The fact that exceptions often have a print_stack_trace method just goes to show that you actually want to keep the stack.

The other main use of exceptions is for a quick escape from nested computation. After years, I think I've come over to the checked exception camp on those. In other words, if a checked exception doesn't feel good in a situation, an unchecked one isn't either, and you should be using a sort of condition system.

AND then if the condition is the kind of thing where you may, for instance, want to get feedback to from the user, then you're likely going to want coroutines of some sort. I mean you were doing something step-by-step, but now it's broken, so set that aside, look for a fix, then come back to it.

so from my day of research, the tldr

algebraic effects are structured delimited continuations that solve a lot of the problems with delimited continuations (~= all problems of unbounded dynamic typed callback programming)

the CL condition system is very close analog with limitations that it

a. it can't restart outside of lexical scope (i.e. resume a continuation in a different stack)

b. it can't resume multiple times

it is questionable whether those are necessary or even good, especially b.

I don't know how deep you want to go with this question, but the best web-visible resource regarding continuations of which I'm aware is:

http://okmij.org/ftp/continuations/

... in particular, on the topic of call/cc, I recommend:

http://okmij.org/ftp/continuations/against-callcc.html

I think it's useful for a programming language to use CPS behind the scenes (i.e. using callbacks in place of call stacks), as opposed to something one done manually (e.g. explicitly passing callbacks) just for the utility that it opens up:

• Easy debugger (stop time, go back in time)

• Easy implementation of exceptions, etc.

• Async code can be written as if it's synchronous

But I'm not sure CPS works that great unless you're essentially using a Scheme-like runtime

This is the only example I know of that does this, though:

http://lisperator.net/pltut/

concur with Jack Rusher Dan Cook comments

for posterity/others, my overall take away after a week of implementing them and various other lang controls is 1st class delimited continuations are extremely powerful but are a pandora's box (~= a functional goto). Even though other things I mentioned are weaker forms of them (e.g. transducers), you do want the weaker forms as it scopes what someone can do

imho, algebraic effects are the best form of them that are usable but even there, I think they need more scoping restrictions, especially in non-functionally pure languages

(e.g. https://cs.uwaterloo.ca/~yizhou/papers/abseff-popl2019.pdf)

Does the newsletter only extract messages from certain channels, or do you curate which conversations are added?

I pick from general, feedback and two-minute-week, maybe I should add graphics and music to it

if it's a slow week almost all will go in the newsletter, if there are many I try to filter the ones that are not so much about future or coding 🙂

Is there a way to search by author? For ego surfing purposes 🙂

not yet, I have to add the usernames to the search index (and pagination, otherwise it will be a lot for some users)

Kartik Agaram just added msg sender username and real name to the index and reindexed, if you search for Agaram you should get all messages that you sent or were mentioned, next task is pagination (for some reason if I search "Kartik Agaram" it returns much fewer results

Do you mean Qt vs GL vs DX vs GUI, etc.?

Chris Maughan yep

My tool is designed as a shader authoring tool (in part), so my plan is to support rendering using GL, DX12, Vulkan. This is for the shaders/graphics the user creates. GL because it is a guaranteed lowest common denominator. DX12/Vulkan because they are the cutting edge. I don't want to use Metal if I can help it.

For GUI elements I have 2 approaches:

• ImGui. This sits on top of the API's I just mentioned and does buttons/checkboxes/windows, etc.
• NanoVg. This is a vector drawing library along a similar vain to ImGui. It has slightly better support for pattern rendering, and is a bit simpler to use for basic primitives. It also uses GL, etc. for the bottom level of drawing.In this image, ImGui is drawing the left hand text editor, the sequencer along the bottom. NanoVg is drawing the Nodegraph UI inside the top right window. And everything sits on top of OpenGL in this example.

My choices are based on ease of use and cross platform. Using custom GUI code for each platform is out of the question.

I have a version of the text editor in the image that runs on Qt. Qt is a good cross platform choice for 2D/UI frameworks, but it is my least favourite API to work with (I do it for a day job too, so I am proficient at using it). Qt is powerful, but can be very frustrating. On the other hand, using it as a way to get a QPainter and draw shapes would be an easy cross platform method.

I use SDL to do the heavy lifting of creating OS specific windows for drawing in. SDL is a great way to get a window on screen. ImGui integrates will with it. So my pathway is SDL->OpenGL/DX->ImGui OR NanoVg

Chris Maughan Thank you! I already knew about imgui, my question was more targeted at rendering stuff like dataflow graphs, but nanovg might be what I'm looking for. I'll look into it:)

Something I am unable to use but would like to is the Slug library for text: https://sluglibrary.com/ As far as I can see this is the gold standard for rendering text on a 3D Device; it looks far better than what I have come up with so far (on a par with OS/GUI font rendering). Unfortunately it is commercial, though the author has hinted that he'd love some company to buy it and make it free.

ImGui is quite capable of drawing shapes for you. You can drop into a lower level and draw anything you like using the drawing code. Many people do that for custom GUI

https://github.com/cmaughan/imgui/blob/master/imgui_orient.cpp

This is an orientation gizmo I did; it renders entirely with ImGui (I think I ported this from somewhere, but I've forgotten... 🙂 Ah, yes, it was from 'AntTweakBar'.

Found this in the readme of nanovg, idk if it should but this kinda scare me away from using something...

This project is not actively maintained.

So you see, you can even draw triangles in ImGui if you want to.

Yeah, NanoVg isn't maintained any more. I've had no problem using it 😉

If you are getting started, I'd use ImGui.

https://github.com/ocornut/imgui/issues/306

Have a look at this thread ^ it contains custom node editors written using ImGui

Thank you!

I'm using NanoVG (which is OpenGL based) ... I know it's no longer actively supported, but it's in plain C and a lot simpler (IMHO) than imGUI.

I'd love to see more answers to this!

I'm unhappy how state is managed in every OOP framework and every framework that uses a VDOM. I think neither mutability with objects nor mutability on another layer (vdom) works well.

Building something else has been hard for me. Text rendering especially.

Building something cross platform makes it 100x harder.

Using the web platform doesn't work, when you try to build on a lower level: You can't even measure text dimensions easily.

I've tried building up my own cross-platform solution based on WebGL, WASM (Rust), but failed at font layout. Compiling harfbuzz to wasm just didn't work for me, despite some people claiming to have done that.

So, I'm considering non-web solutions again. Basically, I'm really interested what others have to say.

Also, adding a reference to Raph Levien's work here, as I think he's also interested in this space: https://raphlinus.github.io/

Philipp Krüger I'd actually be really interested in giving a rust-based solution a try :D

@Matei Adriel There's rust stuff happening here: https://github.com/linebender and also some relevant stuff (for me mostly) here: https://github.com/RazrFalcon/rustybuzz

But it's very experimental. Hard to say what these projects are going to become, in what direction they'll evolve, and in what time they'd be viable. 🙂

Fonts are always hard, especially for smaller text. An HD display helps a lot - the problem is lessened on a 4K screen 🙂 As I said, the Slug library is probably an easy solution if you don't mind paying or just want a prototype. I've used Direct2D on windows before; that is nice renderer. Qt is very nice for fonts as long as you are happy to bite into that huge apple.

Another approach is to use an OS specific renderer to draw your specific text onto a texture and then apply it in the engine; that gives you the best of both worlds, but you need to write custom bits.

I've heard good things about HarfBuzz; I really should get around to building it.

I'm pretty sure harfbuzz itself is very mature, this is from their wiki:

The current HarfBuzz tree, used to be also known as harfbuzz-ng, is under active development and is what is directly used in Firefox, Chrome, LibreOffice, XeTeX, Minikin/Android/Flutter, PlayStation, Qt/KDE, GTK+/Gnome, Java, Emacs and Unreal Engine among many other places directly or indirectly.

Yeah, it's just big/complex.

WebKit direct DOM manipulation via Javascript

I was playing around with a shader editor and built on a similar stack as Chris Maughan

if you're not used to or wanting to specifically interact with low level GPU APIs I wouldn't recommend it though

I specifically wanted to play around with raytracing, wave instrinics, and maybe in the future mesh shaders

as well as gain some more knowledge of how things are done in the DX12 API. I'd done some hello triangle stuff in Vulkan and done a lot of DX11 work for various jobs and side projects, but hadn't officially touched DX12

IMGUI is really nice though

I use Vulkan and imgui in my own project, Onex.

And, to echo comments above, I also use lines and triangles in imgui to draw arrows. 😊 I had to remember some school maths. 😧

If I was working on a higher level tool I'd either do it with something browser based, or using a game engine

I tried browsers and game engines. Never again

why not?

Way way too much baggage. It's liberating starting from the metal (no pun intended)

Not sure it's more work: fighting incompatible models Vs writing more code..

Basically you're up against decades of assumptions around The Web and The Game, resp

fair enough, I think it depends on what you're working on

If you start with Sascha Willem's example code, it's pretty easy to get going

you can also go higher level than Vulkan + IMGUI and lower level than Unity or Unreal 🙂

like using sokol, or bgfx or something of that nature

even wgpu

I'd argue that for all of the FOC projects I've seen Vulkan is overkill

and GL would be fine, or DX11

OK. True nuff. Just wanted to be ahead of the curve 😊

Basing on imgui means I can always switch

But not when I start doing the serious 3D stuff obviously.

Which is a while away. 2D will keep me busy for a bit

if you're using subgroups in vulkan, or some fancy usage of descriptor sets or resource binding, etc. The thing about Vulkan is using it naively will give you worse performance in many cases than using GL or DX11 naively

but that doesn't actually matter for many use cases

+1 to imgui for rendering

for something more complex like a fullblown editor, you'll need some statemanagement & databinding solution

i'm personally biased towards the immutable + unidirectional flow model and have my own library to handle it

but if you're in C++ and have a tolerance for templates, lager is a good library for that: https://sinusoid.es/lager/#contents

Chris Maughan curious why are you using nanovg at all given your usse of imgui? (ps thx for zep, it's my code editor widget still)

@ikrima thanks for the link to lager btw, I wasn't aware of an Elm style library for C++

it uses std::variant and actually uses the words "stringly typed actions" (although discourages usage), so maybe not great for high performance run time but completely reasonable for most things

👍 the author's pretty great and I use his immutable persistent data structures library. honestly the biggest reason i had to roll my own was bc it's heavy template usage (and it links boost.hana)

yeah...

(more of a criticism of C++ vss. the lib; i'm not sure there's a way to do it in C++ otherwise. case in point, my version eschews type safety + uses C++ JIT codegen)

Scott Anderson re: elm - have you seen a library in the general ecosystem that has a good approach to UI databinding?

imho, WPF has been the gold standard but not familiar with elm + broader landscape

I already made a demo-ish visual fp lang using purescript (which runs in the browser) which was rendered to a html5 canvas

But I'm trying to switch to desktop dev

Since IMO the js tooling is shit

The thing about Vulkan is using it naively will give you worse performance in many cases than using GL or DX11 naivelyDoesn't everyone use Vulkan naively? There are probably 3 people who actually know what they're doing, it's so insanely complicated. I rely on Sascha to be my code chef and sprinkle some of my own seasonings on!

Im comfotable in rust + a bunch of fp langs (f#, haskell, purescript, a few more)

It seems like all the stuff you guys recommend is c++ based

I did some c++ for school a while back but I'm by all means a beginner at it

I'd stick to C if you can, then. 😊

imgui is annoyingly C++ but doesn't really benefit from it

All basic graphics techs are in C

And God codes in C apparently

also just in case it was implied, i'd like to clarify that i do not recommend C++ but if you are forced in C++, here's some stuff.

imgui i believe has a cimgui binding (used in sokol)

https://medium.com/swlh/what-makes-godot-engine-great-for-advance-gui-applications-b1cfb941df3b

relevant maybe?

I actually want to use Rust, but for side projects I decided learning Rust (which I don't know well) + learning DX12 or Vulkan + actually making a somewhat useful toy application for prototyping was too much

and it wouldn't be learning idiomatic safe Rust, it'd be learning unsafe Rust in order to interface with a low level API

also, no not everyone uses Vulkan naively, professional game developers with performant Vulkan engines don't use it naively, my (maybe long winded) point was that using Vulkan is probably overkill for hobby projects and doesn't give you anything that OpenGL wouldn't, and might actually be measurably worse

but if the goal is to learn Vulkan or use features that only exist in Vulkan (mesh shading, ray tracing, etc.) then definitely use Vulkan!

in any side project I've done with Vulkan or DX12 I've used it super naively though hah

re: Godot: I went all-out with Godot but hit the issues I mentioned above

re: Vulkan: like I said, I /naively/ (!) thought I was being all leading edge 😄

I am considering going back to my old friend OpenGL|ES 2, or 3

if Vulkan is working for you no need to switch

and Vulkan could unlock some great things

Scott Anderson hot damn, thanks for that godot link!

Godot is the best OS game engine, don't get me wrong

just too much of an impedance mismatch to my C code!

For rendering my UI, what I want is a cross platform, high level, GPU-accelerated graphics UI that goes far beyond the postscript/SVG 2D graphics model. It should support hybrid 2D/3D, and it should be extensible using procedurally defined graphics primitives (signed distance functions) as seen on http://shadertoy.com. So there are no limits to what a UI can look like. You aren't boxed in by the SVG 2D rendering model or by what HTML/CSS can render.

Shadertoy code has performance cliffs. To make this efficient, it should use an extended version of Raph Linus's GPU accelerated rendering architecture: https://raphlinus.github.io/rust/graphics/gpu/2020/06/13/fast-2d-rendering.html Briefly, there is a display list of primitives loaded on the GPU, the viewport is partitioned into tiles, and each tile renders only primitives visible in that tile.

Cross platform means Linux, Windows, MacOS, Android, iOS and web via WASM and WebGPU.

Anybody want to help build this?

@ikrima I'm using NanoVg for 2 reasons; firstly it is simpler than ImGui for rendering basic primitives, secondly it has better gradient pattern support (last time I looked); and I'm using that for subtle effects here and there. NanoVg needs only a few lines of code to draw stuff, ImGui needs significantly more for custom.

Glad to hear you are using Zep; I haven't given it enough love lately; but I will shortly be doing another round of bug fixes.

If you have a screenshot of it in-situ, would love to see.

I heard out 'Lager' just yesterday, sounds like an interesting project.

So your guys recommendations are to learn more C?

There are language wrappers around all this stuff (maybe not much for shader code which is very c-like). So it's not essential; but I'd imagine a low level 3D coder would have an easier time with C/C++.

I personally use C++, since I'm doing low level coding, and all of the graphics libraries that I need to use are written in C++. There is also a graphics programming community using Rust, and they are doing some cool things, but it's tiny compared to C++.

If you're doing low level graphics programming C or C++, followed by Rust, followed by C# are probably your best options just in terms of ecosystems, platforms you can target, examples available, etc.

you can do other languages of course

js is probably better than most, but the lowest level you can go with js is WebGL\WebGPU

I completely missed this thread

but I was working on a VR programming language at Facebook for Facebook Horizon last year

I've been meaning to write up notes, and share them

I've kind of been waiting for Horizon to actually ship... no idea when that will happen though

it's been almost a year since I've worked there so I imagine the actual programming tools look very different than what I was proposing anyway

As for coding in VR there are a lot of examples and things you can try

Dreams just shipped a VR mode

the interface is the same as Dreams outside of VR though, so it's kind of 2.5D with panels you interact with with a laser pointer

Check out RecRoom, AnyLand, ModBox, etc. if you want to see various attempts at visual scripting environments in VR

I was pushing for exactly this

https://futureofcoding.slack.com/archives/C5T9GPWFL/p1596125757391300?thread_ts=1596124901.389500&cid=C5T9GPWFL

It was designed to be a hybrid tangible\block based programming language, where you had a palette of blocks, I was pulled off interface development due to re-orgs and manager\director pressure

so we ended up with something that used the standard laser pointer driven 2D UI

and was extremely clunky

but it worked...

yeah I need to write up notes 🙂

I've been thinking about programming in VR for like 4 years and I've never written a public comprehensive collection of my thoughts

For those of you interested in text based programming in VR there are some fun toys and prototypes

https://store.steampowered.com/app/458200/Rumpus/

There are quite a few Javascript based things as well

https://cognitive3d.com/blog/programming-in-virtual-reality is an early example

I tried to find some more recent ones... but meh

I actually think text editing in VR will be reasonably good sooner rather than later

I give it a year or two for 4K displays (probably not with varifocal displays, sadly), and pretty good tracked keyboard support

At least in a future Oculus device

Also... even though this isn't coding in VR it's relevant to FOC https://www.youtube.com/watch?v=ydyztGZnbNs

John Carmack built a live coding environment for Gear VR based on Racket, that ran an HTTP server on the phone

a prototype version was actually released as while ago

I imagine there are a lot of folks here that are interested, at least tangentially, in programming in VR, but it seems like people know very little about the space (there are Wiremod style systems in RecRoom, ModBox, Dreams and others)

https://www.youtube.com/watch?v=x3a76Q5a-n8

https://www.youtube.com/watch?v=fNXyKB8Qb2o

https://anylandvr.fandom.com/wiki/Scripting

Scott Anderson thanks for sharing all the insider details 🙂 would love to hear your extended thoughts whenever you get the chance.

I remember getting excited about this but being dissuaded by the goodreads reviews. If anyone in this community finds it compelling though let me know!

I just received a copy ❤

Finally got around to look at this... nice! Reminds me a bit of http://www.leoeditor.com/, which has been around for many years and has a relatively small but enthusiastic user community. Leo is less sophisticated in being based on a simpler data structure (just nested lists with text at the leaves), but it also permits including code that can do queries and manipulations.

Do you mean how future-oriented programming languages move away from those constructs?

or how they don't move away 🙂

or sideways 😛

Dependent types, typed holes, pure functional languages, all have interesting ideas. Then there’s state, I highly recommend Rich Hickey’s talk https://youtu.be/-6BsiVyC1kM

data exists before entering the system and its shape not necessarily matches what a type system would like to handle

https://xkcd.com/1838/

That's two questions!

I distinguish "null" from "undefined"; there's a difference between "nothing known (yet)" - undefined - and "known (to be) nothing" - null.

at least two questions

Or between Not Applicable and Not Available

I once implemented integration for a system that sent numbers when there were numbers, empty strings some times (I guess it meant no data) the string "N.A." some other times

The other question, about types: My types are basically syntactic: strings that can be matched by parsers. So any property can change type if it wants.

I see "null" as a very bad implementation of "missing".

In general it's an attractive pattern to be able to build up an object gradually over separate steps. The way C++ or Java are designed, the easiest way to do this is using null. (It can also be done by using lots of separate interfaces, but this is more work).

The reason null is a billion dollar mistake is because it allows you to 1. null everything, 2. retrieve a null value.

If the null pointer exception was thrown at the moment you called x = obj->value (if value is null, not obj) it wouldn't be able to permeate so much.

JS actually does the concept of 'missing' correctly but then throws in null as a kind of turd in the punch bowl.

The other point has been addressed by modern languages such as Kotlin where properties must be explicitly marked as nullable (I would make it 'optional'), and then reference with ?> instead of ->

I tend to see null as ‘optional’, and then handle ‘partial data’ as a different ‘entity’: http://theprogrammersparadox.blogspot.com/2015/11/containers-collections-and-null.html

The ideas I'm kicking around for values that change type over time look vaguely like dependent types, specifically types that depend on a time or generation/version parameter. I don't think you can avoid ending up with something morally equivalent to dynamic typing: you're going to branch on (or use as a lookup key, whatever) the current type somehow, even if you manage to stash the branch in the runtime. I more often think of this in terms of migrating between different serialization formats or database schemata. Maybe another (equivalent?) perspective is as a discriminated union type where you keep adding variants over time. (Have you ever noticed that an instance of a sum type looks a lot like a dependent pair, with the payload dependent on the value of the discriminant? Is that an artifact of my shaky understanding or does everyone know that already?)

here’s a very pragmatic approach to null in the (unfortunately dormant i think) tulip programming language: https://youtu.be/lvclTCDeIsY

and @Andrew F here’s one of Tulip’s designers talking specifically on variants: https://youtu.be/ZQkIWWTygio

Garth Goldwater that looks neat. Tagwords are a great idea. The little ascii faces are great too. :)

I second Hickey's talk - interesting questions in there.

I have more than a few things to say about this topic. My position is that the generic nullability is bad. Also, empty strings are bad. Yes. Think about this: we've had the concept of 'zero' for 1000s of years but only very recently added the concept of 'empty string' - why? Could it be mainly for modeling in computers? There is no zero-like symbol you can write in a paper form where text is expected. Yes you could write N/A but that conflates null and "". Sometimes you might be asked to write why it is N/A.

Consider that there are valid questions for which the meaningful answer is zero: "How many toilet paper rolls are there in the store?", "What is the temperature of the snow?" etc. There are no questions where the 'empty string' answer has a clear-cut meaning: "What is your spouse's name?", "What city do you live in?" etc. What does an answer of "" mean? It could mean "I don't know" or "I dont want to tell you" or "There isn't one". Can these always be mapped to null or ""? I don't think so.

In type systems that have both, the empty string and null, you end up with the question of 'what does null mean' vs 'what does empty string mean'. Sometimes when you have two missing values in the world that you want to model - you end up mapping these to '' and null. But really this has nothing to do with a generic solution - it's often just a reality twisted to fit the types. If you want to model three missing values e.g. 'unknown', 'non-existent', 'secret/intentionally-blank' - how do you map these to "" and null? Maybe the best solution here is to model the value as an enum? unknown, non_existent, intentionally_blank, value(real_string_here) . AFAIK no systems, languages have a great solution. However I feel better solutions lie in exploring the 'information modeling' space - RDF etc (perhaps with some kind of versioned schemas to describe what is possible and necessary.) Basically we don't want multiple data representations to correspond to a single reality (which is what happens in null vs "", or sometimes with nested option<option<option<t>>>).

Shalabh Chaturvedi to add to your points on how reality and implementation play into our constructs of strings. If we take away implementation and ways to model them, strings are really just symbols in a https://en.wikipedia.org/wiki/Total_order. In that context, spaces don’t make much sense, neither do tabs, empty strings too. In my humble opinion we need to build a construct for orders and symbols (not just text, but any symbol you can imagine) and then modern string types can be considered special cases where we are talking about a total order of ‘text’ symbols.

In Onex I have no empty string concept and also no control characters (space is a control character in that statement)

Duncan Cragg sounds interesting! Do you have a link?

I have unknown (perhaps like undefined) and nothing (maybe that's null) as distinct concepts or special symbols

Oh hai Orion, um, documentation is a little thin and/or dated 😧

Other shocking things about Onex: a property can be a single symbol but you can add more symbols, at which point it becomes a list. Indexed from 1. 😊

Maybe I should write an up to date description of this..

@Orion Reed I assume you mean a total order on words? Yes that could be one way to model strings. 'Text' however is a widespread concept outside computers and often mixed in with presentation as well (are paragraph boundaries important? Are underlines important?) So in some sense having a flexible 'container' of media provided by the user is reasonable too. Kinda like a 'bitmap drawing' or even 'rich text'. I don't think strings are particularly fundamental - they model some aspects of text (e.g. paragraphs) but not others (color, underline). In any case, the system won't look inside this media object to make decisions - it will just pass this object around and the meaning is entirely interpreted by another person at some other time. This is where I think "" and null become interesting: often we write if text is none: ... . So the system does look inside this shape.

The 'auto-list' model is interesting, and probably right. "I have one apple" should only be represented one way, so apple vs [apple] looks suspicious.

The thing I find interesting is that if a single value is not a special (and default case) then you don't need null or similar

if everything is a sequence (of potentially zero or one items), then an empty sequence would be "null", the cool thing is that if operations on values internally translate to map then handling the empty case comes for free. This sounds a little bit like "nil punning" in clojure, which is a pain when you find a nil and don't know where it became nil since everyone is passing it around happily

In Onex, empty sequence=empty symbol=nothing =the whole property isn't there. In an object property, if you empty the value or clear the list, the property itself is deleted; if you want a placeholder you just use unknown

conflating nothing with unknown is a source of uncountable glitches in the history of software

Note that this is all to help non-techies feel at home. Yes, non-techies would wonder why apple isn't the same as [apple], or even why have those brackets

so I have fruit: apple then fruit: apple pear and no brackets, no "list type"

and so fruit:[1] will always be apple

If undefined means "not known yet" and null means "known to be nothing", then what about the situation when a value is known to be the value undefined ?

(just recovering from the neuronal warp that question induced)

maybe "not known yet" can also encompass "not known, and who knows why or when"

got any examples?

i’m dealing with that trying to do something somewhere between (un)typed holes and a structural editor—if a user has a key but its property isn’t defined yet, and then they skip ahead to elsewhere in the syntax tree, i’d say that i know they want a value for the property later but it’s not strictly defined yet

pretty sure i can just like... ignore that situation though lol

i haven’t stopped thinking about your no lists/everything is a list model Duncan Cragg... i think you might be spiritually correct, not making afforsances for user convenience

reminds me of how a lot of stuff “just works” in APL as a result of rank polymorphism, but also seems a bit further than that

In Python, there is no char type. They are just strings of length 1. So a[0] == a is true for strings of length 1. You can also loop over them for char in a will work for zero, one or longer length strings. Things don't come crashing down.

BTW, one angle to think about this is that 'nothing' is a property of the field itself (e.g. fields are boxes, and one box is empty). While 'unknown' is a special kind of object that I can put in a box. Interesting.. can I put two unknowns in a box? Or an unknown and an apple?

I think that falls apart if you can get back 'nothing' as a value. But if you can't, then what happens when you try to get it? The only other options I know are throwing an error, or some kind of Haskell-like "Maybe" construct

Shalabh Chaturvedi to avoid that problematic subtlety, I don't have empty boxes, if you empty it, it disappears! (i.e. the object property is deleted) If you try to get it, you get nothing back.

You can put fruit: ``unknown`` apple ``unknown`` banana, yes

But fruit: ``nothing`` apple ``nothing`` mango collapses to just fruit: apple mango

and of course fruit: ``nothing`` banana is just fruit: banana (no list any more)

@Dan Cook what falls apart if you can get back nothing ?

If nothing is not a value and just a property or state, then what is the result of getting nothing? If you can get back nothing, then nothing has to be a value.

... But the solution you just described (i.e. nothing just disappears from containers) is interesting! So nothing is somewhat like a value, but it's a disappearing value.

I suppose it depends if you're on the "left hand side" (matching) or "right hand side" (setting) of a rewrite rule. If you're matching, you have to be able to match with a symbol, so can use nothing to say you really want that to be absent. If you're setting, and use nothing, that's when the disappearing trick happens.

Obviously, with homoiconicity (ooo), you can't let the rewrite rule itself reduce because the matching side will disappear!

“Experienced programmers don’t think in text at all”

I argue the premise of that statement is flawed. It’s misleading, suggesting that “programming languages” are flawed because they are text.

Here is an example.

• Send a text message. In order to model that out we may need some tool for entering data, import Twilio package, get an access token, call an API, store some data in the database. In this domain of abstraction perhaps we can say Jonathan is correct because it’s very non-linear — However, I detailed the high level steps in plain English. I also could write those down in a backlog, in text… so I kinda am thinking in text, but it’s not the final nor exclusive step.
• Take the same example in another product; Alexa or Siri (just for example) — Do you still “think” in text? I say the premise if flawed because it’s misleading. It’s not about “how you think” it’s about how you understand (read) and how you create (write). The “think” part is more personal and cerebral.

I wrote this feedback in text. Are you “thinking” in text when reading it? Likely not… you likely have emotions, feelings, “thoughts” — not text.

TL;DR No one “thinks” in text or diagrams — they think and then translate thoughts into a medium that can be shared.

I interpreted it to mean think at a higher level than text. Like not in detail, in the overall structure. So doesn’t mean it’s not composed of small chunks aka “text”

I have the same interpretation as you, Ope. The example of a painter painting or someone driving a car resonates. Many times when that painter or driver is going through the motions or "in flow", they aren't mentally "available" to stop and describe what and why they are mixing colors in a specific way, or way they changed lanes to make room between cars.

I don't feel like I think in "text" when I program. I feel like I'm thinking in usages and domain models.

It’s also a fluency thing.. like this https://twitter.com/opeispo/status/1291079668817428480?s=20

That's an awesome analogy, too!

What's great about podcasts is I can listen to them whilst doing other things (lately cooking and cleaning). So I feel like this runs against the grain of what makes podcasts successful.

However, I agree that podcasts do lack these features. For example I really enjoyed the FoC episode on Orca but at some point I needed to stop and research what Orca was. And a lot of 99 Percent Invisible episodes come with an attached article with visual references.

Maybe there's an opportunity here to allow me to stop what I'm doing and have a quick glimpse at my phone to get a visual reference (eg. an Orca gif) so the podcast can continue uninterrupted.

yeah i would love a podcast player that let me tap or yell at siri for bookmarks, especially if those bookmarks connected up to a transcript and links

I've done something similar with a presentation, but allowing scrubbing through at the word and image (slide) level: http://vitor.io/uxr101

"hyperaudio" and "hypertranscript" are terms of art that'll turn up other related implementations

and their slack is http://hyperaudio.slack.com

What does the minimap on the right represent? Distance in text vs audio?

This is really useful for me. I generally read the transcript and sometime read and listen. I never only listen to it. The reason? I am more fluent at reading English than listening to it. And you can read at your own pace slower, faster, or read diagonally.

So for me this is great tool, I can jump to some paragraph and have the equivalent audio playing right away.

And +1 for the links and images of course.

Ryan King

have a quick glimpse at my phone to get a visual reference (eg. an Orca gif) so the podcast can continue uninterrupted

Yeah, I think that'd be useful — not necessarily need to include full transcript, just mapping some images against specific audio periods is useful enough. Thinking about slides + audio, could be a great way to record lectures, esp visually intensive ones such as https://cmsw.mit.edu/podcast-gediminas-urbonas/

Vitorio Miliano Great work! Reminds me of https://www.dougengelbart.org/content/view/374/464/.

Hyperaudio seems interesting, will check it out. Although I don't like the website app approach. I'd want to have a open standard for a language, similar to WebVTT/SRT, for writing HTML (as opposed to text) against audio time.

Kartik Agaram

Left side: Each paragraph's vertical position, measured against the full height of the container of all paragraphs

Right side: Each paragraph's starttime, measured against the full audio duration

Nicolas Decoster

So for me this is great tool, I can jump to some paragraph and have the equivalent audio playing right away.exactly, i enjoy being able to use Cmd+F to find what I want to hear, read 1-2 paragraph and start listening from specific points

i also like that I can share you a URL with you like "hey, this is an FoC episode where they talk about letting government fund OSS with tax money": https://foc-new-podcast-player.netlify.app/#00:38:16

I will tinker around with this! Thank you 🙏 for sharing

@Pine Wu, fyi, there's a w3c standard for specifying a timecode in a URL fragment like that: https://www.w3.org/TR/media-frags/

Vitorio Miliano Thank you. I didn't know that before. I'll make the hash follow the spec then 🙏

Context: as we are working on https://nodes.io and hit similar questions i can share what approach we are taking now.

Out platform is based on JavaScript and npm so it allows extensibility and bring-your-own-lib as you wish. Because of that and the nature of our own work (data viz with big or sensitive datasets) we decided to go for desktop app where you own your code and data. To enable git, graph layout is stored in json (ok not the best format) and each Node's code is in it's own CommonJS module. Additionally you can compile or export your app to one bundle.js+html+assets package for deployment to static hosting.

As we enter the public beta soon we are left with dilemma on making this sustainable. This is internal tool that pays the bills by supporting our project so in theory we could open source it but there is no resources for full support, PRs, community etc atm. So our current idea is to have free but proprietary IDE app with licensing limiting commercial use ("pay if you earn") and open source runtime allowing you to compile your project from command line to safeguard your projects even more.

I can see two ways forward:

• Nodes Pro where we have some advance or niche-specific features in the IDE (e.g. realtime collaboration, cloud hosting)

• Content: where you try to leverage your know-how and provide value through paid nodes bundles (e.g. for architectural visualisation or ML) or courses and premium learning materials

As mentioned in the original thread going free and open means anybody can do two above but there are benefits in community, opportunity gain for parent company, paid customisation gigs etc.

i think the biggest deal for open source and platforms is not getting bitten if the company goes out of business

i think that’s why a lot of the success stories (wordpress, red hat) have to do with support contracts and hosting—those are businesses that others could take over if say automattic went out of business

i think collaboration makes a lot of sense too (and i wouldn’t describe these as “niche features”)

but as far as development environments go, id rather see them be open source with a plugin architecture—then hosting and collaboration could just be two default available plugins you provide, developers could make their own (a la figma) and you could run the default marketplace, too

A few things that may seem out of place on this forum, but are nonetheless within the question's territorial boundaries:

• reading fiction -- a distressingly large number of people think non-fiction is how one learns about the world, but (good) fiction is tremendously instructive about what it is to be a person
• physical culture -- in addition to health and wellbeing, there are lessons about the value of daily practice, the way imperceptible improvement can become tremendous over time, &c.
• meditation -- combines some of the benefits of the two aforementioned things
• art -- or really any practice that operates more on intuition than reason (both are human superpowers, best used together)

I’ll start!

Bret Victor’s https://www.youtube.com/watch?v=8pTEmbeENF4 is a fun and historical retrospective (retrofuture?) and the one everyone should watch until they get it, then watch it all over again -> https://www.youtube.com/watch?v=PUv66718DII&feature=emb_title

Alan Kay’s https://www.youtube.com/watch?v=oKg1hTOQXoY is not only a superb title, but also packed full of important and impactful ideas.

Joe Armstrong’s seminal talk, https://www.youtube.com/watch?v=lKXe3HUG2l4 makes a strong case that we are, in fact, in a mess.

Lastly, a talk I was not expecting to find so much value in, but one that clarified and fortified my ideas around decentralised tech i.e. blockchain. https://www.youtube.com/watch?v=G0rZcpfF5dU

“The most dangerous thought you can have as a creative person is to think you know what you’re doing.” — Bret Victor

“In the last 40 years we have written billions of line of code that will keep programmers employed for trillions of man hours in the next few thousand years to clean up the mess we’ve made” — Joe Armstrong

we need our slack solution so i can properly collect the right talks for this question lol

Totally!!! There is so much knowledge and community insights and right now not good enough search even on my own threads.

We Really Don't Know How to Compute!

https://www.youtube.com/watch?v=Rk76BurH384

This one is a bit scatter-brain, but it got me questioning the status quo in the first place:

(It's not as much about DCI as the description suggests. It's more about what's wrong with the state of software culture and practices)

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

While I do like good talks I think a kind of “future of coding” value/argument map could be more useful. Anyone feels in the same way ?

@Andreas S. while I do agree (and internally I think about lots of things as a sort of topology) I think to get there we’d probably have to gather talks, articles, quotes, software, and more before we had a chance of being able to compress it down into a 2D-3D space.

@Orion Reed do you have tools or finished visualisations of these topologys?

I am certainly biased in this conversation.

I do agree that world is inevitably messy and that we have to deal with it. It is for this reason that I believe a new language to create systems, while well intended, is unlikely to address the problem of existing systems already out there.

At the same time, I do believe that we can make significant advances by focusing on the reverse part. The skill of reading the code we have is essential. And that cannot be improved significantly if the only form we have to read is text.

We should distinguish between a storage or exchange format for a content, and the interface through which we interact with the content. I can send an HTML file around, and still choose to view it in a browser. The two are distinct and still can coexist. The way we read doesn’t have to, and should not be the same as the way we edit.

Here's a fellow crotchety old Will. 🍷 I do like to factor in why-are-things-the-way-they-are when thinking how they might be different. Sometimes it's an accident. Sometimes there are deep reasons. Text is awfully flexible. Once you get into it, there's quite the gravitational pull.

One possible reading of "shipping the renderer" is that the document can be shipped as a program that renders the desired output in a resolution independent manner as a side effect of it being run. If this sounds like a crazy idea, consider that all Postscript and PDF documents are exactly this (the underlying language is essentially a dialect of FORTH). The inventor of those technologies was John Warnock who was at Utah with Kay (in fact, they shared a PhD advisor in David C. Evans; Warnock's other advisor was Ivan Sutherland, the person who made SketchPad).

I fully agree. Well, mostly, in fact, I could discuss the part about text files, but I guess you only mean (or don't you? 🙂 ) it as an illustration, so I skip this discussion...

As for the context, I agree it is a very important aspect. It is which gives lots of inertia to what is happening and what we can change. And you have to be aware of that when you work on FoC projects. To use the cost function metaphor, we are at a local minimum. And all the social/technical/economic contexts explains why we are at this minimum. They are the force that pull us down to it.

So what is this local minimum? Is there other lower minima? Where are they? What is the path to go there? etc. And as Foc builders I agree with that we must know all this: the minima we want to reach and the path to go there. And you will do some compromises.

As an illustration, in my case, I identified that one context aspect of the current local minimum that is hard to go away for me, is the web plateforme. If I want to provide something that can be used by most of the people soon, I know the web plateforme is a very good fit. And even if it has lots of technical problems that I want to get rid of. So I decided to stick with this aspect of the current local minimum of "the present of coding" and choose to work on other aspects.

Here is another illustration of how to be aware and how to deal with these context aspects that are local minima. It is about adoption and audience. Something about the social context that is very costly to "move", is the current "programming audience". It is very hard to change habits and well established "standards", even if there are problems with them you want to change (random concrete example that I encountered: bash scripting). So one very risky and difficult strategy is to decide not to target this audience first and hope it will be convinced later. So I guess I will try this strategy, I want to propose new programming tools that I know most of today programmers won't want to use, so I will first target new programmers, that are not bias by the current programming context. Then if things go well, keeping the good parts of what I will build, maybe current "established" programmers will use them. So it is an other way to be aware of the context and try to deal with it to build a FoC vision.

But I’m always extremely skeptical when they don’t address > why>  programming became the way it is.

It's important to consider the context. Why things are the way they are today. But also why things were the way they were yesterday.

Back then is was assumed that to use a computer one has to be a programmer. There was no distinction between programmer and user. It was the same. We've given that up, clearly. Even though many of us here seem to question if it has to be like that.

We are much further down a certain branch of the design space and it only ever gets more complicated from here. There's only so much we can "fix" here, if we stay on the same branch, take the present as given, and only look towards the future.

But what other places could we find, if we're willing to backtrack to a much earlier time and take a different branch from there?

Shipping a rendering engine with an HTML file would be a technical nightmare.My FoC project will eventually do this on the browser using Web Assembly and WebGPU. Shipping your own renderer is what WebGPU is for.

As a specific example, my FoC includes zoomable UIs (ZUIs), one of those really good ideas from the 1970's (eg MIT's "Dataland") that never became mainstream. You can build a ZUI in the browser if you ship your own renderer. Eg, see http://wdobbie.com/warandpeace/

If only everyone had followed this good old idea, everything would be great by now!

I disagree which statements of this form too. I don't get this sense from most "FoC cannon" though. My interpretation is more like "hey this research trajectory looked really promising but never got funded, explored, developed, (in fact due to social and economic factors)". Possibly in the alternative reality we would have a new set of problems and issues. The FoC group (that's us in the alternative present!) would be discussing those problems and solutions in this slack really advanced multi media collaborative space . The question I ponder is: would we be looking at Unix + text files etc. (the "alternative that didn't happen") as something potentially better? I tend to answer "no".

Shipping a rendering engine with an HTML file would be a technical nightmareIt's called "an app", in a large number of cases. And yes, technically a bodge.

Will Crichton: Yeah. To the extent that the future of software is inseparable from the future of critical thinking, these statements feel counter-productive. Even if they lead to good ends (which is questionable), means matter in the long term. Our canon feels impoverished for being phrased in terms of stone tablets from on high. Too much emphasis on aesthetics ("how cool is a retrohistorical talk?!") Here, I'm going to spin up a new thread..

Certainly a respect for the constraints of our predecessors will avoid us from tripping over Chesterton's fence. However, it's worth noting how most tools are designed to edge toward a local min or max rather than a global one. I appreciate the "What if" because we don't know what a local min or max would have been like if a different paradigm had been embraced.

Sadly we are often left in situations where we have built quite the city in a valley when we realise that the next valley over would have been a better location. I am not presumptuous enough to expect an entire city to get up, move over, and rebuild in unfamiliar lands, with new materials, and new constraints. However, I do expect that new city to grow while the old one slowly crumbles-- if those that settle the new city are right.

(BTW, my favorite story on this is from SPJ when he remarked that the slow uptake of Haskell in industry had given them the chance to make big changes. He had a respect for the tradeoffs that getting more popular brings: rather than seeing popularity solely as a sign of success, he saw it also as a boat that took more time to turn)

David Piepgrass - There might be some overlap / similarity between what you described, and @François-René Rideau's "first class implementations"

Thinking in trade-offs feels like a synthesis of Will Crichton's and Stefan Lesser's positions. Yes, you have to acknowledge context. And yes, sometimes the context is a dead end to be ignored/transcended.

This prompt also feels like a gentler version of the [https://futureofcoding.slack.com/archives/C5T9GPWFL/p1580718026447200 thread from... the before times.

In that my iconoclastic trade off is (of course) something like: you should accept that not all incidental complexity is avoidable, but what incidental complexity you have should be https://futureofcoding.slack.com/archives/C5T9GPWFL/p1580751504462400.

(Also — https://futureofcoding.slack.com/archives/C5T9GPWFL/p1580762349483300, for anyone who missed it the first time around)

In fact, trade-off is also at the very core of the programming activity. It is good to know that as Future of Coding designer. You design tools with which people make trade-off all the time.

Making and managing trade-off in programming is hard and intimidating. How the current state of programming actually helps programmers in that task? How to do it better?

That’s what I don’t understand: as programmers we make trade-offs all the time and we deeply understand the complexities involved in these trade-offs.

But then when you listen to programmer conversations a lot of them are about how “it’s clearly better to do it a certain way”, as if that’s so easy to determine without having (and often not even attempting to learn about) any of the context.

my tradeoff is interactivity over abstraction. games are more fun (and faster) when you move your own avatar, not when you write a bot

Great answer, though I'm hopelessly addicted to bot-writing games: https://github.com/akkartik/brooks-ruby-warrior; https://2016.halite.io/user.html?userID=2460

Stefan Lesser while we're forced to make trade-offs, I think human nature is strongly geared to dislike ambiguity. Good things are good, bad things are bad, stuff like that. So when we look to the future we may want (sub-consciously?) to eliminate trade-offs as well. And paradoxically, the more idealistic someone is, the more likely they may be to fall for this fallacy.

I'm curious to hear if anyone disagrees that we'll always have trade-offs, there's no getting away from them.

https://www.cs.virginia.edu/~robins/YouAndYourResearch.html mentions tolerance of ambiguity as a marker for success; that's evidence that it's not universal.

Regarding "You should be willing to put up with klunkier interfaces in exchange for nicer implementation properties. (Eat your vegetables.) Sticking with text mode is an extreme form of this, hopefully I can break out of that in time."

I once wondered why text editors weren't better designed, given that they're the software that programmers make for themselves. But the more I've studied other software packages, the more I've come to believe that text editors actually are the best software that's ever been made. To make this argument, I'd put software like Emacs, Vim, BBEdit, TextMate, VS Code up against things like Photoshop, Excel, After Effects, Ableton Live. In my book, the text editors always come out ahead. They're more flexible, they're faster, they're more powerful, in that features can be combined in freeform ways more gracefully. The basic building blocks of selecting and operating on data works more fluently than in any other software I've encountered. Most of them can also be extended in powerful ways.

What do other people think? What software is better than text editors? (That's of comparable usefulness, I tend to want to narrow it to software that you actually make something with, e.g., because some utilities are so focused they practically vanish. But I'd still be curious what answers people have.)

Interesting. Just to clarify, though, I was alluding here to not using a graphics mode of the display.

I'm curious to hear if anyone disagrees that we'll always have trade-offs, there's no getting away from them.

We will always have tradeoffs but the winners and losers are not always the same person. I might be in a situation where "nicer implementation properties" genuinely don't benefit me.

For example, I am basically insulated from the difficulties Intel engineers have in understanding their chip designs. If they have to take on enormous extra complexity to give me a minor performance improvement, then from the perspective of God it probably isn't worth it, but from the perspective of me, it is, because the cost in this trade to me is smaller than even a small benefit. In this sense a faster chip is always better, there's no tradeoff.

In nand2tetris, the language you design, Jack, requires each line to either start with set or do. So instead of saying obj.func() you have to say do obj.func(), instead of a = 123 you say set a = 123. The design tradeoff they made here is to make the implementation of the parser/compiler easier at the expense of an annoyance when using the language. In the context of the nand2tetris course this makes sense because the user of the language and the implementer of the compiler are both you, but if Jack was a real language this would be absurd.

Finally, just because there will always be tradeoffs doesn't mean there aren't sometimes outright improvements. Leibniz's calculus notation is strictly better than Newton's, IMO.

For sure, the distinction between society at large and individual circumstances is important. I used the word 'tithing' above. Who should do the hard thing? She who can.

There are many examples of strictly better things. To restate my question: does anyone expect a domain to ever decompose into a lattice of strictly better solutions?

Are we firmly in the "then the tools shape us" phase of computing then?

I saw this story and am.. amazed. Not necessarily saddened, but.. just very fascinated.

It reminded me of the the cuneiform scripts - which look that way (wedge shaped straight lines) because that is how you could write on clay tablets with a stylus. Also many South Indian scripts which look that way (very curvy) because they were written on dried leaves and straight lines would easily produce tears.

Staying with McLuhan: If Excel is the medium, what is then the message?

"Yes a large of non-programmer end-users CAN in fact write simple (or sometimes hopelessly complex) programs. But be careful what you wish for."

From my point of view as a computational scientist (though not in genomics, and not using Excel), I'd go for another message: don't use software for research if it's authors don't explicitly support research and in particular your research domain (unless of course you are competent enough to judge the suitability of some software yourself).

This is a fascinating story. It goes to show how in a world of software there is no such thing as a non-technical person. There is only people that understand that world and can navigate it, and those that cannot. It follows that it is imperative to make the world navigate-able by many more people.

Excel is established enough that they can afford to ignore a huge base of users like this. I'm sure their product team is a lil embarrassed right now though. But in an alternate universe where Excel was designed as a technical tool for technical users (think of it as an IDE), this wouldn't have happened.

Tudor Girba agreed, all users are technical to some extent. I think for Excel and many FoC tools, a big challenge is designing so all types of user can get just as technical as they need to in order to solve the problem at hand. But to keep the next depth of technicality/complexity just around the corner so casual folks aren't overwhelmed.

Konrad Hinsen In this case if there is no product that explicitly supports research, and also has the desired features of Excel , what would scientists do?

Have a suitable tool designed and implemented for them by specialists. Using more generic bricks (GUI etc.), why not. The main point is that the core functionality, i.e. what happens to the data, is agreed on between developers and users and written down in some form of contract.

Cost is really not an issue here. Genomics requires a lot of resources for data acquisition (mainly sequencing), so it's worth spending a fraction of that money to ensure that the data is exploited to its potential.

Yes!

We've been in the "tools shape us" stage for a while. For example, the band Chvrches spells it like that so that it is googleable. It's the same phenomenon as "AAA Plumbing Ltd" in Yellow Pages.

I don't think the issue with the gene is as ridiculous as it first seems. If you are going to do this kind of helpful guessing you will sometimes get it wrong. I work with a lot of Excel files of phone numbers which are always interpreted as integers rather than text and converted to scientific notation (e.g. 447123000111 gets turned into 4.47123E+12). Drives me nuts, but from MS's point of view this is definitely the correct way to guess.

I think geneticists renaming some genes is a lot less concerning than everyone doing research in systems that don't model their problems well because they're familiar, or to avoid licensing costs...

Peter van Hardenberg I certainly agree - there is worse happening than this renaming issue.

Chris Knott Adapting to changes in the world around us is fine. Being shaped by tools as well - it's inevitable anyway. The issue here is (1) This is a partial bug fix, not an adaptation. Old and new gene names will coexist for many years and cause a lot of trouble. (2) Similar issues can happen any time again, if Microsoft decides to introduce more magic into Excel. It's OK to adapt to a changing world, but you want to have a say in how these changes happen when your core business is concerned.

Chris Knott great example with plumbing and chvrches, didn’t know that about them!

I feel it’s like an 80/20 rule - this type of parsing satisfies 80% of the people so they made it default - I feel like when pasting/importing, there should be a intermediate mapping/what is this data step. I don’t like it when tools assume without confirming - always confirm before assuming. Like autocomplete doesn’t immediately fill your code out but requires you to press tab. It might be annoying if you do it constantly, but a “remember for this sheet” checkbox would solve that.

https://twitter.com/mariosangiorgio/status/1290576316677455873

I have two examples from when I was learning to code. I learned to code in a language called DarkBASIC that is a BASIC for making games.

I began by editing the examples that come with it. One of these is a 3D character that can be moved around with the arrow keys.

The code used two helper functions which are specifically for a character walking on the x/z plane, rotating around the y-axis. The functions were NEWXVALUE() and NEWZVALUE() and were used like this;

X# = NEWXVALUE(X#, A#, 1.5)

Which is equivalent to X# = X# + cos(A#) * 1.5

I wanted to expand the example to include a second character controller by WASD. To do this I copypasted all the code, then went through and edited it.

The second character I made to have the variables XX# and ZZ#. I could get it set up ok, because I understood the initialization lines like

X# = 100

Z# = 100

I changed these to

XX# = -100

ZZ# = -100

But when I came to edit X# = NEWXVALUE(X#, A#, 1.5), I chaged it to XX# = NEW``XX``VALUE(XX#, AA#, 1.5).

That is, I had confused the 'X' inside the function name "NEWXVALUE" as equivalent to the 'X' in the variable name X#.

You will love some of the talks at the #PLHCISwimmer summer school. I will link once they put it up on YouTube.

In particular Bjorn Hartman’s talk.

He talks about how they scale tutoring and guidance. For example, say there is a grading system so you have a large number of student that submit code that should pass certain test cases and then they keep track of similar submissions and what transformations made them pass the tests and then use that to provide hints to people that are still stuck. There is a lot more but it’s basically how do you provide useful hints that will result in correct code

The second example is that I didn't understand why a 2D nested for-loop had the closing tags 'backwards'.

e.g instead of;

FOR X# in 1 TO 10

FOR Y# in 1 TO 10



(do some stuff)



NEXT Y#

NEXT X#

I was writing;

FOR X# in 1 TO 10

FOR Y# in 1 TO 10



(do some stuff)



NEXT X#  <---

NEXT Y#

which seemed much more natural to me. I just learnt to reverse them as a silly quirk of the language, it was only much later I realised that "there's no such thing as a 2d loop", and the inner loop "doesn't know" it's inside another loop.

Such an error is impossible in Python or C, due to the syntax, but I wonder if the same underlying misunderstanding is there, or whether the syntax helps learners realise straight away my revelation.

I could probably fill a book (or more) with programming errors like these, made by myself😊. Training an AI with this knowledge and assisting you while coding.. that would be awesome and FoC I think😎

Maikel van de Lisdonk do so before you forget them!

I encountered a fascinating one yesterday. A coworker tried to define a class method in Python with both self and cls args.

Python has quite a few around the boundary of what is convention and what is "really" part of the language. The use of _ is understood as just a character like any other that is by convention used to signify a "private" method or function, but in fact this naming affects the behaviour of import * which seemed like a real break of "the rules" to me.

Kartik Agaram maybe I will start doing that, registering the error and its correction in a format that in the near future hopefully can be used to train an AI. Are there already projects doing this (using an AI to give suggestions to coding errors) ?

Love this story!

I’ve never had those kind of “revelations” on LSD about technology, but I’ve never “thought” about technology much on it, it hits me more in a spiritual/astral tripping way. Writing code with it is either a super-flow state or ADD-ish chaos, where I write out a bunch of dirty concepts all over the place to lay out the idea.

But I’ve had similiar inspirations and breakthroughs on MDMA, which one might say is a “LSD for babies” in the way that it also boosts serotonin and processing bandwith of your brain. I find it isn’t as much as a “I know something I didn’t before” but more like seeing your mind compress the large network of complicated, related things into a simpler framework. Like when you build a ton of code and then just refactor it all into a smaller method. Quite interesting.

These are questions I have myself as well. In my situation I currently get a subsidy for my project which comes in the form of "discount on taxes" which helps me to be able to spend more time on it but not full-time. In the (near) future I hope to find a customer who wants to use part of my project in such a way that I earn money by implementing there project with the help of my product. In this case you will need to make good agreements on which parts of the code are yours and can be reused/shared and which part of the code is theirs and will not be shared . But I am not sure this approach will work. A bigger problem for me is finding the right market focus, I can multiple ways. So I probably need to get that sorted out first

what kind of software are you guys talking about? The answer of the question comes case by case right? I'm thinking of examples like, say, Adobe Acrobat vs the open PDF standard, or open source databases like MySQL vs consultancy on companies like Percona. In one case the format is open but some specific tool make const $$$, in the other the product is open but the consultancy costs $$$ too.

Other examples I can think about: I paid money for both the Cursive IDE for clojure and the https://www.linqpad.net/ tool. I'm not really worried these particular tools are paid / propietary.

sublime text costs $ but is extensible

one more example: REBL is a gui app that's distributed as a "closed source" jar file. Under the honor system, if you use it in a commercial setting you need to contribute to cognitect's patreon https://www.patreon.com/cognitect

also there's https://www.clojuriststogether.org/

My project is a flow based programming editor with a flowrunner library. It can be run standalone but I am also working on a web variant which could evolve in a saas model. Currently I have flowrunner implementations in various languages: javascript/typescript, php, rust/wasm , c#. It can be used for learning, building webapps and native mobile apps, data exploration/charting, realtime debugging. I still have to choose my main focus area. It is in active development but fare from completion.

Wow, this has some overlap with my own project but with more focus and it is much more polished (my editor can also be run via npm and has an integrated local server). Thanks for sharing, I am going to check this out

Should probably start an interesting links from the summer school thread. Unfortunately, can’t credit the people who originally posted them because I just have it in my browser.

Also, haven’t gone through them properly myself.

E.g

http://www.cs.cmu.edu/~NatProg/

Thanks for sharing all those links, Ope! 🙂

Thanks for the link, please share those links. :)