10
$\begingroup$

What I'm asking is what comes next? We've got code, we have all this technology on earth- My world takes place in our timeframe and has identical tech. A supersized military computer from years ago is to an everyday computer as coding is to ? So far, I've only been able to think of those new brainwave scanning things- The ones that use your brainwaves to translate information.

This can all be theoretical, and say that these people are able to create whatever the heck you're thinking of in the blink of an eye. They want a new TYPE of technology, a new form of technology, they want something new, not just stuck with what they have now. I understand it's a difficult question to put into words, so if any further clarification is needed I'd gladly oblige.

$\endgroup$

closed as unclear what you're asking by GrandmasterB, a CVn, Rob Watts, L.Dutch, Erin Thursby Mar 7 '17 at 4:17

Please clarify your specific problem or add additional details to highlight exactly what you need. As it's currently written, it’s hard to tell exactly what you're asking. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • $\begingroup$ Hmm, you might check out Zen Code at wiki.hackerspaces.org/Zen_Code. $\endgroup$ – theDoctor Mar 2 '17 at 20:45
  • $\begingroup$ Why is this on hold? The answer was already accepted and answers have been given. What exactly is unclear? $\endgroup$ – Nate Dukes Mar 10 '17 at 21:47
27
$\begingroup$

Instead of Code, train or even teach. - Jim Rush

This is a tricky one because "code" is actually so fundamental that its hard to have anything else. "Code" is a communication mechanism. Any one directional logical communication you do is basically going to be code.

To have anything beyond "code" I'd look at bidirectional communication. Instead of telling the computer what to do first, you tell it what to do and it asks for clarifications during the process of doing it.

This is very different in nature from "code" because code has to be perfect before it is used. Any imperfections are blindly followed by the computer. If there were bidirectional communication, you could convey most of your intent first, and then work with the computer to clarify any unclear parts while it was working.

Your idea of a neural link naturally settles into this pattern. While we can restructure our neurons to emit "code," it's much more natural to use them in a communication network to provide feedback while they are talking.

$\endgroup$
  • 13
    $\begingroup$ "code has to be perfect before it is used" - as a developer I can assure you this is not true ;) (I'm also just giving you a hard time, don't take this comment too seriously) $\endgroup$ – Broots Waymb Mar 2 '17 at 15:28
  • $\begingroup$ @DangerZone I was worried when I wrote that one, for exactly what you mention =) $\endgroup$ – Cort Ammon Mar 2 '17 at 15:58
  • 2
    $\begingroup$ More simply: Instead of code, train or even teach. $\endgroup$ – Jim Rush Mar 2 '17 at 17:55
  • $\begingroup$ @JimRush Mind if I borrow that phrasing? I think the more fundamental discussion of one-directional vs bi-directional communication is valuable, but I really like your phrasing as a summary! $\endgroup$ – Cort Ammon Mar 2 '17 at 18:41
  • 2
    $\begingroup$ a cs professor called explaining (even if only to a duck) what I want a program to do in English "step zero" of programing. If the duck then did the programing that would be nice. $\endgroup$ – user25818 Mar 2 '17 at 21:41
4
$\begingroup$

Coding, as we understand it today, is basically a series of unambiguous commands.
Or, in other words, a series of information being processed by clear rules.

Any programmer, especially the beginners, can tell how frustrating it can be that a computer always does exactly what it was told, no matter what the programmer's (or user's) intention was. This is based on the fact that the computer has no concept of intentions, and little to no concept of context.

If you look at (live, not online) communication between two people you quickly realize that context plays a major part in most communication. You still have information, but with context (habit being one of many aspects of context) you get meaning. Granted, things are getting a bit fuzzy there, which sometimes results in misunderstandings, but the principle holds.

So, if you want the next iteration of coding you could go with broad speech (and non-verbal) communication: you tell your computer what you want, the computer, much like a human counterpart, hears your words, sees your mimics and gesture, takes into account what was before, where you both are, and interprets your request, trying to determine your intention, rather than blindly following orders.

$\endgroup$
3
$\begingroup$

Look at neural nets. A trained network that gives results does not provide an algorithm that can be read back out! And saving it is not a list of procedural instructions to follow, but tables of weighting values.

Look at the recent success with so-called “deep learning” and use that as your springboard.

$\endgroup$
2
$\begingroup$

Code is just human readable instructions that get compiled into machine code. The actual hardware instructions are simple: Fetch memory from address X, put in register 4 Add register 4 and 5 put result in register 6 It is by building huge chains of logic like this that computers do amazing things.

There are many places to go from here. The most interesting is probably Artificial Super Intelligence bootstrapping itself. Currently there is a neural network that has been trained on code samples. It can assemble code to solve real problems. This is important because now the program can expand itself. There's nothing that says a program that writes programs wouldn't be able to use what it has written. Now programs written in code can write their own code. But why human readable code? The program could just as easily examine machine code. Now it is able to string machine code instructions together in a way that perfectly captures the peculiarities of a machine's specific hardware. Studies have shown that when evolving algorithms are involved they're able to take advantage of emergent traits that were never designed into them. Sometimes a minor flaw enables strange behavior. No circuit is perfectly built so there are always little peculiarities. Let's say this self programming machine could take advantage of internal interference as part of its operation. Now the machine is doing things it was never designed to do. Now allow the machine circuit assembly capability. The circuits won't have recognizable logic gates at all. They will be composed entirely of these weird behaviors, interference and cross talk, analog feedback loops. They'll operate far more like biology than electronics. Now the things we used to express in instructions and logic gates get done by tiny piles of silicon containing minuscule incomprehensible circuits. Now the ASI is going to want to incorporate the circuit manufacture capability everywhere. The circuitry can grow. Let's hope it doesn't choose to grow indefinitely.

$\endgroup$
2
$\begingroup$

The next step would be a fully networked turing complete natural language processing engine.

Every single computer on the planet will link together into a neural network - and understand every single request.

Every language, gesture and other body language (including micro-expressions) will be evaluated, local colloquialisms will be understood.

In most cases, predictive analytics based on environmental scanning will allow the system to instinctively know what someone will want it to do before it's even asked - it will know the entire history of each user, and datamine the probable outcomes before anything is asked.

Not learning to 'code', but just asking a computer to do something, and it having the skill and sense to infer exactly what was required based on the situation.

No ambiguity or 'weird' loop behaviour, just pure understanding, based on the situation.

It doesn't need to read brainwaves to understand - its 'deep learning' algorithms will be able to make perfect sense of any request.

It has the entirety of human knowledge at its grasp.

$\endgroup$
  • 1
    $\begingroup$ As a note, the on the "will link together into a neural network"- they won't. A neural network is a very specific construct, where the first layer receives inputs, data goes through layers (ONLY passed from the previous layer), which are eventually output to output nodes (which are entirely different nodes from the others). They'd be in a network, certainly- but not a neural net, since that's a very purpose-built specific construct. $\endgroup$ – Delioth Mar 2 '17 at 19:36
1
$\begingroup$

Possibly symbols and images rather than code.

Today, the vast majority of code is instructions on precisely how to behave and achieve outcomes/output.

There are areas of computing (system provisioning via Desired State Configuration is a good example) where a change is underway to instead describe WHAT you want and allow other specialized systems to work out HOW to give you WHAT you described.

So, a paradigm shift of sorts.

I like your idea of a nueral link. Some sort or neural link to a computer system where the user is trained to communicate in Images of desired outcome and/or chains of Desired outcomes.

$\endgroup$
  • $\begingroup$ Symbols and images would be just another form of code, wouldn't they? $\endgroup$ – Mołot Mar 2 '17 at 7:59
1
$\begingroup$

Code is the next step after code.

The concept of "code" is fundamental. It is what we call the instructions that a computer uses to understand inputs and generate outputs. Asking "What would the next step be after code?" is basically akin to asking "What would the next step be after math?". More math comes after math; increasingly complex math, sure, but it'll still be math.

What would the next step be after 'coding'?

This might line up more closely with what you're asking. Nowadays the concept of code is synonymous with Silicon Valley types drinking coffee and typing lines of instructions into their terminals, compiling, and running the programs. Asking if this will always be the way computer instructions are generated is a more interesting question, and in some ways we're seeing hints that this likely isn't going to stay the sole (or possibly even primary) method of code generation.

Neural nets are becoming increasingly more common, as well as increasingly more sophisticated, and while these still generate 'code' the results are often strikingly different from a human-designed program. This computer-generated code typically defies the more linear logic of a human coder's instructions, but nonetheless it is still a set of instructions which take input and produce output.

$\endgroup$
  • $\begingroup$ I'm not sure if I'd call an artificial neural network's output "code". They're more of a construct that you can push data through and they'll give a result (give it the encoding of an image, one of its output nodes tells you that there's a goat). The neural network itself is the code/construct ("code" used loosely, more apt would be "algorithm"). $\endgroup$ – Delioth Mar 2 '17 at 19:34
  • $\begingroup$ I'll admit my above text is too sparse and basically conflates neural nets and the learning algorithms that create them (which themselves may or may not be the product neural nets). $\endgroup$ – fenix d.Anconia Mar 2 '17 at 20:47
1
$\begingroup$

So many thought-provoking answers. Let me add some more thoughts.

I like the idea of having a bi-directional conversation with the computer. I tell it to do X. It does it. If it doesn't give me the output I expect, I modify the instructions or add more. The "code," which is nothing more than a sequence of instructions, evolves to the functionality I desire.

I learned to program on an Apple //, using Applesoft (interpreted) Basic. I'd type in a statement on a line. It might gripe about that statement (if it was significantly flawed). I'd build a sequence of statements (a program). At any time, I could run the program and see how it behaved. The program evolved. It was a bi-directional conversation between myself and the machine. I could decide which parts of that conversation to keep in that context, which parts to throw away.

Context is important; being able to save your work establishes, and allows you to regain, said context. Because the context needed for this problem is not, necessarily, the same context you need for another problem.

Interpreters are notoriously slow. If you can get a particular piece of functionality "nailed down," it would be helpful if it could be compiled (for faster performance) and added to the environment, able to be called from interpreted statements. This is more of a polyglot approach, frequently found with Lisp systems. You can work with a REPL, building functionality, then export some of the statements from history into a file, edit it, compile it, make the compiled code part of the environment / context, go from there. I tend to think that interpreters / REPLs are a much more natural way for functionality to evolve, with compilers only getting involved once we want to optimize performance. Varying fractions of the context / "code" would get compiled. Eventually, maybe all of it. But maybe not.

All program code, today, is typed in as text then parsed into an Abstract Syntax Tree. Skip the text, create the tree directly; make creating functionality more like dragging / dropping elements of functionality from a palette into a workspace, rather than typing. Put the nodes and trees into a 3D immersive environment and "code" in VR. Just how much more complexity could you view and comprehend if it was a 3-dimensional tree of nodes and connections, hanging in space?

What is there to prevent you from creating (I hesitate to say "writing") "code" which would run across multiple processors? Nothing. Provide an input system which lets you see / manipulate collections of data and your "code" could scale. Any languages out there which do this already? Oh, let's see; there's APL / J, which has had interpreters available since the 1960s. And R, more recently. And SQL; I use the latter, pretty heavily, and it's not uncommon to see the machine chew through gigabytes of data, using a dozen or more cores. If I had more data and more cores, I could use those and do even more analysis on larger pools of data. SQL doesn't really do rigid sequences; this subquery calculates this, which gets used by that subquery which calculates that, with the results bubbling their way up to the final result. There's little in the "code" which imposes serial bottlenecks.

Even if there IS a sequence involved, what's to stop you from running this rigid sequence across millions of data elements / subsets, in a map / reduce paradigm, auto-scaling it to, potentially, unlimited numbers of discrete cores? Money, time and hardware. Google did exactly that for their search engine.

The sum of these thoughts is pretty far from the modern paradigm of typing code into a text file, feeding it to a compiler, linking it and testing, then going back to typing for the fix or the next stage in the development. Since tablets and VR really aren't good environments for typing, I expect to see some of these developments sooner, rather than later.

$\endgroup$
0
$\begingroup$

Parallel processing computation is the answer. Yes it is that simple. Admittedly the complexity of programming parallel processing computers will be a hurdle. Computers today are basically Von Neumann serial processing engines.

A single parallel computer could do all the computational tasks of an entire city. There would be no need for all those individual serial processing computers. However, it will take an enormous amount of investment to get here. First, to develop the technology, and secondly, to implement on a wide scale.

$\endgroup$
  • 1
    $\begingroup$ Almost all modern computers are parallel computers (even if you don't take into account the processing architecture, which is almost certainly parallelised at some level). Anything with multithreading capability engages in parallel processing. Anything with a GPU is so massively parallelised that it's frankly insane, and yet these things are programmed using code $\endgroup$ – Joe Bloggs Mar 2 '17 at 10:27
  • $\begingroup$ @JoeBloggs I was principally thinking of the processing architecture. There were studies back in the late 1980s, suggesting the possibilities of totally colossal parallel processing computers. Of course, it needs code, but they were intended to exploit the sheer computing power available. Insane? Absolutely! That's why I mentioned the investment entry barriers to their implementation. They're frankly prohibitive. $\endgroup$ – a4android Mar 2 '17 at 12:17
  • $\begingroup$ GPU's are essentially exactly what you're describing. Take a look at Nvidia's CUDA, which is GPU language abstraction. As for totally colossal: Bitcoin mining, anyone? $\endgroup$ – Joe Bloggs Mar 2 '17 at 12:21
  • $\begingroup$ @JoeBloggs I'm not sure if they are exactly the same. The 1980s studies contemplated 3d arrays of surprisingly low powered chips are their parallel processor systems. It wouldn't be surprising if their vision of where the technology was wrong. It was the eighties, after all. As envisaged they were incredible machines. Perhaps it is the phlogiston of computing. $\endgroup$ – a4android Mar 2 '17 at 13:19
  • $\begingroup$ My point is that we are already using hugely parallelised structures of really low powered chips. GPUs are those incredible machines envisaged in the 80's, but so few people can program for them effectively that we're reduced to using them to control the timings of little lights flickering on and off so we can watch a cat jumping into a box. $\endgroup$ – Joe Bloggs Mar 2 '17 at 13:31

Not the answer you're looking for? Browse other questions tagged or ask your own question.