Blurring the Line Between User and Programmer

Catching the moment when someone can not do their job efficiently anymore is an HR problem, and businesses can not rely on introspection and self-evaluation to work in this situation.

That said, I believe that “dumbness” and non-evolution of excel (as a biggest player) is a root cause. If it wasn’t just a bunch of cells with chaotic references, but suggested a user to think in a strict “tabular datasets with comments, RLS and history” way, things could be much better (or worse, depending on how you use it).

Basically, in “show me your data, not code” excel is the latter, and that’s pushed to an innocent user. The result is pretty obvious.

I suspect trying to build a programming language to stop having to think like a trained programmer, is a doomed project.

Non-technical people should be able to use their native cultures language to query for answers. Or in the case of scientists & mathematicians, the well defined symbols & glyphs of their field.

Programming is the act of organizing information for a specific context, ideally efficiently to the computer, but that’s not a requirement. Clearly organized results are the only real requirement of software. All the rules we add on these days are to the benefit of corporate keeping things tidy by pretending making software is like building a car.

As someone getting into data science as a hobby, I have no interest in Python or R syntax. Like with PGP & a host of other issues, terrible UX is an impediment, and an artificial shield for those that slog through learning what is really superfluous crap given their actual task of making sense of business data.

Give me an app where I can select a database, and compose a math equation with nothing but plain math, as like React components, or a word processor with scaled up Unicode symbols, or use a game engine like Unreal, for all I care.

And for day to day life things like Siri are fine.

This is my huge beef with the tech world is believing everyone needs to fetishize source code to use a computer.

The “design is life” era has resulted in a ton of boring/limited business “apps”, and over designed one off UX that lacks broad application.

Software as a marketplace in general is suffering the App Store problem: it’s so easy to copy-paste SOMETHING out the door via Github or however, we’re socializing around the most visible, IMO, well known concepts, minor iterations on known information.

Often wonder if there’s a theory there that might explain why society is where it is lately: we’re not generating enough emotionally unique information. Just fetishizing minor improvements to well known emotional norms.

I think it would look like a component architecture, with Elm syntax.

As someone that barely programs but still hacks on open-source, I just want the code for one thing to be in one place, not spread out across 4 different files.

And I want one action/object to have just one name. Not three names like createServer, newServer, server, etc

I know a handful of non programers who can automates tasks in their everyday workflow but as you say they're not maintainable pieces of software or particularly transferable, they are custom tools they create for their own flow.

Sure, and then they just pass it off to a competent technical person. It sure would be convenient if these people used the same language! Right now, when a non-programmer starts a project in Excel, and then hands it to a programmer to make into a good, maintainable version (perhaps as a native application, or a web application), the programmer has to start from scratch. That's an awkward discontinuity.

There's no reason I see it always has to be that way. We just haven't prioritized the ability for a non-technical person to make something, and also for a technical person to be able to pick it up and turn it into a full system.

I see programming mostly as a mindset. Like doing algebra. You couldn't do it as an infant, because you just didn't understand the concept of using letters instead of variables.

Of course, there usually is a level of complexity that you need to get used to as well, but you can also see this as a defect of most API's, or as an inherent quality of doing anything nontrivial.

Coda actually just released their v2.0 a few days ago which has brought some much needed bugfixes and stability improvements. I've had some time to discuss larger strategy with their team, and I can tell they're working really hard to "strike the right balance" between easy to use / discoverability and capability.

I definitely like their product, and am following them going forward. If you're at all interested in this space, you should check out Coda just for the sake of seeing where we are (as a field) in solving this problem.

This IMHO is the largest problem with spoken language, no parentheses, lots of synonyms/homonyms etc.

One word: AppleScript

A more sane expression syntax might be nice too, but isn't necessary to make Excel more productive for abstract programming.

It's the right attitude to take, but let's try to provide some definitions. What does it mean "to program"? Certainly we have contemporary ideas of what it all involves. But at the end of the day it's hard to come up with a more encompassing definition than "telling a computer what to do (and possibly what to do later)." This means that by merely "using" a computer (ie through a GUI or whatever -- manipulating it somehow) one is, by this definition, doing some kind of programming.

With that definition in mind, we now see that the systems we have provided users are completely hamstrung. We have given them limited environments and languages (languages here being mostly of a visual/UI variety) to work with.

What's worse is that we have goo examples from even recent history about how alternatives can work: Visicalc, Hypercard, Smalltalk, etc.

Insofar as these conversations rely on discussing "programming languages" -- a loaded term, and only part of the picture really -- rather than whole "computing environments," then we tread further down a losing path for everyone.

APL does the hard part of choosing composable functions and presents those to the user, as a simplified interface. Sorting isn’t a global namespace of thirty different sort algorithms so you can delight in picking the exact one you want, sorting is one character (⍋) so you can use it as a composable building block and not care about the details.

I might agree that the core issue is that programs have become less composable over time - but what you ask for doesn’t seem to address that at all. Part of the job of designers and creators is to make simplifying decisions on behalf of users; I don’t want the lightbulb raw interfaces to be exposed to me as an alternative to a crummy closed app product, I want a well designed composable app product as the api I use - all at once, so I don’t have to care about negotiating access tokens or header padding anymore than I have to care about LED heat dissipation or mains smoothing inside the bulb when I flick a light switch.

For composition I want Lego not a machine shop, and I accept compromises in ability to get that. I want grep not fopen().

When you say you want composition what you’re asking for is a machine shop; not a bad thing to ask for, but completely different from where you started out with Unix shell composing of finished product programs which you originally said you wanted.

So if I have a computer and I want to access the internet, I should have to write my own browser first?

No... "to use a computer you should program it" isn't a philosophy, it's a technical limitation from when "programs" were simple and everything ran in a terminal, and no one but engineers and students would ever be expected to touch a computer in the first place, and it doesn't scale.

Should people be able to write software for their own computers? Yes.

Should programming be considered a normal part of computer use, and be far more common than it is, with systems and software being more open than they are? Yes.

Should people need to write their own software? NO.

>I think we as an industry made a wrong decision turning programs into products. We should have kept programs as programs - make them super composable, and then let the end user design their own products that fit them best.

It wasn't entirely wrong. End users don't want to write software, they want to use their computers do to things - and most of those things now require multiple thousands or millions of lines of code written by engineers with domain specific knowledge. Turning programs into products is a way of managing the complexity necessary for software that's useful to people in modern society.

> The language that you build your extensions on shouldn't be thought of as a programming language in afterthought; it should be designed as a programming language. In fact, we discovered that the best programming language for that purpose was Lisp.

> It was Bernie Greenberg, who discovered that it was (2). He wrote a version of Emacs in Multics MacLisp, and he wrote his commands in MacLisp in a straightforward fashion. The editor itself was written entirely in Lisp. Multics Emacs proved to be a great success — programming new editing commands was so convenient that even the secretaries in his office started learning how to use it. They used a manual someone had written which showed how to extend Emacs, but didn't say it was a programming. So the secretaries, who believed they couldn't do programming, weren't scared off. They read the manual, discovered they could do useful things and they learned to program.

> (2) Bernie Greenberg says that Dan Weinreb's implementation of Emacs for the Lisp Machine came before Greenberg's implementation for Multics. I apologize for the mistake.

~ "My Lisp Experiences and the Development of GNU Emacs" (Transcript of Richard Stallman's Speech, 28 Oct 2002, at the International Lisp Conference). https://www.gnu.org/gnu/rms-lisp.html https://news.ycombinator.com/item?id=20374467

Maybe it could even be taken a step further and turn it into a UNIX pipeline composition equivalent in GUI form. Trying to imagine what a system could look like, I see a kind of tiling window manager in which you can place arbitrary widgets (list views, sliders, text entry, etc) and hook together their inputs and outputs, maybe with a little scripting glue.

And why on earth do you believe that this difference in mindset cannot be taught?