I think the idea of a programmer will fade away,
as it will be replaced by the modern teenager.

I think smartphones are already too stupid,
and the next big thing is a programmable phone.

That is how quickly times are changing,
smartphones are a relic.

I recently discovered that there is something neat,
that we can do to hasten this transformation.

We have to race to meet the new intellectual,
with self guided integrated development environments.

No newcomer to programming should ever wonder,
where to put the code.

The boxes for the code, along with a build button,
should already be on the screen.

Mr. Vonnegut presented us with the idea that stories have shape,
and same is the case for every useful programming pattern.

That shape is always very simple,
as it is rarely visualized with a friendly GUI.

The old school programmer had a terminal,
the whippersnappers have electron, the madmen have eclipse.

And none of it is friendly, even the modern web based editor,
is just a spicy text editor, little more than a 1980’s terminal.

There are some shapes that do get complex,
Object Oriented Programming comes to mind .

And same is the case with Aspect Oriented Programming,
OOP Mixins, and Multiple Inheritance

These would be greatly improved with a specialized editor,
but these technologies still fail, no matter the user interface.

They create too much complexity,
any which way.

On a much smaller scale the Event Emitter,
is incredibly friendly.

It is just a listener,
and bunch of functions that crunch the data it receives.

And Linux command line commands are friendly too,
sweet configuration arguments, the input stream is any, and then just the error and output streams.

They are similar to an Event Emitter,
and in fact node streams are made with the use of the Emitter.

I mention modern JavaScript for creation of commands,
because of how many places the JavaScript programmer can reach.

Linux Command Line, SVG Graphics, Electron Desktop Applications,
Web Sites, Web Servers.

C or C++ would greatly slow a programmer down,
not so with JavaScript.

Finally, I will just describe the shape of an EventEmitter,
and I will even throw in unit tests to the mix.

The shape is three columns,
underlined by the code editor.

In the first column we have
an editable list of all the events where user can add more.

When we select an event,
from the first column.

In the second column we get a list of the functions,
that process the object the Event Listener receives.

And when we click on a function,
yes the associated code does appear on the bottom of all three columns.

But also the third column will display the unit tests,
that are used to check if the function is complete and correct.

Three columns, List of Events, list of event functions, and list of function tests,
and wherever there is some code to edit, it can be edited in the editor.

That is usually the function code,
and the unit test code.

By clicking build a code generator will gather everything up,
and create a perfect little module that can be committed to a proper repository.

Such a program would be installed on the user’s commuter,
so there is no need for servers here.

Aside from being a very neat way,
to learn programming, this project comes with a powerful benefit.

While the programmer has a useful interface,
they get to look at the code generator output.

And see how their functions are integrated,
into EventEmitters and node modules, or command line applications.

I think, at first, the new intellectual, the programmer,
will end up viewing that code the way we view obfuscated or transpiled code.

They will eventually get to know how it all works,
but it won’t be a priority.

Precisely because these luxury code editors,
help the programmer focus on code, and not boilerplate.