rndmcnlly0

"insolation" (think of incoming solar radiation) is distinct from "insulation"

The basic trance problem:

    kick if i%4 == 0
    clap if i%8 == 4
    hat if i%8 in [0,2,6,7]
    bass always, according to some function of i

Given the effort the play a game and the inter-subject noise in a numerical judgement, I think a better use of Mechanical Turk would be to ask the player to do some blame assignment. That is, instead of rating a game as 4-stars, they could perhaps give a thumbs up/down to particular rules or sets of rules in abstracted representation of the game.

This kind of feedback extracts several more bits of information from the player than a single rating (making better use of them). However, it breaks the applicability of an evolutionary algorithm which treats both artifacts and fitness evaluation as black boxes. If you use a search algorithm that was aware of how the game was built from components, I'm guessing that component-level feedback (being both more objective and more specific) could provide more informative pressure to drive the algorithm than the standard interactive genetic algorithm setup gets.

Here's my restatement of the statistical approach (correct me if I'm wrong):

Instead of proposing some metric for fun that is valid a-priori, we are going to look for the very grounded game-specific correlates of fun and optimize with respect to those. Satisfactorily capturing the entire fuzzy sense of human fun in a finite piece of code is silly, but cataloging the observed feedback for every popular combination of level elements (e.g. "goomba two blocks to the right of a coin block while the player has a fire flower") is both practical and useful for automating level design.

It's natural to question how someone can unproblematically pose a metric on the value of game rulesets (particularly without a generous helping of philosophy and psychology to back it up). However, pragmatically, it's not a silly thing to try. If there were game-design IDEs in the future, we'd like them to provide the equivalent of spell/grammar check -- if there was an alternate design with an edit distance of two away from the current design that scored dramatically better on some canned metric, it might be worth putting a human eye on that alternative design.

If you think of the error function as the combined output of a bunch of "obvious flaw" detectors instead of a "theory of fun", then speculative optimization where the initial conditions come from a human's design under consideration becomes a potentially interesting bit of design automation. Think of design rule checks in CAD with a bit of fuzziness and a default bias -- instead of saying just yes/no, it can say "X might be a better alternative according to the metrics you've enabled in the preference window, consider adopting some of its edits".

I'm in grad school for AI right now as a result of reading about Eurisko as a kid. Though I haven't followed up on the greater vision, my thesis proposal a few years ago pitched the project of building a Eurisko-style discovery system for game design: http://users.soe.ucsc.edu/~amsmith/proposal/amsmith-proposal...

Also, the fact that I had a good experience playing an "academic" class character in Traveller during college was also an influence in deciding to go to grad school. I haven't seen this class in any other RPG.

Before you jump to evolutionary algorithms, note "The Problem with Evolution" section in the OP. This was written by a guy who knows what he's doing with evolution, and it's interesting to see him turning to MCTS given his previous success with evolution.

The gist is that games are fragile with respect to mutations (motivating the need for a search paradigm not based on gradualism). This fragility may not exhibit itself as strongly for the parameter tweaking involved in the balancing problem, but balancing quickly shades into general game design when you start to consider non-trivial tweaks.

Oh, and here's a sudoku solver in 15 source lines with ASP: http://asparagus.cs.uni-potsdam.de/encoding/show/id/3540

Also, a sudoku puzzle generator directly incorporating the unique solution constraint: http://asparagus.cs.uni-potsdam.de/encoding/show/id/12739

You might enjoy answer set programming (ASP). It's a different take on logic programming based on the idea of automatically transforming your problem into a SAT-like representation and then running fancy conflict-driven constraint learning solvers on it. In many solvers, you give up Turing completeness in exchange for being really productive with solving NP-complete problems (similar to regex engines turning you into a bad-ass string matching programmer).

Here's a tutorial application of ASP to map generation: http://eis-blog.ucsc.edu/2011/10/map-generation-speedrun/

I had the core idea of this in 2006 (binary coded patterns of small magnets for position and orientation sensitivity), but... didn't follow up. Looks like they are doing some interesting stuff with it (and piling on the patents).

The original application I imagined would be very simple arrays to be used in kids' tile puzzles where you could have square-peg-in-square-hole style thinking but without hole geometry (choosing something more semantic instead). Puzzle tiles would only have strong attraction to their correct location and all other locations would be relatively neutral.

If so, then it's all the more true that now is the time to invest attention in learning how the internet works at all of its layers. When the time comes, you can be part of those who build the next internet-like thing with full knowledge of all the weaknesses of the previous one.

(seconding your claim that this is an interesting new social dynamic)

In the quasi-whimsical view of Anonymous as a legitimate internet-dwelling mentality, it's these definedly group actions act actually constitute the speech (a vector of communication) for that entity. Every textual or video message signed "Anonymous" is quickly interpreted as the speech of an individual or small group of collaborating authors, relatable on human terms. The attacks, despite their sit-in level overall effectiveness, are inherently aggregate, as opposed to that-13-year-old or that-15-year-old-and-his-botnet.

On a meta-note: I deeply enjoy that linking to Wikipedia articles is part of HN culture. If that which is timely cannot be timeless, then it is of supreme importance that what is News to us, individually, consists of more than what is New at the time of posting.

Has anyone considered generalizing these to voxels -- adding details to minecraft style spaces?

"Deliberate practice" is, in fact, what Gladwell is saying the 10,000 hours should measure.

It's not that Prolog necessarily backtracks to find the final solution. It's the forward computation that actually builds the solution, backtracking only when one can't be found with assumptions made so far.

Sloppy programming can lead to lots of unnecessary backtracking, of course, but some of the main benefits of Prolog come in using it for problems where you would have otherwise written your own ad-hoc backtracking search process to find a solution. That is, good Prolog code only likely to be slow because of it's backtracking when an imperative solution would have been slower/buggier.

Runtime slowness because Prolog is a dynamically-typed language that also strongly encourages the development of meta-intepreters as a common tactic is a separate issue. Often times a slower run time is acceptable in exchange for a much faster development time with the use of custom metalanguages (DSLs).

Integrated search aside, another benefit of logic programming comes in declarative knowledge representation. In an expression optimizer I wrote, it was easy to concisely define several code substitution patterns as simple logical statements and then create the overall optimizer as an interpreter over those declared patterns.

For problems that don't really revolve around search or knowledge representation (i.e. most CRUD web stuff), Prolog doesn't provide practical benefits. Nonetheless, understanding the otherwise foreign concepts of the language can give you the seeds of new design patterns and idioms for your familiar languages.

None of these reasons is a Technical Explanation.

Thanks for doing some extraction!

Using your file I've been building up a solver for these questions in Prolog (using DCGs for parsing and simple predicates for the common sense facts and answer calculation). It's nowhere near "done", but it does get 45% of the questions now after only a few hours and 450 lines of code.

The trick to factoring someone else's generative space is to spot the symmetries and build your self a little domain-specific language for explaining those symmetries to your program.

Here's some snippets:

    tomorrow(wednesday,thursday).

    food(butter).

    body_part(arm).
    plenty(arm).
    above_waist(arm).

    ordinal(2) --> lit('2nd').

    question( tomorrow -> Answer) -->
        p(['Tomorrow is ',token(Tomorrow),'. If this is true, what is today?']),
        { tomorrow(Answer,Tomorrow) }.

    question(count_2(P) -> Answer) -->
        p(['The list ',token_list(L),' contains how many ',pred(P),'?']).
        {include(P,L,Goods), length(Goods,Answer)}.

    pred_name('something each person has more than one of',plenty).

Even if you don't find a way to use anything out of the functional-logical space, reading about languages like this can change the way you program when you are in a functional-only or logical-only language.

Here's a little oversimplification that I've found useful for understanding this stuff.

    * Mercury is the Haskell of Prolog
    * Curry is the Prolog of Haskell

It's interesting to see a lot of the ideas in Mercury addressed from the opposite direction Curry. See for yourself: http://www-ps.informatik.uni-kiel.de/currywiki/

LBO = "leveraged buyout" http://en.wikipedia.org/wiki/Leveraged_buyout

For reference, a 2000 Calorie per day diet translates to about 100 Watts.

Update: I gave them a high-level overview of the conceptual exploit and even sketched a high-level technical solution for the problem (one that I admitted probably only pushes the difficulty up a few more notches, expected with DRM). I guess I'll play the next move by ear.

I hadn't considered the effect on my reputation at all.

So, forward simulating (and embedding my sentiments as a measure of my ease of sleeping):

Case {they implement it any nobody learns of the exploit}: I'm remembered as the one who stood up to help reduce friction to new apps being listed. They keep me as a positive point of contact for future design changes. I feel good about baleeting bad software design. Reputation improves, presumably.

Case {I don't tell them about it, they implement it, and somebody turns the conceptual exploit into a real tool after deployment}: The company company loses, consumers win (yarr). The company (and every company they swap stories with) decides never to deal with me, if they decide to pin it on me as intentional. I feel good about baleeting bad software design as well as demonstrating the counterproductiveness of DRM (albeit in a contrived way). Reputation declines, conditionally.

Case {I do tell them, they continue anyway in the name of reduced friction}: They take a calculated risk and own the result. Yay for improved design, but hard to forward simulate any more. Reputation unchanged-ish, regardless of whether the concept is exploited or not.

Case {I do tell them, and they decide to quit the project and keep their old solution}: They feel less receptive to future requests in the name of reduced integration friction ("ya know, it might have a flaw!"). I don't list my apps with them, and I hope that others don't either. Reputation unchanged. The concept of third-party-android-marketplace's reputation (and indirectly Android's)? Decreased relative to potential.

By this, non-exhaustive, in-the-reply-box analysis. It sounds like I should tell them, but somehow do it in a way that doesn't talk them out of it. Best option so far, but somewhat hard to enact.

Btw, I'm not a professional software consultant.

Heh, nope. I thought asking for money would only complicate their adoption of my idea for cleaning up the DRM integration process. I'm just trying to save the world from some terrible software here, remember (and trying not to create a bigger mess in the process).

Nope, and it's not Amazon either.

The theme with these MIT announcements seems to be HCA: Hope, Certainty, and Assuredness by analogy to FUD and with similar use of misrepresentation, simplification, and appeal to authority.

While the generation engine is written in python (source linked in another comment), the engine itself doesn't make use of existing regex libraries because they solve a different problem (deterministic matching vs nondeterministic generation).

It look like rubular just shows you example matches out of text you've already typed in (the same situation you have when playing with any regex matching library directly), whereas regexio generates matches you might not expect out of the blue. Can you clarify what sense of similarity you mean to point out?

Here is the source to the python meat of this project: http://pastie.org/1180230

The general idea is that it is a command line tool that reads a regex as input (along with a number of examples to generate). It parses the regex into an abstract syntax tree, then hands it over to an interpreter to "execute" the expression/program several times.

The 'simpleparse' python library does a nice job of easing the regex-to-tree mapping.

Heh, its a matter of implementing a declarative model of each of the different regex engines you'd like to select. If would be fantastic if it existed, wanna try?