Quora Answer : Taking the top-ten programming languages as the current generation of programming languages. We see a blend of imperative, declarative, OO and functional programming. What might be the next paradigm shift or blend in language design?

Jul 21, 2019

Increasing interest in :

"functional", and other kinds of "reactive programming". That is, programming where you specify rules or standard transformations of data, and then use declarative programming to wire them together. Rather than using imperative code and callback hell to manually tell the computer when to update and move data from one place to another.

the above leads to a general focus on data-flow programming. I say this is "the next garbage collection" meaning, just as we realized that most of us don't want or need to manage our own memory explicitly, most of us don't really want or need to manage our own data-flow explicitly. Just say module X is connected to module Y this way, and whenever X changes, let the computer figure out how to pass those updates onto Y.

tuple-space programming. That is, pull the global state out of obscurity in the main code base, and put it into an external database. Then have your program architected as multiple agents or actors posting changes to, and subscribing to changes in, this external database.

"logic programming" Languages like Prolog already have a central database of facts and the code basically responds to changes in this. Prolog is good for some things but awkward for others. You could hook Prolog-style inference engines up to make it more convenient for them to interact with sophisticated GUIs, back-end databases and external systems. Experiments like Bloom and Eve have started to bring these ideas forward again. But we will see more in the next couple of decades.

These are all kind of interconnected. But would save a lot of hassle of programming if we adopted them systematically in our languages.

Future Programming is a Space on Quora to talk about this whole topic.

Quora Answer : What programming language today is what Smalltalk was back in the days?

Jul 30, 2018

There is nothing like the Smalltalk project.

Something focused on being radically innovative, introducing a new paradigm of programming and being easy, accessible and productive.

The nearest thing I can think of being done today, is probably Chris Granger's Eve : https://www.youtube.co\m/watch?v=5V1ynVyud4M

And that can't really match the scope of Smalltalk. I suspect it had nothing like the funding and support of PARC. And never crystalized on a single system like Kay's Smalltalk. But wandered all over the place.

The really interesting thing to me is the paradigm of reactive or "when" clauses. And the implicit database of facts / world state. This is kind of like Prolog, but more practical and accessible to n00bs.

Y-Combinator's HARC has also dabbled in interesting ideas. And brought in Alan Kay to run it. And a bunch of other great people. But again I suspect the same degree of support wasn't there. And again it seems fragmented over multiple little ideas that don't come together in one big thing, the way Smalltalk did.

So we're still waiting for the equivalent of Smalltalk.

Of course, the IT landscape is much bigger and more complex today. There are far more things we want computers to do. Far more places and platforms we expect to work on. Maybe it's impossible to imagine one unified thing that could serve the way Smalltalk might have served. And lots of small projects is a better way to do research. But it's a shame you couldn't have the kind of commitment to build an accessible Eve (or Bloom) style language into a fully working environment.

Quora Answer : Which programming language according to you is the language of the future?

Jun 9, 2019

We're moving into a period when FP languages and ideas are going mainstream.

The FP languages like Haskell, Lisp (CL, Scheme, Clojure) and Erlang are pioneers of a set of ideas. Either these languages are going to become even more popular and "go mainstream". Or new languages come along that steal many of their good features.

The next stage, after mainstream practice has started incorporating the FP ideas, is going to be to come back to languages influenced by declarative, logic and rule-driven programming. Basically ideas you see in Prolog . And MiniKanren, Bloom, Eve, Picat, etc.

And to a certain extent, this is the way that React / Redux are taking Javascript programming. Or even Model-View-Controller taken to its natural conclusion.

We keep all our mutable state in a single central database. And the rest of our program consists of declarative, state-free rules for how the contents of that database get rendered, and how events transform it. Data flow is implicit and automatic.

I can't give you name of the future language that will take these ideas mainstream. But one will come.

Quora Answer : Where do you see computer programming languages heading in the future, particularly in the next 5 to 20 years?

Jul 31, 2018

There is a basic trend at the moment, which I think is becoming more apparent, and will become increasingly more important.

And that is to recognise the virtues of having declarative languages to represent bits of computation.

We've always had "declarative languages" of course. From Prolog to the more pedestrian SQL to describe database queries. To HTML to describe web-pages. To templating languages.

A lot of the time they just look like data-structures : XML, JSON etc. Nothing really exciting.

But things got more interesting when we started getting reactive programming moving into our frameworks eg. Angular and React to take the explicit flow of control out of updating the bits of a web-page. I understand there are similar declarations of dataflow in Build and Continuous Integration systems.

Eve was a series of experiments to make more beginner-oriented declarative languages. Based on ideas from BOOM – Berkeley Orders of Magnitude – Declarative Languages And Systems.

Johnathan Edwards' "Transcript" has "social data-types" ie. data-structures with declarative permissioning and synchronization characteristics. Eg. you can say "this dictionary is unique for each user but that list is to be automatically synced between all users looking at it on the server"

In another field, I think urbiscript was a fantastic language for programming robots. Basically a kind of C-like but augmented with a very convenient way of expressing event-driven parallelism. (Shame it seems to have died off.)

Then there's the logic programming described here :

(hat-tip Quildreen Motta of course)

The paradigm all these are leading to is a kind of central database / global state, which might consist of a bunch of propositions or facts. But might also include facts automatically mapped onto the actual external "world" (eg. position and posture of the robot, values of sensors, the state of various computers in our build chain, the contents of various chat windows distributed across a bunch of mobile devices, the contents of fields in web-form or position of mouse)

And then the program consists largely of declarative rules for how that database gets updated. What events trigger other events, what transformations are needed to map the data as it passes through, or to infer new facts from old facts.

We've had versions of this idea for a long time. Pandemonium, Prolog, blackboard systems, "stigmergic programming", even good old fashioned RDBMSs have had triggers and signals. (But because these have been rather obscure compared to the main imperative programming, they've been sources of confusion and bugs.)

But I think there's a chance we'll see versions of this paradigm going mainstream now. With the event handlers / update rules front-stage so being easy to see and reason about.

In the next five years, that's going to be in the form of frameworks for existing languages rather than new languages. But I wouldn't rule out the possibility of new frameworks which are as radically transformative as React has been in the last five.

Also, Javascript is evolving very fast. What I suspect may happen is that Javascript might well gain new capacities for writing macros / DSLs with custom syntax. And then this paradigm could turn up as an embedded language within the Javascript ecosystem.

But in 20 years time, I think it's very plausible that there will be mainstream languages of this paradigm. Doing things the imperative / OO even basical FP, way is too much work for the amount of software we'll be creating.

The difficulty / challenge is making languages in this paradigm that are general purpose / widely applicable enough. Most languages we've had like this, so far, have been fairly specific : logic, or relational database or UI design. We will want something sufficiently abstract and expressive and general purpose enough to build any of these things and more.

Related :

The next stage after this.Phil Jones (He / Him)'s answer to How would you design the perfect programming language?

Phil Jones (He / Him)'s answer to Which is the best programming language for developing a GUI application?

Phil Jones (He / Him)'s answer to In what direction computer science is going for next 10 years? I mean a hypothetical scenario?

Phil Jones (He / Him)'s answer to If Clojure is one of the most expressive languages of today and has similar expressive power as Common Lisp, which goes back to early 80s, can we say that the field of programming languages hasn't progressed much in the last 40 years?

Phil Jones (He / Him)'s answer to How would you design the perfect programming language?

https://www.quora.com/In-the-future-will-jobs-be-based-on-programming-C-Java-Python-etc/answer/Phil-Jones

Phil Jones (He / Him)'s answer to Will programming become obselete within the next 50-60 years?

Phil Jones (He / Him)'s answer to What do you think will be the next big and successful programming paradigm in the future? (Older answer)

Phil Jones (He / Him)'s answer to What is the next generation of programming languages? (Older answer)

Quora Answer : What programming language that has appeared recently in the last 10 years are you currently interested in or want to learn?

Aug 12, 2018

I've fallen heavily for Clojure in the last 5 years. It's now, officially, my "favouritest language forever". It's the language I want to work with today.

But maybe Clojure is just over 10 years old now. It's getting a bit old-skool and established for a question like this.

What's actually new and exciting me? In 2018?

Well, having grokked functional, I'm starting to get more of a sense of, and feel more intrigued and attracted by the idea of declarative and "logic" programming languages.

I've periodically looked into Prolog over the years, but it's never really clicked. And I'm pretty sure it's not the next big thing (for me) because of various specific characteristics.

But it does have elements of what I think I'm looking for next. An inference engine / Rules that fire automatically rather than explicit flow of control. An implicit database of state being managed through those rules. Etc.

I've never been a fan of types. The whole ML, Haskell, Idris etc. family didn't attract me much. But in Clojure I'm getting my head around Spec. And I'm thinking more about the virtues of types and contracts in languages these days.

So I'm intrigued by Shen, a Lisp with a built-in Prolog-like engine to define types and contracts, based on the sequent calculus. It promises that this is more powerful than the type checkers in the ML / Haskell family.

Another language which brings automated inference into a Lisp-like is Rosette which builds SAT solvers into Racket, and promises that it can use them to do program synthesis, ie. write code for you given certain constraints described as high-level declarations.

Then there's a language that I didn't pay much attention to when it first popped up : Eve. When I first saw it, I thought it was a bit of a gimmick. And there are definitely things about the Eve project that don't interest me. The focus on trying to write something for beginner programmers. And on graphical development environments.

But the fundamental idea of writing code as event-handlers, again without thinking about flow of control. The more I sniff it, the more important it smells. That has led me back to looking at BOOM – Berkeley Orders of Magnitude – Declarative Languages And Systems and the language Bloom / Dedalus.

Now ... I want to emphasize that I haven't tried any of these languages yet. I'm not even sure if I really understand what they're offering or talking about. I certainly couldn't write code in any of them.

But these are the things I want to learn soon. Because these look to me like sign-posts pointing to the mind-blowing, next-level shit that's going to be coming in 10 - 20 years.

People talk a lot about AI and how machine learning could make programming redundant. That doesn't worry me much because I know that programming is really about pinning down the edge-cases and making concrete decisions about exactly how things should be at the fine detail.

Machine learning with its fuzziness around edges doesn't replace that or what we need programmers for.

But just because we're going to need programmers to specify exactly what we want our programs to do, doesn't mean that we shouldn't have languages with more powerful and expressive ways to tell that to the computer. And the obvious next trend to accelerate is towards reducing programs to pure, minimal declarations of the constraints and logical inferences.

That's what these languages are hinting at.

So yeah, Shen, Rosette and Eve / Bloom are the languages I want to get into next.

BTW : this is the latest in a series of answers I'm giving on Quora where I'm thinking through these ideas and sketching out what I think the future is like.

Other recent answers worth reading with this :

Phil Jones (He / Him)'s answer to Where do you see computer programming languages heading in the future, particularly in the next 5 to 20 years?

Phil Jones (He / Him)'s answer to If Clojure is one of the most expressive languages of today and has similar expressive power as Common Lisp, which goes back to early 80s, can we say that the field of programming languages hasn't progressed much in the last 40 years?

Quora Answer : What will Computer Science and Programming be like in the far future?

Apr 30, 2014

There's no programming language that's good for everything. Not even "natural language". We invented maths notation so that people who are "natural intelligences" could communicate more precisely and effectively about certain abstract things.

No profession, from medicine to law to theoretical physics to art criticism is without its jargon which can only be understood by those who've taken the time and effort to achieve a certain level of familiarity with it.

Programming won't therefore become something that untrained people do by conversing in everyday language, for the simple reason that most programming will still be about involving the computers in specialist activities, and will need specialist understanding of those activities. Such specialist understanding actually prefers more formal and unambiguous notation rather than trying to use conversational natural language. (Even ideas and services that everyone uses and thinks they understand (think banking, or Facebook) still have complex conceptual ideas specifying how they actually work and deal with edge-cases behind the scenes. You would be hard pressed to specify how your bank or Facebook work to another human being, despite that human being being "AI complete". )

So, most likely, programming will fragment into more and more "domain-specific languages" for the increasing number of niches that are programmable. Each will be full of domain-specific assumptions and knowledge, though they may sometimes be different dialects of some basic grammatical syntactic patterns. (An example of this is XML which acts as a syntactic substrate to many different data formats.)

Apart from XML, C and Lisp are syntaxes which will probably still be hanging around. There'll be many of these specialist languages that still use C-like or Lisp-like notation because that's what people are used to.

The other thing about these domain-specific languages is that many of them will be hooked into huge online data-bases and cloud hosted services. (A bit like the Wolfram Language). You'll rarely write code to run by itself as much as you'll use it to present your problem to the cloud service and reformat the returning data.

There'll still be "serious" programming languages for defining and orchestrating what goes on behind the scenes. Such languages will have the following characteristics :

  • they'll be good for defining and hosting these other DSLs.
  • they'll have facilities for defining data-flow between systems. (Most likely some kind of reactive programming). Because the important thing about programming in the future is that you'll very rarely be programming one computer. You'll be programming an application that's distributed amongst many : servers and phones, the sensors and actuators of the "internet of things", multiple robots etc.
  • they'll aim to be as powerful, expressive and error free as possible.

(If all of this leads you to think of Haskell, that's deliberate .. .though it may not be Haskell itself.)