In case you missed it...

[marc weber]

I finally got this code to work!

boolean for >>= 6 38 byte private 86 //end main method for native if final 34 else final 42 }
{instanceof ++ new else else //end while ~ 34 switch short double catch Integer float 
{29 20 <E> int *= System |= transient ++ super & " static Integer ++ if 97 >> long static private / double transient 36 }
{instanceof 95 this int == interface new }
{return 31 }
{>= int >= extends long void new void protected ^= 
{this case if public new volatile /* void return 88 try | ^ || %= throws protected <T> package String 
implements }
String String throw catch volatile this 76 enum byte 
this * 48 <E> ^=   enum 
{>>= private class transient == public System }
{else for native new extends byte + 27 synchronized - if char && volatile 28 <T> ^ static strictfp }
{enum if for " && }
{%= goto short }
&& 
class float long /* protected }
{interface || protected return & 42 public 98 volatile char double do 83 while 19 }
{45 finally >>> " 
{; 
volatile 75 36 switch new , long } }
* ,  enum for 70 17 throws ^= transient 78 throws 48 0 50 4 
if import / << new assert + default }
[x] char }
{throws finally 13 package import String 69 static 14 throw 12 42 class finally 60 % new synchronized new finally ++ break && 60 static import *= <<= System <<= }
{new && 85 private while static = }
{
{//end if }
3 3 + 82 *= return }
,  */ catch 10 ^ catch void   throws while 16 20 ,  
- ~ ^= try ^ 
{implements class ,  else ,  volatile float 88 public super //end main method int 
}
instanceof abstract ^ += volatile assert / 
implements = byte char throw 7 36 25 }
extends interface goto 

>= += strictfp &= == while () }
{extends native ^ switch &= protected instanceof switch 15 }
{short try 38 int % throw package 44 return case ,  strictfp byte 6 
{
{5 &= implements 60 void : *= }
import class }
catch static >= 65 strictfp 
& }
for transient { const ,  public 99 package & new void if catch assert static char assert }
 
{switch 75 
{[x] protected //end while 

+ 0 do strictfp long const Integer do ,  break try ,  66 goto interface | 5 super package }
{byte final ,  float 
>> + }
{protected " 76 : 3 14 goto + //end main method new || }
{= long 82 if }
try throws 42 super super extends float 17 + 7 class finally native }
<<= >= while 31 == import /= void extends * 32 goto 
{void int }
{-- while }
{*/ 56 goto } == double ,  this ,  extends static 57 try char switch super -= interface byte ^ assert + 94 instanceof 
>> 94 }
{implements protected 4 throw implements long strictfp synchronized |= / native 52 16 break return 66 transient Integer %= case ' finally implements }
{private { 53 }
{enum abstract if [x] synchronized 
>> goto 56 try int 
public synchronized >= * else >> println }
{implements switch || }
//end if { instanceof default transient const /* class instanceof throw 81 / 83 do 
double class synchronized native / this >>>= for 78 <= 
{static int catch Integer boolean 81 }
51 97 ~ protected switch catch super 
<< goto   try void <E> >>>= ' long ^ return 24 }
{synchronized break short = assert && throws while const 37 }
61 
{void goto implements 18 long continue default extends finally extends 23 goto }
}
{char & [y] break ^= import boolean &= }
{extends enum }
{|| ^ | default transient native }
{32 * - goto class private synchronized 11 assert   System switch public 
{
{
 
break 63 [y] public assert for break 11 46 package + + break byte ; - ^= native assert 54 boolean goto }
protected /= 90 }
= this enum transient package do for () continue }
{switch boolean %= goto 29 &= else [x] && 9 %= 
{%= if else 
Integer private >>= char const goto << throws assert goto class catch class super finally " [y] Integer while / super volatile Integer -= 56 long >>>= 17 final ' case float double 
{// }
{short long 9 short else () protected synchronized try - catch 
{
+= 57 ,  <T> | if transient >> 
}
16 float do /* String implements new " 46 Integer byte 55 while implements native throws do 80 >= 
{67 try - 16 //end main method implements ,  }
{22 return else continue * 
{char 21 long static volatile = |= const >> goto final % import >>= instanceof while 76 static 85 97 66 throws 70 const abstract import *= abstract protected 
21 
{
{case , [y] , }
native strictfp }
{46 49 << 39 enum 38 interface //end main method new return throw 50 }
31 7 import [y] switch import final instanceof 37 strictfp implements int }
 
byte 2 abstract 20 package goto 31 new 92 - else 
{
{volatile this interface goto assert 34 ,  package -= case goto continue <T> throws 
{catch >>= super switch import int }
{long }
{double && volatile }
}
}
throws protected while break [x] abstract public <= }
; ++ String return catch 
{
const extends float 
{79 ^ <E> ^ ,  13 
{byte case   package implements assert 33 while super abstract }
{}
{return }
* long 
{goto boolean interface for += if new Integer long 14 
boolean 48 package throw catch }
++ float 37 default << public 55 33 - 92 ' 
79 74 78 }
89 default for this char void }
{50 
{>>= }
{43 final synchronized 94 
^= strictfp && println final final class volatile >>= native case () [x] float ,  
{try double for << 12 package 59 }
{-- int finally finally volatile static 
{finally 96 : char static protected strictfp " System abstract }
{>> ++ native switch & 33 ,  if */ 61 <T> void super //end main method assert try short 
float ; ,  -= ,  - super package byte }
protected 83 /= //end if /= }
{import continue int break //end if : class ^ [y] double ^= while void 73 68 enum enum for long return 
{65 [x] 15 
{}

long | finally instanceof [x] synchronized boolean 22 } -= //end while byte if abstract <E> <T> import int public this ++ interface package - = if }
{continue -= throw >> ' boolean private public += }
{static /* enum finally == 70 do ; }
float 67 }
protected switch private >>>= continue 
{51 61 instanceof 
{}
}
void finally int extends try 50 " */ interface static strictfp >>>= int 28 new else <= interface catch String ' synchronized throw public >>>= do final short import 29 }
final 
{}
return private 47 & 33 [y] 97 this float for == *= extends double & 
{implements }
{55 protected 7 for ,  char 94 implements 70 implements final catch static double }
| >>>= short 67 float static 40 Integer 22 38 36 &= }
{while }
{&& 22 |= finally << instanceof ~ default 
{/* 85 void final 50 catch /= ,  }
{%= }
21 throws transient package synchronized }

{super 8 }
catch 
 
transient int for for 20 [y] 
class 10 }
{}
catch continue break double //end main method }
package 
65 case instanceof continue continue System ,  public native ,  = & 92 -= 90 while *= super goto -= byte ,  int 74 80 long interface ,  static 92 instanceof while this short << short this volatile for if && 16 boolean try float 71 throws do byte &= synchronized long catch 
 
abstract Integer << 22 25 
43 throw default super 
{}
{implements super += + >>>= }
[y] 
}
{throw 
{assert strictfp extends synchronized }
synchronized }
{class if + double 28 volatile case { extends throw abstract finally ,  }
synchronized break throw //end while double new catch default 67 char 1 continue final >>= 
{//end main method 
}
{return strictfp 
+= //end while abstract strictfp 
assert || protected / & [x] /* void interface strictfp >>> 42 long : }
{90 do }
break 92 ; void 
{switch }
{for >> instanceof 13 // 15 81 switch 9 super , char int class abstract 
{41 48 enum package class byte strictfp && for byte <<= }
15 ,  boolean }
{*/ char 
{this this 51 // assert }
extends 69 
switch import 
switch short && | System switch [x] char }
{volatile class 
{synchronized protected == const += catch <T> super boolean break throws assert else super 
37 & 24 do default 
{import //end main method enum >= byte static }
47 for continue }
synchronized *= >= ^ ,  35 [y] { ,  new 
{%= if 22 abstract >>> transient 
{try 
{+ transient -- package >= void throw 29 abstract private ,  double const 
{continue }
{*/ 12 [y] const throw final |= *= 78 { byte package private instanceof protected const <T> private implements 
85 <E> implements -- finally }
class * */ volatile 50 extends import catch }
enum 
{}
{25 //end main method = println super default char ^= if Integer long |= >>> 9 }
%= if = println //end main method << synchronized this 33 byte () 
{goto extends }
println 
{|| 8 //end main method double 
{>> >= ,  
{public short & 7 28 import synchronized 
double extends println import char import , interface //end while synchronized 91 -- : - implements println int += do try 1 throws ' else long volatile >= 
|| % new // = /* implements goto }
{public }
case : 94 >>= <<= const do 52 extends while abstract protected switch *= ' ^= interface <<= byte 13 
{}
else for 72 goto }
{17 && native super ; instanceof continue break ' 41 throw 
{
{; 40 ,  package 82 ' new ' 97 boolean throw instanceof [x] void synchronized assert byte 94 } private catch /* final return abstract switch ~ throws finally 
{; throws class == -= void implements >>= }
{short goto double byte /* strictfp do 
{
45 default += + instanceof if <T> System byte float case }
if strictfp byte const try }
{case 
{<< *= boolean 
{25 else * do if public Integer for for float float }
>= } { return extends throw 
{}
transient final goto ; public 36 
{volatile 
{this <E> 57 switch extends instanceof long 
{>>= */ short >= float - import ; ,  }
{>>= [y] static volatile , [x] this int 
{++ throws }
[x] for //end while }
public 
{package / 13 
38 private implements 
{case >>= ^ long 94 switch super }
native float // ~ float 57 extends } while 91 private static 
& " String class }
{
<E> 
{do if / assert ++ catch void else 25 volatile new ,  instanceof 83 57 * <T> }
{synchronized 
{%= double float short */ else 53 }
{private short strictfp byte finally 71 / implements 8 this default if extends return }
super transient char ++ 

[Gabriel Claramunt]

Congratulations!

... I miss the urgent questions forum... it was the best!

[Ernest Friedman-Hill]

I saw this and I wondered how fancy you were in implementing the generator. It looks like just random tokens, though. Hidden Markov chains of even length 2 would produce something that looked a lot more code-like. I wonder how long the chains would need to be before you usually get something that compiles?

Anybody ever played with this? HMC of English, I've played with. Code, not so much.

[marc weber]

Originally posted by Ernest Friedman-Hill:
I saw this and I wondered how fancy you were in implementing the generator. It looks like just random tokens, though...

Generator? I spent weeks writing this by hand in Notepad!

I nested some 50/50 "if" statements to vary the mix of keywords, new lines, numbers, tabs, etc. But it's very haphazard.

import java.util.Random;
 
public class CodeOMatic {
  String[] keywords = { "abstract", "continue", "for", "new", "switch",
      "assert", "default", "if", "package", "synchronized", "boolean", "do",
      "goto", "private", "this", "break", "double", "implements", "protected",
      "throw", "byte", "else", "import", "public", "throws", "case", "enum",
      "instanceof", "return", "transient", "catch", "extends", "int", "short",
      "try", "char", "final", "interface", "static", "void", "class",
      "finally", "long", "strictfp", "volatile", "const", "float", "native",
      "super", "while" };
 
  String[] stuff = { "/", "&", "|", "^", "%", "<<", ">>", ">>>", "+=", ", ",
      "-=", "*=", "/=", "&=", "|=", "^=", "%=", "<<=", ">>=", ">>>=", ", ",
      "+", "++", "-", "--", "*", "||", "&&", "()", "[x]", "[y]", "{", ", ",
      "}", "<T>", "//", "/*", "*/", "=", "==", "~", " ", ":", "<=", ", ", ">=",
      ";", "\"", "'", "String", "System", "println", "Integer",
      "//end main method", "//end if", "//end while", ",", "<E>" };
 
  String randomKeyword() {
    return keywords[(int) (Math.random() * keywords.length)];
  }
 
  String randomOperator() {
    return stuff[(int) (Math.random() * stuff.length)];
  }
 
  void generateCode() {
    Random rand = new Random();
    for (int x = 0; x < 2000; x++) {
      if (rand.nextBoolean()) {
        System.out.print(randomKeyword() + " ");
      } else {
        if (rand.nextBoolean()) {
          System.out.print(randomOperator() + " ");
        } else {
          if (rand.nextBoolean()) {
            System.out.print((int) (Math.random() * 100) + " ");
          } else {
            if (rand.nextBoolean()) {
              System.out.print("}");
            }
            System.out.print("\n");
            if (rand.nextBoolean()) {
              System.out.print("\t");
            }
            if (rand.nextBoolean()) {
              System.out.print("\t{");
            }
          }
        }
      }
    }
  }
 
  public static void main(String[] args) {
    CodeOMatic c = new CodeOMatic();
    c.generateCode();
  }
}