What Is Programming?

Is mathematics programming?

Is Javascript programming?

What is programming?

Is "GOTO Considered Harmful" about programming?

Is The Mythical Man-Month about programming?  Where does "Second System" syndrome fit?

How did Bell achieve four-nines (0.9999 uptime) in the 1900's without using Haskell?

What is a "current directory"?  Is that related to programming?

What is CamelCase?  Is that related to programming?

I believe that the field of programming has not been sufficiently sub-divided.  I believe that pure research is, currently, being conflated with applied research, such as architecture, engineering and implementation.

What is Computing?

For that matter, what is Computing?  

Is Computing about making calculations?

Is Computing about controlling machines?

Is Computing more than one thing?

See my thoughts on this in https://guitarvydas.github.io/2021/01/02/The-Primary-Issue.html.

Categories of Programming

The word programming is a loaded term.  It can mean many things.

As usual, fractal-man comes to the rescue.

We can sub-divide a loaded term to gain new insights.

Off the top of my head, I see programming as four (4) different disciplines.

At present our PLs are highly polarized - there are PLs for Pure Research and languages for Implementation, but not much in between (e.g. generally no PLs for Software Architecture and generally no PLs for Software Engineering).

At present, all sub-categories of programming are conflated.  Most individual software professionals perform bits of each category. Most software professionals work on intuition.  Some individuals are better / more experienced / biased at certain goals and produce imbalanced results.

  It might help to think of other^[1] disciplines, e.g. bridge construction.

I list further thoughts below and in Fig. 1

Fig. 1 Software Development Categories

Pure Research

Pure Research tries to define the boundaries of software design using first principles.

Ironically, Pure Research defines things like numbers, but does not define what programming is.

Pure Research, for example, does not constrain the use^[2] of GOTOs.  In fact, Pure Research gives us GOTOs-on-steroids in the form of CPS.^[3]  CPS is useful for Denotational Semantics, but should not be used in day-to-day software applications (e.g. for Maintenance reasons).

Research PLs

Agda

Coq

Haskell^[4]

(list incomplete and changing over time)

Architecture

Software Architecture is the embodiment of experience in solving day-to-day application problems.

Tools of Software Architecture include:

• RY (as opposed to DRY)^[5]
• reuse of Architecture (as opposed to reuse of code)
• little languages^[6]
• etc.

UML is an early attempt at Software Architecture.

Modeling (vs. compiling) is the domain of Software Architecture.

Superposition is required by Software Architecture. Designing systems is only possible using technologies that provide superposition.  I argue^[7] that current software practices and languages inhibit superposition.

Architecture PLs

parts of UML

(list incomplete and changing over time)

Tools of Architecture

• RY (as opposed to DRY)^[8]
• reuse of Architecture (as opposed to reuse of code)
• little languages^[9]
• etc.

Engineering

Engineering is not coding.

Engineering is Applied Research.  Best-of-breed research applied to manifesting an architecture - a specific solution to a specific problem, as sketched by a Software Architect.

Engineering is about filling in details left open during Architecture and making trade-offs to derive a workable final result.

Engineering is specialization, not generalization.

Engineering is about making trade-offs, using the best (most usable) bits of research to create specific applications.

Engineering is about making cost-effective trade-offs.  [What does cost-effective mean?  It depends on the specific problem / the specific customer.]

Engineering can be further broken down into sub-categories, for example:

• testing
• optimization [What is being optimized?  Memory, CPU, UX, etc.?]
• maintenance
• UX
• etc.

There is research^[10] that applies to Engineering, for example:

• debuggers
• restarts
• packaging, package managers
• optimization
• language features - what to keep, what to throw out
• better editors
• macro processing
• IDEs
• programming techniques, such as Structured Programming, OO, FP, etc.
• programming abstractions
• DSLs (programming abstractions)
• solution-centric^[11] abstractions
• testing strategies
• etc.

Compiling (vs. modeling) should the domain of Software Engineering.  Currently, compiling means creating implementation instead of doing Engineering.

Statecharts (UML2.0) is a kind of Software Engineering language (there could be many more tools in this domain).

Drakon might be another kind of Software Engineering language.

DRY^[12] and OO are the domain of Maintenance Engineering.

Blueprints are the domain of Structural Engineering.  There are few blueprint technologies for Software Engineering.

Fig. 2 shows a rough diagram of design iterations that occur during Engineering.^[13]

Fig. 2 Engineering Iterations

Optimization Engineering is also known as Production Engineering.

Tools of Software Engineering include:

• little languages
• RY
• StateCharts
• m4
• pipelines
• PEG (Ohm-js, ESRAP, etc.)
• etc.

Engineering PLs

• StateCharts
• parts of UML
• Drakon

(list incomplete and changing over time)

Implementation

Implementation is coding.

Implementors should code at the speed of touch-typing.  If they stop to think, then they are delving into Engineering and/or Architecture.

Implementation can be further sub-divided.  For example:

• test
• CI/CD
• Q/A
• alpha/beta coding
• production coding
• etc.

Implementation PLs

PLs are second sourced if more than one implementation of the PL is available from different vendors.

PLs that have standards allow one to switch between implementations easily.

Such PLs include:

• C
• Common Lisp
• FORTRAN
• ECMAscript
• HTML
• POSIX, Linux, UNIX®, etc.

Most other PLs are single-sourced, e.g.

• Perl
• Python
• Rust

Testing PLs / Tools

• CI tools
• (list incomplete)

Q/A Testing / Tools

(list incomplete)

Frameworks

• Rails
• Query
• React.js
• no-code

(list incomplete and changing over time)

See also

Mathematic is not reality

https://guitarvydas.github.io/2020/12/09/Mathematics-Is-Not-Reality.html

Software development roles

https://guitarvydas.github.io/2020/12/10/Software-Development-Roles.html

Pure Research vs. Applied Research

https://guitarvydas.github.io/2021/01/14/Pure-Research-vs-Applied-Research.html

New-Breed HLLs

https://guitarvydas.github.io/2020/12/09/New-Breed-HLLs.html

---

[1] Looking at other disciplines is "reuse". High level reuse.

[2] Research into how to constrain GOTOs is the realm of Research into Applied Research.

[3] CPS means Continuation Passing Style.

[4] Is this correct?  Is Haskell a research language or is it a production language?

[5] Imagine git for Architecture instead of code.  DRY detection and resolution should be automated.

[6] I call little languages SCLs, meaning solution-specific languages.  SCLs are like DSLs, but more focussed.

[7] See https://guitarvydas.github.io/2020/12/25/The-ALGOL-Bottleneck.html and https://guitarvydas.github.io/2020/12/09/CALL-RETURN-Spaghetti.html.

[8] Imagine git for Architecture instead of code.  DRY detection and resolution should be automated.

[9] I call little languages SCLs, meaning solution-specific languages.  SCLs are like DSLs, but more focussed.

[10] This suggests further sub-divisions of Pure Research in the above diagram.

[11] Solution-centric abstractions are more focussed than domain level abstractions.  I used the abbreviation SCL instead of DSL (solution-centric languages vs. domain specific languages)

[12] DRY means Don't Repeat Yourself.

[13] I was schooled in EE and am biased towards Engineering, hence, my diagram shows more detail in the Engineering phases.  The diagram should be extended to show phases in other categories and to show further sub-divisions of Engineering.  This is not a final diagram.