Try emergent coding
codevalley.com
codevalley.com
This website is really rough, the writing is dense and the first rule of video club is don't get one of the founders to narrate the video unless your CTO is Morgan Freeman. That said, I think this is just so unbelievably audacious that it's worth a look anyway.
The concept seems to be to take hardware's supply chain model and use it for software development. So instead of having one company figure out your requirements, plan the project and build everything, you use a marketplace. Each part is put up for bidding by any supplier, meaning you get specialisation and competition.
Oh, and the suppliers are actually software agents. And "parts" includes everything from requirements gathering to opcode generation. In essence they want to build their own industrial revolution for software development, from scratch, using (basically) DAOs.
Is that possible? I have no idea. My first instinct (and second, and third) is no. But if it is, it could blow up the entire industry. Rubbish or genius, nothing in between.
This could perhaps be a great application for Idris-Style dependent types. For example, you could create an RFP for "List.append" with a few constraints, `len(append(a+b)) == len(a) + len(b)` and so on and then know that the market will create something you can automatically verify to a certain degree.
Any developer can vet suppliers before they automate an agent to contract them. For example, you could contract the agent you're looking to vet, hit 'build' and be returned a small program to carry out List.append a b. If the program works as you expect, you have then verified (in that instant of time) that the supplier is sound, and can proceed to building your own agent to contract it.
("It is difficult to get a man to understand something, when his salary depends upon his not understanding it!")
> All layers of abstraction are encapsulated into a single scalable system. Since there are no codebases and thus far fewer unintended consequences, Code Valley neatly sidesteps the software complexity trap. We don’t need to search for silver bullets anymore — the Werewolf has been retired to a harmless cottage, no longer able to bother the were-proof residents of the Valley.
I ... can't see how the top level 'pilot' operations don't effectively count as a codebase, just a really weird one.
It's very kind of you, but this is clearly the former.
Can some try to have built a simple 'online calculator' - you know, with buttons, square-roots, logs. etc.
Anybody?
No?
A practical demo?
You can build it to run on Linux (https://marketplace.codevalley.com/pilot.html#linux-fibonacc...), or to run in a browser (https://marketplace.codevalley.com/pilot.html#browser-fibona...). You will need to pay a few satoshis (to the agents you will be contracting), and if you don't have a bitcoin wallet, just shoot me an email (julie@codevalley.com) and I'll foot the 50c for you :).
edit: added clarification
It looks like the guys behind Code Valley have been working on this for a long time with patents[3] dating back to 2003. There's probably some sort of Internet law at work here where the longer an idea has been worked on without traction, the more hyperbolic the prose becomes in order to maintain commitment from the founders.
[1] https://en.wiki2.org/wiki/Joe_Firmage [2] http://academyofscienceandarts.org/videopage [3] http://www.freepatentsonline.com/y2006/0161888.html
I guess the real example is this one:
"For example, the compare::bytesequence::lesser agent, when contracted, will design the code that will compare two strings. At first glance, a developer may see that title and assume that the compare::bytesequence::lesser agent will actually compare one given string against another, but in actual fact, the compare::bytesequence::lesser agent will return tailored code that compares two strings."
So, it's template metaprogramming but with confusing terminology? I'm trying to give this a fair shake, but it doesn't make an argument for why this is a useful abstraction layer.
In this system, developers are incentivised with the prospect of direct payment to deliver a correct fragment. If we assume that game theory's rationality will prevail, I'm sure you can see how (in a perfect world), all fragments will be correct. However, we know the world isn't perfect and that there will always be an irrational player who is motivated by things other than direct remuneration... a player who has malicious or duplicitous intent.
There are three pieces of good news regarding how the system deals with these players: (1) The first is that it is actually a good deal more difficult for a bad actor to actually produce, well... bad (binary) code, compared with current methods. In this system, every agent provides its service by contracting other agents. There is no glue code in between; no opportunity for a developer to 'write' additional (malicious) code. If a developer wanted to create an agent that 'injects' malicious code, he would have to do so by contracting agents to design and 'inject' that code. Then, the developer would have to deploy that agent to the network where it would try and directly compete with other legitimate agents, agents with good reputations and a solid history of successfully completed contracts.
(2) The second piece of good news is that although these irrational players technically can enter the system and build an agent, their time will be extremely short-lived. Because of the recursive nature of the system, it has near-perfect accountability. Malicious players are easily spotted and basically ostracised by the wider compiler community. (Who would want to contract an agent that is known to return faulty/malicious fragments?)
(3) The third piece of good news is that the system itself only becomes more resilient and hostile to bad actors the longer it is operational. 'Honest' players (better yet, efficient players who cleverly optimise their agent's designs) are just as easily identified and even more handsomely rewarded. Remember how an agent achieves its service of compilation? By cleverly contracting other compile-as-a-service agents. Since these 'supplier' agents will return the smaller fragments that make up the larger fragment the agent itself returns, an agent's livelihood is dependent upon the reputation of its suppliers. This means the developer will choose its agent's suppliers very carefully, likely vetting them prior to building the agent itself. Over time, as suppliers become a known and reliable quantity, the ties between client and supplier agents are strengthened and it becomes even more difficult for a bad actor to find any kind of footing.
It is a strange concept indeed to ask someone to trust a binary that has no 'source code' to inspect! But when you know and trust the compiler of that binary, it is a no-brainer.
Do you mean "someone" as in the author of the template? Or as in the template itself?
What are the specific limitations of agents? What can they do? How are they written?
I mean "someone" as in the author of the template (to use your phrasing), yes.
> What are the specific limitations of agents? What can they do?
What each agent does, not matter where they sit in the network layers, is the same; they request information from their clients, they make some decisions and then they contract other agents. In this system, everything is a (compiling) supplier. A developer creates an agent to build on and inherit the knowledge of its suppliers, adding a little knowledge himself in the process, and ensuring that his agent returns compiled code.
Have you had a chance to check out this video (https://www.youtube.com/watch?v=qTl-V58cG1w)? It sheds a bit more light on how the service an agent performs is that agent doing its own part in a distributed compiler.
A developer can only build an agent if its suppliers exist, and if the compile-time interface protocols have been defined. Are they the sorts of limitations you meant?
> How are they written?
This system bootstrapped itself (and achieved PoC at the same time) back in 2013. Agents are built by agents. There is a special agent that sits on top of this hierarchy of agents that is designed to specifically capture a developer's requirements for their agent (what it should ask its client, what decisions it should make, and who it should contract) and translate these requirements to contracts to agents which will ultimately build that developer his agent. (The recursion is a killer sometimes, isn't it?)
This special agent that sits on top of the hierarchy is called the 'Agent-builder' and will feel to a developer like an IDE or visual programming language (designed specifically to design agents).
Right...like...open source?
Here's a better one: https://www.youtube.com/watch?v=PZCv696rMCk
This has to be a scam, a joke, performance art -- something like that.
Edit: After reading the website more in depth, I am not sure anymore. I get the sinking feeling it's one of those situations where someone has an idea that might in some way make sort of sense but not really, but they somehow have a circle of support that funds or helps them do "stuff". Maybe even picking up some true believers as investors?
For instance, I was contacted about an opportunity to work on a firewall "that uses soundwaves for data so it's hacker proof". They claimed they could break AES at will (hence the need for sound-encrypted data). They had lots of promo materials built, and had spent years on the idea. Had a sales guy/evangelist getting people interested. Even had prototype hardware.
And a little more detail than "Oh my god! where are your parents?"
I'll take what I said in another comment in this thread:
"This system bootstrapped itself (and achieved PoC at the same time) back in 2013. Agents are built by agents. There is a special agent that sits on top of this hierarchy of agents that is designed to specifically capture a developer's requirements for their agent (what it should ask its client, what decisions it should make, and who it should contract) and translate these requirements to contracts to agents which will ultimately build that developer his agent. (The recursion is a killer sometimes, isn't it?)
This special agent that sits on top of the hierarchy is called the 'Agent-builder' and will feel to a developer like an IDE or visual programming language (designed specifically to design agents)."
Out of curiosity, have you signed up to try your hand at building a few agents? I can personally guarantee you an invite, and once you have those login details, you will be able to see an interactive example expression of an agent. This expression is the closest thing this system has to the 'source code' you are referring to.
Anyway, I can give it a try if I have time, but surely you can provide a more concrete example than this. For example, what does the "string reversal" agent look like?
* Conceptual vs actual expression of an agent that will compile code that clears a string - https://www.youtube.com/watch?v=MlwjHQQgNRQ (voiceover)
* Actual expression of an agent that will compile code that computes an exponentiation result - https://www.youtube.com/watch?v=Fmwcs1fu6wM (no voiceover)
* Actual expression of an agent that will compile code that adds a bit to a bit array - https://www.youtube.com/watch?v=RCg8cOZyADE (voiceover)
Do you have any examples of anything "complex" being written with this?
> Do you have any examples of anything "complex" being written with this?
You could argue that an agent itself is a complex thing being created using this technology :). A developer expresses their requirements using that visual domain-specific programming 'language' that you saw, and then these requirements are translated to contracts to agents that will end up building the developer his agent. (Recursion... it's a killer sometimes.)
But for an example that you can actually relate to, here (https://www.youtube.com/watch?v=U6jtCVOQiuA) is a cut-down version of our corporate website (with back-end server) being built as a single program by contracting about 8 agents from the behaviour layer (the 'domain-specific' layer of the network). Please note that this example uses our old interface so it looks a little rough compared to the current interface.
(These agents exist in the previous iteration of the network, and are now defunct. We are working our way up to these agents in the current public-facing iteration of the network, so that the community of developers can join and build their own agents.)
Why one decided to make a completely new vocabulary that feels incredibly inaccessible to even the technical audience is beyond me.
And you don't need to worry about suppliers increasing their fees and holding you ransom... again, that represents demand: another enterprising developer can come in and fill your need for a more reasonably priced service and undercut the exorbitantly priced supplier (who will likely go out of business quick-smart).
Instead of a hello world example in a video I would like to see a high-level example for something really complex, like:
"The site you're currently viewing is served by a web-server that was designed and built by this network of agents in 12 minutes."
ok then, how high level and reusable that code actually is? Show it.
Is that video really supposed to show the power of this thing?
That visual template you saw was actual contracts to agents in the network. As soon as the expression is built, these agents receive contracts and the hive compiler begins forming. Bytes return shortly thereafter.
This technology does still have a long way to go, but it has the potential to do some powerful things. Right now though, we (the Code Valley team and developers who have joined and are joining) are still in the phase of populating the lower layers of the network. We are working our way up... when the behaviour layer (the 'top' layer) is populated with agents, the 'power' you are looking for will be more clear.
However I've read the main page, looked at 3 videos. Tried the demo... I still don't really understand what's going on.
Now, it is 6am and I've been up all night working on a project. But if I'm really trying to understand what's going on and it's not clicking /at all/ then it probably means there's a problem with either the description or the model itself.
The User side of things does not require a login. You can learn more about how to use the technology in the User Guide (https://marketplace.codevalley.com/use-it) and in the Interactive Tour (https://marketplace.codevalley.com/use-it/module0-step1). If you pick that up pretty quickly, you can request an invite to join the other side and become an agent builder (https://marketplace.codevalley.com/signup).
The only reason we have the invite-only mechanism in place is to ensure the integrity of the contributors. The system is so new, and reputations are still being developed; new contributors must be assured of some measure of the calibre of other contributors.