For those who haven't heard: Raspberrypi.org is holding a programming contest. Only 18 and under, though. (Barely made it in )

Rules are pretty simple: Must be all your own work (minus open-source libs and such, and within reason) and it has to run on the rpi. It ends in september, entries start in august.

I'm currently at a loss for ideas. I want to make an evolutionary dubstep generator bcause it would be awesome, but I have no idea how to do genetic programming. Any other thoughts?

Oh, and I do have a RPi, so hardware-based things are not out of bounds.

Genetic programming is easy: have a random generator seed your stuff. Find some way of judging which one is more fit, and breed them. Wait a bunch of generations, and voila- you have dubstep.

(Note that this is most definitely not the right way to do it, nor the most efficient)

EDIT: This seems legit, and more helpful than what I said: EDIT: This one is much better: http://www.geneticprogramming.com/Tutorial/

I think you should do something that interfaces with the calculator. I don't know what, though.

He could port one of the many transfer programs floating around.

Make a supercharged pixel art/index painting raster editor!

Porting something wouldn't go so well, since all the code should be written by me. I'll look at that genetic programming tutorial. I really want to try that Especially after I saw that HaD article where a genetic algorithm made an FPGA that used magnetic flux

I'd say that you should make it be a gCn bridge, but the Raspberry Pi is way overkill for that sort of application, if a simple Atmega 328 could do the same thing, as long as it has a network connection of some sort. I'm glad that you read that FPGA article; I thought it was some amazing work. Although seana11 and I don't always see eye-to-eye, I actually like the idea of a generative process for dubstep creation.

I think seana's main complaint is the general dislike of dubstep, not the idea of generating it.

Another idea I've been thinking about for a while is a programming language that uses low-level assembly-style commandss and memory access, but has a generic enough syntax to be used on different processors.I'm thinking of basing it on GCC as an include file so any missing functionality could be supplemented by the "universal language". The include file would have to be different for each architecture, but it shouldn't be too terribly hard, just a lot of #defines.

Sounds to me as if you just re-invented Java's bytecode. But it sounds as if your proposal is for something lower-level even than that, which might be interesting.

No, he reinvented LLVM IR.

well, it's not going to be a VM, unlike both of those. It would compile to native assembly.

Wait, LLVM isn't looking like a VM....confusing. And it doesn't look like a language either.

No, LLVM IR is an intermediary language between whatever the frontend compiler you're using spits out, and assembly. For example, Clang can spit out LLVM IR, which the IR compiler effectively turns into machine language. While it's mainly for x86, it also supports ARM. What you're talking about doing does indeed sound like this.

Um, LLVM IR can be translated to any processor that LLVM supports. It's put together such that frontends (such as clang) translate input code to an internal representation which the optimizer runs on, and emits IR. The IR is processed by a backend to generate code for the target.
Existent backends include x86, PPC, ARM, MSP430, Alpha, SPARC and MIPS.

Ok, that sounds really cool. I also saw that it supports python as an input lang...

Anyways, I still need ideas, since I probably won't be able to learn enough about signal processing and genetic programming before the deadline.

Well, the RPi has a bunch of open contacts; you could do something cool with interfacing with them to control something else. A heat-seeking nerf gun would be cool. (3 infared diodes and some servo motors would work out nicely).

I think I hit on the perfect idea. It fits with the RPi foundation's goals (some nice brownie points) should be completable by the deadline, and most importantly, it's within my current skill range.

I call it the ERF: The Extensible RPG Framework. It's a framework (no rly? ) of python scripts and modules that lay out the basic necessities of a classic RPG. It's going to be structured such that users would modify the existing scripts to add new stuff. Not only is that more efficient, it encourages more internal probing and modifications.

I'm also releasing it under its own Open Source license, written by myself. Tell me what you think! I'll edit in a link to the license in the next few minutes.

Edit: And here's a pastebin. Criticisms and suggestions are welcome.

Link

Bad idea. By using a well-established license, users know exactly what rights they have and do not have. If you create your own license, they must interpret it themselves, and they may not interpret it correctly. More importantly, you may accidentally leave loopholes that you did not intend for there to be, and thus allow certain activities. Using a different license will also turn off potential users, who may instead go with a project that has a GPL, BSD, MIT or CC license. It is much better to use something well defined and established, than roll your own.

Btw, why do you want to use a different license, and not the GPL?

I'd agree with this, unless the license is something like "use this however you want, and if you ever meet me in real life, you should consider buying me a rootbeer". The GPL and other mentioned licenses are well respected, and people know exactly what they're getting into when they're using/modifying something enacted under them.

Agreed with the other assessments (I couldn't be bothered to compose a response before). It seems like the MPL is close to what you want.

Ashbad: For what it's worth the buy-me-a-rootbeer license is sometimes referred to as the WTFPL, and BrandonW uses it frequently. Seana11: Although the Pi does indeed have GPIO, it has shockingly few of them for a board that's meant to teach hardware hacking, in my opinion.