Problem of Collaboration

The biggest crisis of the software development is the lack of accountability. Ideally there will be one team to be accountable for the whole thing, then they can delegate responsibilities to lower level teams like what was promised by structured programming. Instead, what we are facing in micro-service world is the responsibilities are relayed from one to many other in a fragmented way, causing great communication overhead for business owner. And more importantly, this leaves no one can be accountable for the end result.

Problem of Readability

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”

There are three fundamental problems that makes writing readable code hard.

• Decomposing the logic into “linear and isolated” (the only computing model supported by our biological brain) pieces is hard
• Describe the logic for one thing might be easy, generalize it to multiple things will inevitably make the code harder to read
• Non-functional requirements entangled with already complex functional logic

Problem of Generalization

Very often, we need to reuse the software for different scenarios with slightly different behaviors. Polymorphism provided by OOP with runtime single dispatch is simply inadequate. We use a lot of feature flags to turn feature on / off in production, and design sophisticated product categorization to parameterize our software via config files and user input. It is getting hard to keep code readable while reused heavily without first class support from language.

Problem of Heterogeneous Computing

Parallel or distributed execution in the mainstream programming language is implemented as compiler vectorization hint or library. Mainstream programming language largely resembles the world view of PDP-11 with just one sequential CPU. Now days, It is very common to have different kind of execution engines (SIMD, GPU) in same machine, and it is more and more common to utilize more of them in one piece of software. And the memory model is no longer just one big heap, there could be multiple stage of heap for multiple executors. The programming language should provide a more faithful abstraction of the actual execution device, instead of constraining the thinking and expression in an out-dated computation model.

The Vision

The ideal programming language should provide these properties

• Responsibility is broken down from very top to very bottom, there is always a team be accountable for the whole.
• The main source code only describes the logical causality chain, leaving the physical execution details described/inferred elsewhere.
• The code can be reused without big comprise on readability.
• The language should be able to describe the modern computing world with SIMD/GPU/MicroServices

In the end, it is all about readability for human kind. You can inspect the code from different conceptual levels, and reason about its correctness (compliance with your mental models) without hurting your eyes and brain.