On Tuesday, 5 January 2016 at 16:10:21 UTC, Jason Jeffory wrote:
It seems that many programmers get dissatisfied with the state
of something and try and branch off and create something that
suits them. The evolution of programming is the evolution of
life in some way.
Is it possible that one could develop or modify an existing
programming language that can adapt in such a way to provide
maximum unity between programmers?
In a way that is the ideal for language design. Design a minimal
core that can be extended. A few languages are a bit like that:
Lisp, Beta, Self, Smalltalk?
But I think the most powerful concept now is _software
synthesis_. The basic idea being that you specify the constraints
and let the computer write the actual code, or some variation
over that.
A language itself, that can adapt grammatically(since people
like different grammars), be both powerful and simple, and
provide all that is needed(more or less)?
Ok, on the grammar level you have some languages that try. Like
Pure, which is based on term rewriting. But the _key_ problem
with this in the general case and also with very powerful and
flexible type systems is that situations may arise where you
either have bugs related to (perceived) ambiguities or that
computations become very expensive and takes forever to complete
(if at all). Of course, one can solve that with time-out errors
and smart heuristics, but there is a design complexity cost here.
I know many will immediately write off this statement, but I
have to ask: Is it possible for a single language to capture it
all?
If you mean "capture it in all ways that a human will perceive as
significantly", then yes, probably. It might be impossible to
master, like C++, but such a language could probably be
constructed.
System level, application level? Why not both?
Ok, but I would rather have a deductive language that can easily
express efficient imperative code... I don't know what it would
look like, but I think that would be my ideal.
People will claim that such a language is infeasible because it
is too complex!
I don't think it is infeasible, but I think that the amount of
effort it takes to design it should be spent on creating AI that
can do boilerplate coding. And let humans do high level
application design instead.
My point is this: We all spend a disproportional amount of time
writing braindead code. With bugs. Because the human brain isn't
very good at pinpoint level accuracy. We are really not very good
at explicit imperative programming.
We are much better at modelling approximately with clay,
gradually refining the model until it is good enough.
That's the major flaw of computer languages. None of them reflect
human creative processes.
Any more thoughts?
Think of all the wasted man hours spent on people working
unfocused on the issue.
Yes, this is horrible. We should rather write more generic
language agnostic code, and drop down to specific code where
efficiency matter.
Take a look at Github and see how many source code files have
functions that implement almost the same function. That's
insanely inefficient.
Just take a look at D repositories and we see the same, lots of
implementations of essentially the same functionality.
What we need is not libraries but maps of "abstract function
implementations". The closest we get to this is StackOverflow. I
think that is just the beginning. We could have a language
agnostic representation and automatic translation to Java, C#,
JavaScript, C, C++, D...
But a top down approach to programming(and computers) is
required.
You need both. Top down and bottom up, then software synthesis
(let the computer fill in the details).
Such a programming language would truly be evolutionary(or at
least revolutionary), right?
Software synthesis is an active research topic. Maybe we'll see
it in 30 years? Real world languages lag 20-30 years behind the
computer science frontier...
