On Tuesday, 5 January 2016 at 20:11:10 UTC, Ola Fosheim Grøstad
wrote:
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...
Yeah, I'm not sure I understand the StackOverflow thing but it
would be cool if people didn't waste so much time having to do
the same boilerplate code. I'm not sure if AI is far enough
along. Proper AI learning algorithms could potentially help(they
might suck at first but this is what training/practice is for.
Eventually they will be better at it than us)
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).
Yes, I meant that basically programming compilers and designing
languages seems to be approached current from the bottom up(much
like it was in the past). We are starting to see top down
approaches with DSL's, intermediate languages, etc...
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...
I basically agree with what you said. I think it is a difficult
problem and I guess it will take time for humanity to figure it
all out... we are on track. It just feels like there it is very
inefficient... but like most things, it tends to be exponential.
I suppose the average programmer can't comprehend the
complexities require for the initial adaptation and it takes time
for them to "get with the program". Think of when C added ++...
most programmers were not good at oop... now it seems everyone
has a pretty solid understanding of it.
Thanks
