
End-User Programming - kawera
https://www.inkandswitch.com/end-user-programming.html
======
userbinator
If you look at PC magazines from the late 80s/early 90s, you'll find Asm
program listings for small but useful utilities. DOS batch files, another form
of programming, was common too.

From several decades before that, I have an engineering textbook from the
early 60s which devotes an entire chapter to the basics of how computers work
and writing programs (once again, in Asm) to use them for solving problems.

Thus I'd say "End-User Programming" has been around for a very long time, but
it's only recently that the rise of "user-friendliness" and locked-down
walled-garden environments contributed to its demise.

~~~
indymike
Could be that it's just tough to do user-programmable web apps in a secure
way.

------
empath75
The problem with end user programming is that no matter how much easier you
try to make the interface to use, programming requires some ability to think
logically and understand systems and anybody who can do that is going to get
frustrated by guard rails and just want to do ‘real’ programming eventually.
There’s never going to be the magic interface that unlocks coding for everyone
because most people just don’t think that way and the people that do, don’t
need a more intuitive interface.

Which isn’t to say that quality of life improvements aren’t important, I just
don’t think they’ll turn non-programmers to programmers in any great number.

~~~
blotter_paper
>There’s never going to be the magic interface that unlocks coding for
everyone because most people just don’t think that way and the people that do,
don’t need a more intuitive interface.

Strongly disagree. The "magic" interface will be a machine that understands
verbal instructions well enough to convert them into logic, figure out which
cases are undefined and non-obvious, and then ask clarifying questions. I'm
not saying we'll necessarily get there in 10 years, but barring civilizational
collapse we should get there in n years. It's both useful and theoretically
possible, so we _will_ eventually build it.

~~~
empath75
Sure when we have general intelligence they can do the coding, but those
people won’t be doing coding any more than the guy submitting a feature
request in Jira is doing coding.

~~~
blotter_paper
General AI isn't necessarily necessary for this, though it could be what
brings it. And I suppose I never compile anything since I don't do it by hand?
Why bark when you have a script?

------
dukoid
I am surprised that they used yahoo pipes as an example for "flow based"
programming instead of something a bit more modern such as Node Red (1). My
own experience wit trying to design a flow based system for mobile
([http://flowgrid.org](http://flowgrid.org)) was that input seemed just to
cumbersome (compared to typing) and not dense enough (compared to text) -- at
least on mobile.... Labview / lego would probably be worth looking into,
too....

1) [http://nodered.org](http://nodered.org)

------
ken
Just yesterday I was thinking that I like the iOS Clock app but hate the time
picker, and it’s not very OO of it that I can’t subclass the app and fix it.
Also that Maps cleverly picks an appropriate scale but there’s no way for me
to use that functionality from my app for my data.

iOS apps aren’t unique in this. Modern software isn’t very flexible.

~~~
Wowfunhappy
You'd be able to fix the Clock app if your phone was Jailbroken. There's a
system for modifying existing apps called Cydia Substrate, and it's _very_
robust.

For simple modifications, there’s also Flex, which doesn’t require any
programming! Flex provides a list of variables and methods, and lets you to
override them with whatever value you want. I changed setSwitcherStyle from 1
to 2, and now I have the iPad’s “grid” app switcher on my iPhone.

iOS software isn’t inherently inflexible. Apple is just preventing you from
modifying it.

~~~
ken
I think there's a big fundamental difference between "programming" (with
source code) and "reverse engineering". Cydia Substrate definitely looks like
the latter.

I also think there's a big difference between "programming" and "toggle a
single bit of configuration". You got a different behavior which didn't
require programming because someone else had already gone to all the effort of
programming it, and you only needed to find the secret switch to enable it.

If there's any system in common use today which allows subclassing
applications to permit users to change arbitrary behavior, or plucking out a
single function to re-use in a different context, I'd love to hear about it.
We've got open-source, but most of those are really not at all designed for
end-user programming.

The closest example I can think of today is Greasemonkey.

~~~
Wowfunhappy
Creating Cydia Substrate certainly involved a ton of reverse engineering, but
I get the sense creating tweaks _on top of_ Substrate is a lot closer to
Greasemonkey. There are also tools like Flipboard Explorer[1] that make it
easy to see how an iOS view is constructed and what needs to be modified, very
similar to a web browser's inspector.

There's a line in a blog post[2] Saurik (Substrate's creator) wrote a while
back:

> In general, I also believe the algorithms for reverse engineering have
> started getting better faster than the technology behind binary obfuscation.
> [...] I believe that we will find the distinction between closed source and
> open source crumbling—not just for people like comex and myself, but for the
> average developer.

He also references a longer talk he gave on the subject. Disclaimer that I
haven't watched it.
[https://www.youtube.com/watch?v=D91jVZ4Z6og](https://www.youtube.com/watch?v=D91jVZ4Z6og)

Note that all of this absolutely still requires _programming_ though. And Flex
is absolutely not a programming tool, although the wealth of options it opens
up is very substantial, since you can modify the return value of just about
_any_ method.

\---

[1] [https://github.com/Flipboard/FLEX](https://github.com/Flipboard/FLEX)
(Note: Flipboard Explorer's abbreviated name is "FLEX". It has no relation to
the other software I mentioned, "Flex".)

[2] [http://www.saurik.com/id/22](http://www.saurik.com/id/22)

------
NicoJuicy
Ugh, for 1,5 months I've been trying to find a way to duplicate flow based
programming in c# ( like node-red does). If anyone has some ideas on how to
create the "engine", please contact me..

Tried everything I can think of. Currently, not much luck.

~~~
mamcx
You mean, visually? or conceptually?

Visually is more complex, you need to build a UI.

But the concept, that can be done with a DSL, combining the
concatenate/stack/tacit programming paradigms. How much nice, depend in what
you want...

~~~
NicoJuicy
Visually is kinda easy. There are a lot of UI tools for that on Github.

The concept, can't be done in a DSL. Because node-red makes exceptionally well
use of the dynamic programming paradigm ( and with the optional payload
property).

Just converting it to a Dictionary<string,object> when it enters || exits a
node doesn't seem enough. + A huge performance drain

~~~
mamcx
How you think > dynamic programming paradigm is implemented?

With something like Dictionary<string,object>. Yep, exist some tricks you can
apply, but to make things "dynamic" you will need to use something like that.

C# have the buildings blocks for make something like that, like the Expando
object and the whole meta programming.

However, a custom interpreter could be best.

P.D: I'm implementing a custom programming language, and research about it a
lot. BTW, the use of hash maps with a decent hash function will not be
necessarily the bottleneck...

~~~
NicoJuicy
> Because node-red makes exceptionally well use of the dynamic programming
> paradigm

Because of flexibility around the payload/context property. I can map anything
generic through abstracts and T1,T2,... In c#, but it's not enough

Not sure about anything use related. Or I need to reduce the flexibility that
I wanted before and look to the mapped properties only and ignore the rest.
Which would be a lot easier

------
KlaymenDK
> In fact, the opposite: today our computing devices are less programmable and
> less customizable than ever before.

Ohh, I'm not at all sure I agree with that -- but then again, I am pretty sure
I have an above-average number of scripts for my Android phone's Automagic
app, and before that Llama. I have all sorts of automation and customization
set up on my phone and workstation -- but granted, this is far above the
trodden path for Joe User.

------
revskill
In my case, my end-users are not programmers, their daily job has nothing or
very little to do with computer. They don't need customized environment for
them to customize by themselves. They need their program to have enough
functionalities for them to get job done. To the downvoters: Please read my
comments below or at least provide the reason you think the comment is
invalid. My end-users are different than yours for some reasons.

~~~
benj111
Does that mean they can't use spreadsheets?

If their work has very little to do with computers, then they don't really
need any functionality to do their job. So this article is kind of irrelevant.

~~~
revskill
Before computer era, one of use case is librarians. They just want to store
metadata into the computer for them to easier to search. Without any computer,
they also get the job done. But with a computer, it's more productive for them
in their job.

~~~
keithpeter
But when librarians got their OPAC systems, they started writing reports to
analyse lending patterns and identify stock that was not being borrowed, and
identifying lenders that had overdue books &c.

So the decrease in effort needed lead to an increase in analysis of the
information captured in the system - new uses.

[https://en.wikipedia.org/wiki/Talis_Group](https://en.wikipedia.org/wiki/Talis_Group)

~~~
revskill
I'm not sure about other regions, but in my region, non-tech users are too
lazy to "program" their customized job. The reason is many, but it's just the
fact to let you know. "Programming" in any kind is a hard work, and not all
end-users like to do it. They're lazy to do brain work.

~~~
shkkmo
> I'm not sure about other regions, but in my region, non-tech users are too
> lazy to "program" their customized job.

You know this how? Not a single non-tech user would even try?

I would suspect that the quality and accessibility of the implementation has a
huge impact on this, far more than the region or domain.

