Self hosting is the act of having your website
totally under your control. This can include you managing all whole aspects of
it, from setting up the web server to installing software, to simply managing
your weblog software like WordPress. This is usually accomplished by either
renting your own server/virtual machine or, more commonly by using shared
hosting. The later choice allows you to have low costs while giving up some
control but generally not in the areas that you are interested in.
The opposite of self-hosting is free hosting, where
you use a free service to host your site. Usually this is done either through
Blogger, WordPress.com, Livejournal or any other popular system. This means
that you have very little control over your site other than the content and you
have to follow specific TOS, which are very frequently quite limited.
Now, If you are a blogger you will sooner or later
create a strong connection to where you make your little place on the web. Your
blog becomes sort of an online home with a much more value than any shallow
social network profile. It is the place where your character or professionalism
is shown to the world at large and with time you may find that you have
invested a lot of effort and time into it.
It is for this reason that I consider that for
anyone who views blogging even as a hobby, self-hosting their own site is the
better choice. I understand however that there are a lot of misconceptions
about what self-hosting entails and you can see in the following poll result
the reasons so many people avoid it
To this end, I’ve written the following articles in
the hope to counter some of these misconceptions.
The term self-hosting was coined to refer to the use of a computer
program as part of the toolchain or operating system that produces new versions
of that same program—for example, a compiler that can compile its own source
code. Self-hosting software is commonplace on personal computers and larger
systems. Other programs that are typically self-hosting include kernels,
assemblers, command-line interpreters and revision control software.
If a system is so new that no software has
been written for it, then software is developed on another self-hosting system
and placed on a storage device that the new system can read. Development
continues this way until the new system can reliably host its own development.
Writing new software development tools "from the metal" (that is,
without using another host system) is rare and in many cases impractical.
For example, Ken Thompson started
development on Unix in 1968 by writing and compiling programs on the GE-635 and
carrying them over to the PDP-7 for testing. After the initial Unix kernel, a
command interpreter, an editor, an assembler, and a few utilities were
completed, the Unix operating system was self-hosting -- programs could be
written and tested on the PDP-7 itself.
For example, development of the Linux
kernel was initially hosted on a Minix system. When sufficient packages, like
GCC, GNU bash and other utilities are ported over, developers can work on new
versions of Linux kernel based on older versions of itself (like building
kernel 3.21 on a machine running kernel 3.18). This procedure can also be felt
when building a new linux distribution from scratch.
History
Main article: History of compiler writing
The first self-hosting compiler (excluding assemblers) was written for Lisp by Hart and Levin at MIT in 1962. They wrote a Lisp compiler in Lisp, testing it inside an existing Lisp interpreter. Once they had improved the compiler to the point where it could compile its own source code, it was self-hosting.
The compiler as it exists on the standard compiler tape is a machine language program that was obtained by having the S-expression definition of the compiler work on itself through the interpreter.
—AI Memo 39
This technique is only possible when an interpreter already exists for the very same language that is to be compiled. It borrows directly from the notion of running a program on itself as input, which is also used in various proofs in theoretical computer science, such as the proof that the halting problem is undecidable.
