Update README.md

README.md

@@ -1,14 +1,18 @@
 # Theory Lisp
 
-Theory Lisp is a simple language for simulating theoretical models of computation. Its syntax and functionality are similar to Lisp, but it is not truely a Lisp dialect. 
+Theory Lisp is a programming language for simulating theoretical models of computation. Its syntax is similar to Scheme, but it has additional expressions specifically designed for describing automatons.
 
-The language is dynamically typed, dynamically scoped, and fully interpreted. Code can be represented as data, and it is possible to dynamically generate and execute code at runtime. The interpeter uses a recursive descent parser. Arbitrary user-defined expressions (even expressions that does not have list form) can be used by extending the parser with macros. Both imperative macros and pattern matching macros are available.
+The language is dynamically typed, dynamically scoped, and interpreted. Code can be represented as data, and it is possible to dynamically generate and execute code at runtime. The interpeter uses a recursive descent parser. Arbitrary user-defined expressions (even expressions that does not have list form) can be used by extending the parser with macros. Both imperative macros and pattern matching macros are available. The language has built-in functions for string and list manipulation, math, and standard I/O. Exception handling is supported, but in a naive way.
 
-In addition to functional and imperative Lisp forms, Theory Lisp provides special syntax for designing automatons. The syntax can be used for designing finite state machines, single-tape or multi-tape Turing machines and (very simple) Markov chains. Composite machines can be constructed from simpler machines by using the smaller machines as base machines. The goal of the language is to be a self-contained educational tool for simulating automatons. The further development will be on adding different models of computation.
+In addition to commonly used functional and imperative Lisp forms, Theory Lisp provides special syntax for designing automatons. The syntax can be used for designing finite state machines, single-tape or multi-tape Turing machines and Markov chains. Composite machines can be constructed from simpler machines by using the smaller machines as base machines. The goal of the language is to be a self-contained  tool for simulating automatons. The further development will be on adding different models of computation.
+
+## Documentation
+
+The documentation for built-in types, expressions, macros and functions is available at [kocatepedogu.github.io/theory-lisp](https://kocatepedogu.github.io/theory-lisp/index.html). 
 
 ## Dependencies
 
-The interpreter does not require any external libraries, but Check is needed for unit tests. 
+The interpreter does not have any external dependencies, but Check is needed for unit tests and pkgconfig is used to detect it.
 
 On Debian based systems,
 
@@ -18,17 +22,17 @@ sudo apt install libcheck
 
 On BSD,
 ```console
-pkg install check
+pkg install check pkgconf
 ```
 
-On Mac OS X (only tested on very old OS X 10.5 PPC with tigerbrew), 
+On Mac OS X (only tested on very old OS X 10.5 PowerPC with tigerbrew), 
 ```console
-brew install check
+brew install check pkgconfig
 ```
 
 ## Installation 
 
-On Linux, BSD and macOS/Mac OSX following commands will compile and install Theory Lisp
+On Linux, BSD and macOS/Mac OSX following commands should compile and install Theory Lisp
 
 ```console
 autoreconf --install
@@ -38,7 +42,7 @@ make install
 make check
 ```
 
-It is recommended to use --prefix option in configure step to specify an installation directory that does not require root access.
+It is recommended to use --prefix option in configure step to specify an installation directory that does not require root access. autoreconf is not needed when building from release tarball.
 
 ## Usage