Accessing the Kernel & Can't change my screen saver without the CPU crashing

In the future, for best results, I recommend posting two (or more) separate questions when you have two (or more) unrelated problems. I've attempted to answer both your questions in this one post, but if you find that you need further assistance with both, then I recommend starting a new question for one or the other of them. (If you need further assistance with just one, that can easily be accommodated here, and if you don't need any further assistance, then of course that can also be "accommodated.") If you post a new question, you can post a link to it here, and then I'll be sure to see it.

You can disable the screensaver without entering the screensaver settings. See post #10 at https://answers.launchpad.net/ubuntu/+source/gnome-screensaver/+question/143742. If you want to try to work further on the crash itself (for example, to fix the problem, or to report it as a bug), please post again. There might be some computers on which screensavers (besides the blank screen screensaver) don't work, but they should still not *crash* on any computer.

"Is there any way I can access the Ubuntu kernel...."

Linux is indeed the name of the kernel in Linux-based OSes including Red Hat's operating systems (Red Hat Enterprise Linux and Fedora) and Ubuntu. But a kernel is *not* a programming language. See http://en.wikipedia.org/wiki/Kernel_(computing) and http://en.wikipedia.org/wiki/Linux_kernel. Every time you interact with your computer or open or save a file or access the Internet or some other network, you are "accessing" your kernel, in that the kernel is responsible for the operation of all your computer's devices, including your keyboard, your pointing device (e.g., mouse), your screen, and your storage devices such as hard drives, and the kernel is responsible for implementing the lowest level of networking, enabling your computer to communicate with other computers and networked devices. The kernel is also responsible for defining what memory and CPU resources programs get, and for performing a number of other low-level functions.

The kernel provides an interface for programs to interact with it (system calls, see http://en.wikipedia.org/wiki/System_call). Almost any program will use system calls (or will perform actions that result in the invocation of system calls). But it would be a category error to ask why a human cannot interact with the kernel directly--in fact, everything a human does with a computer is interaction with the kernel. If this paragraph makes absolutely perfect sense to you, then you probably have a solid, basic understanding of what a kernel is. If it does not (after you have read the three articles linked-to above), I'd encourage you to reply with specific questions about whatever doesn't (or doesn't quite) make sense.

"Is like the Assembler language that built C, Fortrans, and Pascal programming languages?"

Besides what I said above about how a kernel is not a programming language, I cannot really answer this question, as it appears that the question itself may be based on an incorrect assumption. Alternatively, I may simply be misunderstanding the question.

C, Fortran, and Pascal are all traditionally compiled languages, which means that they are written in a technical but human-readable language not generally requiring detailed knowledge of the hardware on which the program will run; as a consequence, a program written in such a language must first be converted to the machine language for whatever machine it is to be run on, in order to be run. Such a program is traditionally, and often, converted to that machine's assembly language first, and then from assembly language to machine language. To "compile" a program can mean to convert it to assembly language (the original meaning of the term and arguably the only correct meaning), or to convert it directly to machine language. A program that is compiled to assembly language must then be *assembled* to become machine language. Arguably, a program that converts non-assembly source code directly to machine language, skipping assembly language, is a hybrid compiler-assembler, rather than a compiler.

C, Fortran, and Pascal are not "built [by]" assembly language. Languages do not build things, they're just ways of imperatively (or sometimes declaratively) expressing what a program is supposed to do. To build a program is to perform all the actions necessary to transform it from its original, human-readable state into its final, runnable state. What steps are involved depends on what language or languages the program is written in and also on various other factors that vary from program to program, but in C, C++, Objective C (and Objective C++), and some other languages, building a program consists of preprocessing (http://en.wikipedia.org/wiki/Preprocessing), compilation (as defined above; also see http://en.wikipedia.org/wiki/Compiler, and note that compilation itself can be subdivided into multiple, separate steps), assembly (http://en.wikipedia.org/wiki/Assembly_language), and linking (http://en.wikipedia.org/wiki/Linker_(computing)). The term "compile" is sometimes used as a synonym for "build", and this informal use is facilitated by how, in many cases, all build steps are performed automatically and in the correct sequence by a single invocation of the compiler. But using "compile" to mean "build" is not technically correct.

Source code written in some programming language (or languages) can *be* built (into runnable programs), but languages themselves are not built (in this sense), and it is not the language that performs the actions that constitute building (also called "build steps"). A language's *implementation* is what performs (at least some) build steps. For example, a compiled language's implementation consists of at least a compiler for that language, and perhaps other tools as well. A compiler (and other tools) are also themselves built--they are written in some language and turned into runnable programs (the function of which is to perform steps in the process of turning source code into runnable programs). Thus, a language's implementation, rather than the language itself, can build and be built.

But most programming language implementations, including implementations of C, Fortran, and Pascal, are not written in assembly language. They, too, are typically written in compiled languages. (Similarly, most implementations for interpreted languages, i.e., interpreters, are written in compiled languages and not assembly language. Occasionally, interpreters are themselves interpreted rather than compiled.) Like with many computationally intensive applications, small parts of compilers are sometimes written in assembly language, for performance reasons, but it is extremely rare for a modern compiler to be written all, or even mostly, in assembly language. For example, the GNU Compiler Collection, which includes compilers for C and various C like-languages, and also for Fortran, is itself written in C. At first, implementing language X (by which I mean, any language) in language X itself may sound strange, but actually it sometimes works quite well. If there is a pre-existing X implementation, that can be used to build the new X implementation for the first time. If the pre-existing X implementation only exists for another platform, then the first native X implementation can be cross-built (see http://en.wikipedia.org/wiki/Cross_compilation). If there are no implementations at all for language X yet, then the first implementation will have to be written in some language besides X, but it wouldn't have to be written in assembly language. See also http://en.wikipedia.org/wiki/Bootstrapping_(compilers) and http://en.wikipedia.org/wiki/Self-hosting.

In case you're wondering, Linux (which I again emphasize is a kernel, and not a programming language, and also not a programming language implementation) is written in C, with small parts written in assembly language, typically so as to better perform very low level operations, rather than to optimize performance.

Correction: I had said

> C, Fortran, and Pascal are all traditionally compiled languages, which
> means that they are written in a technical but human-readable language
> not generally requiring detailed knowledge of the hardware on which the
> program will run

I meant:

> C, Fortran, and Pascal are all traditionally compiled languages, which
> means that they are technical but human-readable languages
> not generally requiring detailed knowledge of the hardware on which the
> program will run