Cixelyn

If anyone is interested in learning more specifically about the Battlecode competition, I wrote a blog post giving a brief overview of the competition a few years ago: http://cory.li/battlecode-intro/

Also, we open sourced our winning 2012 bot on bitbucket here if you want to see the type of code that goes into it: https://bitbucket.org/Cixelyn/bcode2012-bot

The "watch" links let you watch the actual battle simulation results in a really old viewing engine written almost 6+ years ago in Adobe Air. It was amazing at the time since you didn't have to install the full Java client just to view the matches.

The devs probably have their hands full implementing the actual game -- pretty sure no one has had time to port the codebase to something more modern. The competition organizers are primarily MIT students doing this in their spare time, so they have classwork and other things to deal with as well. :)

Oculus's docs on "Introduction to Virtual Reality Audio" may be of some use[1], specifically the section on environmental modeling[2].

The general idea is to model reverberations and reflections given the distance of a point sound source to the nearest flat surface, giving the impression of a "contained" sound.

[1]: https://developer.oculus.com/documentation/audiosdk/latest/c...

[2]: https://developer.oculus.com/documentation/audiosdk/latest/c...

The published paper is in science here: http://www.sciencemag.org/content/345/6197/668

Yup, everything's open source, setting up your own private competition is quite doable.

https://github.com/battlecode

> "If you love programming, games, and competition, it’s the most fun you’ll ever have" As both a past competitor and someone who's been following the current game, I can't stress this enough, especially if you're the kind of person who likes to think for a long time to come up with novel approaches to problems.

As a contestant -- it's quite satisfying to be a step ahead of the crowd and watch other teams copy your strategy.

As a spectator -- watching the metagame evolve is exciting.

Because the game is brand new every year, there's a fast-paced metagame that the clever contestants get to define. It really brings me back the early days of starcraft, when the unit synergies were not well defined and players were theorycrafting new build orders all the time!

Isn't the finickiness related to power consumption? USB is only rated up to 500mA, so drawing too much power from the Raspberry Pi's own USB port will cause all sorts of havoc especially when the RPi itself is powered off another computer's USB port.

In fact technically RPi model B's official spec is that it requires 700mA. You can often get away with less, but you'll definitely start to hit 500mA+ under stress and with peripherals, which is above what USB can officially supply.

Your best bet is to get a nice solid cellphone wall-wart type charger, preferably rated 2A and up. With enough juice powering the Pi, all the issues relating to USB disconnects, freezing, and ethernet dropping stop happening.

Gonna guess that the stability you're seeing with the beaglebone is just from its much lower power requirement.

Yeah navigation via A* / other traditional algorithms is almost always a no-go in Battlecode because of the way the bytecode limitation works. You almost always have to create some extremely custom pathfinding algorithm tuned to the constraints of the engine.

The simple algorithms are stuff like bugnav (walk in your desired direction until you see a wall then attempt to trace around it), but you'll find that even in something as simple as bugnav, there are a _ton_ of edgecases you have to account for in a discrete implementation that results in robots tracing around each other / stuck in infinite loops, etc.

Our 2012 bot uses a special implementation of the discrete tangentbug algorithm that allows us to precompute squares during rounds which we have extra bytecodes to spare[1]

It's probably _the_ most complex part of our codebase, and the person who wrote it doesn't even really understand how it works anymore.

[1] https://bitbucket.org/Cixelyn/bcode2012-bot/src/default/team...

For those that are interested, the new 2013 release is now live[1]. Should be a fun game this year -- enough spec changes that even seasoned Battlecode veterans will have to sit down and think quite carefully about how to write a bot.

Shared sensor data now makes higher-level strategies a ton more viable, so it'll be fun to see what contestants come up with.

There's a quick start available if you want to just clone and hack some things together in git[2] and hg[3] flavors.

[1] https://www.battlecode.org/contestants/releases/

[2] https://github.com/Cixelyn/bcode2013-scaffold

[3] https://bitbucket.org/Cixelyn/bcode2013-scaffold

any chance you could bake in functionality for WTForms instead? since a number of flask users use that as a form handling library.

The big gene synthesis companies are all a part of the international gene synthesis consortium, which has loose set of guidelines that include gene sequence screening (eg: every order is screened against a database of known pathogens, toxins, viruses, etc.).

granted this is a hard problem (similar to the difficulty of fingerprinting computer viruses). So while synthesis prices are still relatively high, simple fingerprinting will probably suffice for now. There will probably be a lot of development of more advanced machine learning algorithms to detect dangerous sequences as it becomes more and more of a threat in the future.

yup that's one of the biggest fears with respect to bioterrorism.

engineering bacteria to produce new strains or even deadlier toxins is well within realm of synthetic biology (although currently extremely nontrivial).

Falling synthesis prices and better assembly techniques however will make the repeat-test cycle fast enough to debug and engineer such organisms.

Also a newish Mac user here.

Played Starcraft/SC2 at a fairly decent level. To an RTS player the lag is extremely maddening as every mouse movement seems a bit off. (to get a good feel for exactly what's off, try to repeatedly draw diagonal strokes of the same size as fast as possible in any paint application for a good minute or two. Do it in both Windows and OSX and you'll notice something feels off about the OS you're not used to)

I tried a large number of things to get the feel right (all the old blog posts said that only acceleration was to blame), but even with mouse acceleration disabled, something felt off. Right now I only feel comfortable using my mac with mouse acceleration set to -2x for some reason.

I eventually just gave up and uninstalled SC2 from OSX. Now I only play it whenever I'm dual booted into Windows. Almost all the other mac users I know who play SC2 use this solution.

I've successfully used jCoffeeScript in my projects: https://github.com/yeungda/jcoffeescript

Best thing is that the whole jar is self-contained. Nothing is required except for java, which eliminates the headache of installing cygwin and node on windows.

  java -jar jcoffeescript-1.1.jar < foo.coffee > foo.js

For sass, the easiest way is to just install ruby on windows and then install the sass gem, which will give you access to the sass command.

Here's one way of doing it with a PCR machine:

1. First find a risk gene of interest. You can find a gene name via flipping through scientific articles about the disease, and then finding the exact sequence of the gene on NCBI (http://www.ncbi.nlm.nih.gov/projects/genome/guide/human/inde...).

2. Design primers that amplify around the region of interest. ($15 maybe tops?)

3. Toss everything into a PCR machine and amplify it up. ($3 or so for per-run reagents?)

4. Take your amplified product and send it off for sequencing (another like $10 or so?). When you get the sequence back, compare your sequence to the published sequence and see how it looks!

There are a few caveats in primer design, and there are some other ways of detecting disease markers, but this is one easy relatively low-cost approach.

Yup. Highschool / Undergraduate labs that teach PCR with two water baths and a stopwatch really kill a lot of the "magic" bestowed on these absurdly expensive machines.

I think it's also useful to note _just_ how versatile a PCR machine is in biotech. If every EE hacker needs an oscilloscope, every bioengineer hacker needs a PCR machine. PCR is good for much more than just amplification -- a huge number of variations on the basic technique have surfaced in the past few years, here are just a few:

- Need to synthesize a new gene or genetic circuit? Take a bunch of DNA fragments, design overlapping fragments which serve as the "glue", and use PCR to sew the whole thing together

- Want to know if your bacteria is the right strain? Microwave a colony and toss it into the PCR machine with some probes to check. Same thing if you want to test yourself for common disease risk factors such as the BRCA1 gene.

- Want to know the expression of protein A compared to protein B? Use Q-PCR to get quantitative data on the difference.

- Made a mistake in your latest gene synthesis order? Use PCR to change base-pairs or even edit out regions of DNA to fix the problem region. Conversely, if you want to _introduce_ mutations / randomize segments of DNA, PCR can do that too!

There are many more uses of the general technique including next-gen sequencing and DNA origami that are just too numerous to list. PCR is like the IDE of biology, containing an editor, a compiler, and a debugger all in one!

Really, my only complaint is that a PCR run takes an hour or more to run depending on the complexity.

The clue is given to Watson electronically the moment the clue appears on the screen.

While watching, I was actually hoping for really short questions which would cut down on Watson's time to process and possibly put Watson on more even footing with Jennings and Rutter.

I think it would be even better if the protocols were stored in some sort of machine parse-able format rather than just human readable text.

This solves two problems a) the big problem of reproducibility in fields like biology, and b) if it's machine-readable, you can just toss the file onto a robot and have the whole procedure done for you.

Check out Biocoder for an example of a language for describing protocols: http://research.microsoft.com/en-us/um/india/projects/biocod...

Format conversion and outputting versions for publication also follow quite easily once a strict protocol language is defined.