2 files changed, 47 insertions, 9 deletions
diff --git a/html/gen.sh b/html/gen.sh
index df78d25..445704f 100755
--- a/html/gen.sh
+++ b/html/gen.sh
@@ -2,6 +2,12 @@
 
 set -euo pipefail
 
+if [ "$(pwd)" != "$HOME/src/zisp/html" ]
+then
+    echo >&2 "Call this from within the Zisp HTML directory."
+    exit 1
+fi
+
 md2ht() {
     src=$1
     dst=$2
@@ -28,3 +34,5 @@ do
     name=${name%.md}
     md2ht "$note" "notes/$name.html"
 done
+
+rsync -a ./ tk:/var/www/html/zisp
diff --git a/html/index.md b/html/index.md
index 8f2cd97..b7209e3 100644
--- a/html/index.md
+++ b/html/index.md
@@ -1,20 +1,50 @@
-# Zisp: 21st-century Scheme-inspired language
+# Zisp: A full-stack Lisp for the 21st Century
 
-Zisp is my experimental toy language inspired by Scheme.  The idea is
-that it's a modern "re-imagining" of what Scheme may have been had it
-been invented today, and had it been designed with pragmatic use as a
-primary concern in its design.
+Zisp is my experimental language project that first started with the
+idea of writing a simple Scheme implementation in Zig, just to learn
+Zig and how to implement Scheme from scratch.
+
+It then morphed into the idea of re-imagining Scheme, breaking off
+from the standards to modernize it and clean up the small amounts of
+cruft it has (yes, even Scheme has warts) especially where efficiency
+and pragmatic use for "real-world" programming are concerned.
+
+Next, I felt a surge of ambition and decided to aim for something
+rather outlandish, considering that this is still just a toy project:
+
+I want Zisp to become a "full-stack programming language" that allows
+you to both write high-level script-style code in a "don't care style"
+(as if it's a throwaway JavaScript, Python, or even Bash script) while
+at the same time allowing a seamless transition into a stricter style,
+with static typing, explicit data layouts, manual memory management,
+and so on, to create optimal binaries that you could otherwise only
+achieve with a lower-level language like C, Zig, or Rust.
+
+Coming from high-level languages, you could think of this like adding
+features to a language like Python or JavaScript that allow its users
+to take total control over run-time behaviors like memory management
+and object representation, which are normally handled implicitly.
+
+Coming from lower-level languages, you could think of it as adding a
+large amount of convenience APIs, and ergonomic syntax features, to
+languages like C or Zig, to allow users to omit all the hoops they
+would normally have to go through to achieve things that are rather
+simple to do in higher level languages, at the cost of not having
+optimal run-time behavior due to missing details.
 
 This language doesn't actually exist yet.  You are merely reading the
 ramblings of a madman.  A little bit of code is here already though:
 
 [Source code](https://git.tkammer.de/zisp/)
 
-Some of the following articles are quite insightful.  Others are VERY
-rambly; you've been warned.
+The design process of Zisp happens in large part through little notes
+and moderate length blog-style articles that I write down to clarify
+my own thoughts.  These are listed below in chronological order.
 
-Some are outdated with regards to the actual implementation of Zisp,
-because writing the code often gives you yet another perspective.
+Some of these may be quite insightful, while others are ramblings.
+Some are outdated with regards to code that I've since written to
+actually implement the ideas, since writing code often gives you
+another perspective on how to best do things.
 
 * [Compilation is execution](notes/250210-compile.html)
 * [Everything can be serialized](notes/250210-serialize.html)