Update documentation

Author: rcx

README.md

@@ -2,43 +2,79 @@
 
 ![JDA Logo](docs/icon.png)
 
-Java Disassembler (JDA) is a fork of Bytecode Viewer (BCV) that adds advanced code analysis features. The basic principles of BCV are maintained; however, many aspects are different.
+Tired of seeing this???
 
-## Motivation
-The main reason JDA was forked was that BCV was becoming too large and cumbersome, with many redundant, unused, or
-useless features. The issue with removing them is that there could be many BCV users that relied on such features.
-Because of this, it is more appropriate to fork JDA as a separate project. Additionally, BCV's development has
-stagnated, and the last official build is from July 2015. It has since grown increasingly difficult and arcane to
-compile BCV from source, and full jars often range into 20Mb in size. It has become necessary to fork BCV in order
-to make large-scale changes.
+```java
+// $FF: Couldn't be decompiled
+```
 
-In addition to the growing power and complexity of commercial obfuscation programs for Java, it has become increasingly
-necessary to develop improved reverse engineering and static analysis tools. For this reason, JDA has been developed
-in order to provide professional-quality static analysis tools for JVM-based languages.
+The Java Disassembler (JDA) is a GUI reverse engineering tool that can turn this:
 
-## Scope
-With that in mind, JDA's goal is to be a light-weight yet powerful Java static disassembler. BCV suffered from a
-multitude of issues, but a large one was that it tried to be a dynamic reverse engineering tool (debugger) as well
-as a static tool (disassembler) at the same time, only succeeding partially in the latter. JDA's role is to provide
-a platform and interface for the core features such as analysis and disassembly. Additionally, many useless
-or irrelevant features have been removed. JDA's scope as a program currently is to be a platform for reverse engineering
-tools to be built on top of.
+```java
+// $FF: Couldn't be decompiled
+// java.lang.IllegalArgumentException: Invalid type: @
+//     at org.jetbrains.java.decompiler.struct.gen.VarType.getType(VarType.java:405)
+//     at org.jetbrains.java.decompiler.struct.gen.VarType.<init>(VarType.java:90)
+//     at org.jetbrains.java.decompiler.struct.gen.VarType.<init>(VarType.java:62)
+// ...
+```
 
-In the future, JDA will have powerful static analysis tools, such as control and data flow analysis, code contraction
-(copy and constant propagation), whole binary cross referencing (xrefs), and an IR engine. However, these standard
-core utilities will be distributed separately as the [MapleIR](https://github.com/LLVM-but-worse/maple-ir) plugin.
+into this:
 
-![MapleIR demo](docs/demo.png)
+```java
+public void keyPressed(KeyEvent var1) {
+    super.keyPressed(var1);
+    int var10000 = var1.getKeyCode();
+    int var10001 = (3 << 2 & 9 | 5 | 7) ^ 5;
+    int var10003 = 0 ^ 1165448477 ^ 958591453 ^ 2085987521;
+    if (var10000 == var10001) {
+        11.iiIIiiiiIiIIi(this.IIiiIiiiIIiiI, this.IiIIiiiiiiiiI, this.IIiiiiiiIIiIi);
+    }
+}
+```
+
+and finally this:
+
+```java
+public void keyPressed(KeyEvent var1) {
+    super.keyPressed(var1);
+    if (var1.getKeyCode() == 10) {
+        11.iiIIiiiiIiIIi(this.IIiiIiiiIIiiI, this.IiIIiiiiiiiiI, this.IIiiiiiiIIiIi);
+    }
+}
+```
 
 ## Features
- - Ergonomic design for low-level bytecode reversing
+JDA offers powerful static analysis tools, such as control and data flow analysis, and code simplification
+built using a custom IL. Moreover, many tasks expected of a disassembler such as constant and string searching are available.
+These standard core utilities are with the [MapleIR](https://github.com/LLVM-but-worse/maple-ir) plugin. You
+can also access the IL API and integrate into the UI by writing your own plugins in Java.
+In the near future it will support whole binary cross referencing (xrefs) and more.
+
+ - Ergonomic design for high-level browsing or low-level bytecode reversing
  - [Data-flow analysis with copy and constant propagation](docs/propagation-analysis.png) (provided by MapleIR)
  - Support for a variety of decompilers
- - Cross-reference bytecode, decompilation, and IR.
+ - Side-by-side view of decompilation, bytecode, and IL.
+
+![MapleIR demo](docs/demo.png)
+
+## Motivation
+Due to the growing power and complexity of commercial obfuscation programs for Java, it has become
+necessary to develop improved reverse engineering and static analysis tools. JDA was developed to
+provide professional-quality static analysis tools for JVM-based languages.
+
+JDA began as a fork of Bytecode Viewer (BCV). BCV suffered heavily from bloat, poor performance, and
+stagnant development. In JDA many useless or irrelevant features have been removed, and significant parts
+of the codebase have been cleaned up or rewritten entirely.
+
+## Scope
+With that in mind, JDA's goal is to be a focused, light-weight yet powerful Java static disassembler.
+JDA's role is to provide a platform and interface for the core features such as analysis and disassembly.
+Therefore, JDA's scope is to be a platform for Java reverse engineering tools to be built on top of.
 
 More to come in the future.
 
-## Maple-IR Plugin
+## MapleIR Plugin
 
 To install the plugin put the plugin jar in `~/.jda/plugins` (or equivalently, `%USERPROFILE%\.jda\plugins` on Windows), then restart.