Today's computers are limited in what they can do, by way of their architecture's constraints. The von Neumann architecture has served us well up to this point, but going forward it's going to be a real handicap. But it isn't just the architecture that needs rethinking. As you say, 'we probably won't program these new machines in the traditional sense'. And you're probably right. Programming languages are also part of the problem. We've wasted so much time reinventing the wheel, over and over again. I don't know what form the next computing architecture will take, but I do know there will come a time when the notion of using a 'programming language' to get things done will seem quaint. Hell, I thought it was an archaic way of doing things 20 years ago, and it's why I didn't pursue a career as a programmer. The tedium was incompatible with my temperament!

You mean writing a series of logical instructions in order to solve problems is tedious? I wonder what future platform will be created that doesn't require an ordered series of logical steps to solve problems...

Well, even today there are computing devices that don't require an ordered series of logical steps (in the form of program code) to solve problems. So you don't need to wonder about it. The future is already here.

However, there could one day be a means to easily implement algorithms in hardware.

To clarify, I'm not thinking of ASICs or FPGA's, which of course already exist and have for quite some time. Neither are very 'easy', and the expense is real.

Just out of curiousity, do you honestly believe that the way we've been getting computers to 'do things' is never going to change?

> Well, even today there are computing devices that don't require an ordered series of logical steps (in the form of program code) to solve problems. So you don't need to wonder about it. The future is already here.

Could you give us some details about what you are talking about here, so that we don't have to play guessing games?

I am curious about what career you chose.

I'm curious why you think things can never change. Maybe you can't imagine anything different. That's OK, other people will drag you into the future.

I am at an utter loss to understand what made you draw the conclusion that I am anti change based on my comments in this thread.

yeah, my bad. thought you were the guy above me. Apologies.

As for the career I chose, you can assume it wasn't anything to do with computers, lol. (Although I almost went the Cognitive Science/Computer Science route back in my younger days, before realizing I wasn't nerdy enough!)

I think you underestimated your nerdiness back then. Here you are all those years later responding passionately in a thread on rescuing programming from the von neumann style.

Well if nobody is passionate about it, nothing will change. I'm sure I look like a fool for it, but someone has to.. might as well be me! :)

My interest in AI and computer architectures never went away.. I just decided not to turn certain interests into a career, and walked away from the chance to be gainfully employed as a programmer. At the time I felt there had to be a 'better way', and I've been trying to come up with that 'better way' ever since.

I'm probably somewhat bitter that my research (probably) won't get translated into something physically tangible and complete, as I'm running out of time. Cancer is unkind that way.

It's entirely possible that I've been chasing a pipe dream all these years though, and while that would be a shame I'm realistic enough to entertain that notion. I've already accepted death, so at this point I can accept this, too. But of course I don't really believe that is the case here. ;)

>Programming languages are also part of the problem. We've wasted so much time reinventing the wheel, over and over again

That's a good thing.

If we didn't we'd still use stone or wooden wheels -- like in ancient times.

People say "reinventing the wheel" when in actuality it's "improving the wheel".

CL is not 60's LISP, Rust is not C, C is not Algol, Haskell is not ML, and Go..., ok, Go is like Algol 68.

>I don't know what form the next computing architecture will take, but I do know there will come a time when the notion of using a 'programming language' to get things done will seem quaint.

This I feel is too hand-wavy ("there must be a better way").

Programming language is sort of like math -- logical instructions.

The scientific underpinning of programming is algorithms. And those are expressed by programming languages.

We cannot really replace algorithms with anything else, like we cannot get rid of equations in math.

We might abstract them more ("robot, write a program to do X for me") or less (some "visual programming" thing), but in the end, programming and algorithms are part and partcel with solving problems.

Wheels are the most effective way to transport things on land. So of course it's in our best interests to keep improving that wheel.

Certainly, language is useful when hashing out a problem on paper (be it pseudocode or math equation or whatever). The abstraction is convenient. But programming languages are not a requirement for computers to do their work. Languages exist for our benefit, not the machine's. One can use software to do work on a computing architecture, or that same algorithm can be implemented in hardware and run a hell of a lot faster.

The problem is that, while we can come up with all kinds of algorithms, we can't seem to agree on what programming language to use when implementing those algorithms. I guess I'm arguing that the languages are getting in the way of the algorithm, and it would be nice if there were a way to achieve something closer to a 1:1 relationship between algorithm and implementation. We're always going to be inventing new programming languages because we can't reach a consensus on what is the 'best' abstraction. It's become ridiculous at this point.

Algorithms are currently expressed by programming languages because they have to run on general purpose, programmable von Neumann architectures. I mean, yeah we could skip the language and just input machine code, but that would of course be ridiculous. That's why we use compilers.

If there were an easy way to implement algorithms directly in hardware, why would we bother with programming languages?

Take, for example, a supercomputer. If the kinds of work a supercomputer does could be implemented directly in hardware, I think it would be safe to assume that researchers would be all over that. The gains would be enormous.

If there were a hardware-only 'Travelling Salesman' algorithm that showed astronomical gains in efficiency compared to the conventional software implementation, don't you think that would be important and useful?

Do you feel similarly about written language?

A computing architecture doesn't need to use a language.

The language is there for our benefit, not the machine's. I'm merely suggesting that all these (by now, countless) languages are getting in the way of efficiency. If we have something in mind that we want the computer to do, why not just do it in hardware directly, as that would provide the most optimal efficiency?

I don't 'feel similarly about written language', because written language is kind of important for human communication. Last I checked, human brains have very little in common with computers and our capabilities are not the same as a computer's. We are not computers, we're social organisms. So we need written language. One could even say that we need written language to do 'our work'. Society would fall apart without it.

But I guess if there were a better way to communicate or record/relay our thoughts to others, I'd be all for it.

> Liberated implies that today's computers are limited in what they can do, which I disagree with.

His argument is that it's programming languages (and programmers) that need to be liberated from the von Neumann style, not computers.

You might be interested in [Likely](http://liblikely.org/), the programming language I've been working on. One of its core tenants is that "training == compilation". I haven't given much thought to departures from von Neumann style architectures, but with emerging/de-facto standards like OpenCL and LLVM I don't see any reason why, at least for computer vision algorithms (my domain) we can't train/compile to FPGA.

Since I am seeing this a lot lately, you probably meant tenet. Tenant means something entirely different.

Flow-based programming is an example that's a bit easier to understand and toy with:

https://en.wikipedia.org/wiki/Flow-based_programming

Lambda Calculus in its many forms is probably the original:

https://en.wikipedia.org/wiki/Lambda_calculus

Here's an example of its (i.e. LISP's) power in bootstrapping a whole toolchain with several languages starting with assembly and LISP:

https://speakerdeck.com/nineties/creating-a-language-using-o...

Also used in hardware design for integration with software:

http://scheme2006.cs.uchicago.edu/05-saint-mleux.pdf

I don't think he meant to liberate the mechanism of computers, but instead our worlds and conceptions for talking about computer programs... which are then translated wherever.

More mundanely, see FPGAs. They can be thought of as "computers" (and you can build a von Neumann core on one), but are programmed using different languages (Verilog, VHDL) and a completely different paradigm that involves lots of parallelism.

There have been attempts to force imperative/functional paradigms into FPGAs, but they have not been well-received simply because it doesn't make much sense to do that.