Recent blog entries for loadquo

There is another way not mentioned on the GNU website, that you can help the free software movement. And that is to create a technology that helps make the benefits of free software easier to attain.

For example broadband facilitates the spread of free software as more people can download large source packages more quickly and so spend more time working on the source. Also p2p technology might in the future make it unnessescary to have large centralised servers for the ditribution of free software.

I'm looking at how to help the Freedom 1 of free software, the ability to adapt the software to your own needs.

However if we are to avoid having a huge unwieldy human speech to machine code program that needs to be udpated by coders, I think we will have to rethink how computers work.

What I am proposing, although it may not be the only way of to help freedom 1, is to try an evolutionary aproach. Some of you may have heard of Tierra, which was one of the first computer systems that had self-replicating computer code. The process of coding in that program was embodied in a random changes to code, to simulate cosmic rays and the like. Now as we coders know, that method of programming isn't the best :). So my proposal is to encode a method of programming into the programs themselves. And this method is then used to alter a copy of that program, hopefully to improve it. Then the programs complete a task, fetching information from the internet or similar and the user rewards the best ones. Those with the higher reward survive.

This means the method of programming can also be maintained and improved, as the previous generation can change the next generations method of programming. Also my memory has unix inspired permissions on all sections of the memory so that programs can protect themselves from overwriting and viruses in the system.

It also means programs can communicate with each other and I hope they will cooperate, fulfiling the Unix philosophy of lots of specialised programs.

I have started work on it already, but I am looking for help, which is not easy to find on a risky project that may not pay off very quickly, and also different views on how free software might go in the future.

I've been mulling over purely probabilistic learners, like the ones described here and here. And I have quantified, why I don't think they will be a complete picture of how we learn.

It is because they ignore what I call probabilistic oracles, although there may be a different name for them. Basically they get all there probabilistic information first hand, they cannot currently incorporate other probabilistic information, from other learners. For example I could not convince them that suns age and change colour over time, without showing them the actual stars changing colour. Whereas we know that stars are likely to change over time as they run out of hydrogen and other lighter atoms, without direct experience.

However if you do allow probabilistic oracles, you get into problems of trust, which oracles do you trust and which don't you.

Hopefully my solution where the trustworthiness of an oracle could be encoded within a program and those programs evaluated to see how well it acts in the real world, might get around those problems. Although these sorts of systems do definately bear more thinking about.

Hmm, I wonder how well the diary portion of advogato will scale in the future. Will it still be readable and a viable platform for the exchange of views, for example if the number of diary entries increases a lot. What happens if between the time you log off, to the time you log on the number of messages puts your entry and any replies off the most recent diary pages, how will you find them?

It seems that it is being used for a whole mishmash of different purposes, from professional diary to personal, and a method of informal chat about advogato itself. Perhaps a more specialised approach would be a good idea, categories perhaps? Any ideas people?

Anyway, work on Codesoup is going okay with a seperate (slower) sub-project for visualisation and program design being near alpha release. A few problems include slightly different behaviour of the programs (they don't seem to evolve as fast) and trying to figure out automake so that it will include the sub-project and a known bug in the visualisation. Anyway once those are sorted it should be time for another release.

I am working on a qt interface for my project codesoup. It contains a custom widget that displays a representation of the internal state of the soup, and a few buttons for control of the actions of the soup. This should be hopefully useful for debugging the internal programs.

Next on the list of things that most need improving is the compiler for my own brand of assembler. Ideas include the ability to reuse sections of code (including passing in Symbol Information from the main file pseudo-functions).

I am also thinking about my real work, which is designing programs that alter, in a fairly random but clever way, a copy of themselves. Coming up with a few useful ideas, but none that seem amazing.

I have been working on the Frequently Asked Questions for my project, Codesoup, and because they are short at the moment, I decided to post them here

1. What is the system It is a evolving system where programs compete for reward from a user. Currently the programs copy themselves and modify their offspring. The ones that get the most reward can overwrite other programs. There is also scope for cooperation between programs to solve problems.

2. What would I use this for?
   Currently this is a research project, so researching is the order of the day. Once the research has been done hopefully it will be useful for complex online learning. By online, I mean the system will interface with the problem directly, rather than being presented with a lot of pre-specified training data.
3. How do you see future development?
   Ideally it will become a community project and people will use it when they need to learn a problem that this sort of system can solve. The ultimate goal would be to produce a computer (possibly wearable) that used this sort of system as the operating system. Although that is so far in the future it is not worth thinking about at the moment.
4. What success have you had so far?
   Limited, the system can evolve although at present the internal mutation operators are too destructive so evolution tends to remove the variation. This was a very primitive method of variation so it was not suprising.
5. Why are you doing this?
   Because I don't think that the current way computer programs are developed is the only way or the best way for the user. So I am exploring other ways to create computer programs.