diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..567609b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+build/
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..bfba9a6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,81 @@
+StringWriter
+============
+
+I have written this class to solve a problem with old c-style c++ code like this:
+```
+void g(char *s) {
+  if (!strncmp(s,"texta\n",6))
+    s+=6;
+  if ( *s == 0 )
+    return;
+  char *xs=strstr(s,"\n\n");
+  if (!xs)
+    return;
+  char xxs=*xs;
+  *xs=0;
+  char ccs[1000];
+  strcpy(ccs,s);
+  *xs=xxs;
+  s=xs+2;
+  xs=strstr(s,"\n\n");
+  if (!xs)
+    return;
+  s=xs+2;
+  while (y<YMax && !end) {
+    char *sb=s,*se=s;
+    while (*se && *se!='\n' && *se!='\f')
+      se++;
+    if (*se=='\f' || !(*se))
+      end=-1;
+    int i=se-sb;
+    if (i) {
+      char xs=s[i];
+      s[i]=0;
+  ... // continues this way
+}
+```
+What does this code? I have now clue. But I have to reduce the use of `char*` and replace
+it by `std::string`. The first and best idea is of course to find out, how this code works and 
+clean it up. But you know, in a commercial environment nobody pays for this and if this code is not 
+mission critical and runs since ages... why care? 
+So the basic idea is to refactor such code in two simple steps:
+1. replace most occurences of `char *` with auto
+2. replace the basic `char *` (in the above case it is the function param s) with the StringWriter
+The StringWriter behaves like a `char *` (with some additional features like range checks), in 
+addition I have written replacements for functions like strstr to work on StringWriter. 
+
+Lets look at a simpler example (or just check the teststringwriter.cpp):
+```
+void g(char *s) 
+{
+  char *sc = s+3;
+  *sc = 'a';
+  while (char *scc = strstr(sc, "b"))
+    *scc = 'c';
+}
+```
+Now we take step 1:
+```
+void g(char *s) 
+{
+  auto sc = s+3;
+  *sc = 'a';
+  while (auto scc = strstr(sc, "b"))
+    *scc = 'c';
+}
+```
+That was easy and changed nothing, now step 2:
+```
+void g(string& str) 
+{
+  StringWriter s{str};
+  auto *sc = s+3;
+  *sc = 'a';
+  while (auto *scc = strstr(sc, "b"))
+    *scc = 'c';
+}
+```
+Now ```g()``` takes a std::string and works as before. Except the range checking in StringWriter of course. 
+For the given examples it may look like overkill. But I have got cases where I cannot wrap the call of g()
+into a string version, because the additional copy was too expensive. So I first transformed it this way and 
+later started the real refactoring.