Chapters review (#45)

Hyper Mega merge! BOOM!

Author: dreamos82

.gitignore

@@ -1 +1,2 @@
 .*.sw*
+.*.kate-swp

.pandoc/decorators/part_architecture.tex

@@ -1 +1 @@
-\part{Architecture And Basic Driers}
+\part{Architecture And Basic Drivers}

00_Introduction/01_README.md

@@ -6,24 +6,25 @@ We hope you enjoy, and find something interesting here!
 
 ## Structure Of The Book
 
-Each numbered chapter adds a new layer to the kernel, expanding it's capabilities. While it's not strictly necessary to read them in order, it is encouraged as some later chapters may reference earlier ones. 
+The book is divided in parts and every part is composed by one or more capter. Each numbered chapter adds a new layer to the kernel, expanding it's capabilities. While it's not strictly necessary to read them in order, it is encouraged as some later chapters may reference earlier ones.
 
-There are also a pair of special chapters at the end of the book: one containing a series of unrelated but useful topics (appendices), and one containing descriptions of various hardware devices you might want to support. 
-
-The appendices chapter is intended to be used a reference, and can be read at any time. The drivers chapter can also be read at any time, but implementing support for these devices should come after the memory management chapter (when a VMM has been implemented).
+There is also a series of appendices at the end of the book, covering some extra topics that may be useful along the way. The appendices are intended to be used a reference, and can be read at any time. 
 
 ### Topics covered
 
-As we've already mentioned, our main purpose here is the guide the reader through the general process of building a kernel (and surrounding operating system). We're using `x86_64` as our reference architecture, but most of the concepts should transfer to other architectures, with the exception of the very early states of booting.
+As we've already mentioned, our main purpose here is to guide the reader through the general process of building a kernel (and surrounding operating system). We're using `x86_64` as our reference architecture, but most of the concepts should transfer to other architectures, with the exception of the very early states of booting.
+
+Below the list of parts that compose the book: 
 
-Below a short list of all the topics that are covered so far: 
+* *Build Process* - The first part is all about setting up a suitable environment for operating systems development, explaining what tools are needed and the steps required to build and test a kernel.
+* *Architecture/Drivers* - This part contains most the architecture specific components, as well as most of the data structures and underlying mechanisms of the hardware we'll need. It also includes some early drivers that are very useful during further development (like the keyboard and timer).
+* *Video Output* - This part looks at working with linear framebuffers, and how we can display text on them to aid with early debugging.
+* *Memory Management* - This part looks at the memory management stack of a kernel. We cover all the layers from the physical memory manager, to the virtual memory manager and the heap.
+* *Scheduling* - A modern operating system should support running multiple programs at once. In this part we're going to look at how processes and threads are implemented, write a simple scheduler and have a look at some of the typical concurrency issues that arise. 
+* *Userspace* - Many modern architectures support different level of privileges, that means programs that are running on lower levels can't access resources/data reserved for higher levels.
+* *Inter-Process Communication (IPC)* - This part looks at how we might implement IPC for our kernel, allowing isolated programs to communicate with each other in a controlled way. 
+* *Virtual File System (VFS)* - This part will cover how a kernel presents different file systems to the rest of the system. We'll also take a look at implementing a 'tempfs' that is loaded from a tape archive (tar), similar to initrd. 
+* *The ELF format* - Once we have a file system we can load files from it, why not load a program? This part looks at writing a simple program loader for ELF64 binaries, and why you would want to use this format.
+* *Going Beyond* - The final part (for now). We have implemented all the core components of a kernel, and we are free to go from here. This final chapter contains some ideas for new components that you might want to add, or at least begin thinking about.
 
-* *Build Process* - The first part is all about getting an osdev environment up and running, explaining what tools are needed, and the steps to build and run a kernel.
-* *Architecture/Drivers* - This part contains most the architecture specific parts, as well as most of the data structures and unerlying mechanisms of the hardware we'll need. It also includes some early drivers that are very useful during further development (like the keyboard and timer).
-* *Memory Management* - This chapter offer an overview of the memory management layers of a kernel. We cover all the layers from the physical memory magager, virtual memory manager and the heap. We'll look at how these fit into the memory management stack, and how they work together.
-* *Scheduling* - A modern operating system should support running multiple programs at once. In this part we're going to look at how processes and threads are implemented, implement a simple scheduler and have a look at some of the typical concurrency issues that arise. 
-* *Userspace* - Many modern architectures support different level of privileges, that means that programs that are running on lower levels can't access resources/data reserved for higher levels.
-* *IPC* - Also known as inter-process communication, is a mechanism for programs to communicate with each other in a safe and controlled way. We're going to take a look at a few ways to implement this.
-* *Virtual File System* - This will cover how a kernel presents different file systems to the rest of the OS. We'll also take a look at implementing a 'tempfs' that is loaded from a tape archive (tar), similar to initrd. 
-* *The Elf format* - Once we have a file system we can load files from it, why not a program? This chapter looks at writing a simple program loader for ELF64 binaries, and why you would want to use this format.
-* *Going beyond* - The final part (for now): we have implemented all the core components of a kernel, and we are free to go from here. This final chapter contains some ideas for new components that you might want to add, or at least begin thinking about.
+In the appendices we cover various topic, from debugging tips, language specific information, troubleshooting, etc.

00_Introduction/03_AboutTheAuthors.md

@@ -1,6 +1,10 @@
 ## About The Authors
 
-*Nerd and in free time programmer!! - I just love software development and everything is about computer, the lower level the better. My main job is software developer, as well as my main hobby (not the only one). I wanted to write my own kernel since i discovered programming. Even though it took years to understand how to do it. My first attempt in writing a kernel was DreamOS (32 bit kernel). My main programming language is C, although i used also Java, Python, Go, Assembly.* - Ivan.
+*Nerd and in free time programmer!! - I just love software development and everything is about computer, the lower level the better. My main job is software developer, as well as my main hobby (not the only one). I wanted to write my own kernel since I discovered programming. Even though it took years to understand how to do it. My first attempt in writing a kernel was DreamOS (32 bit kernel). My main programming language is C, although I used also Java, Python, Go, Assembly.* - Ivan.
 
 *I'm a hobbyist programmer, and have been working on my operating system kernel since 2021, called northport. I've experimented with a few other projects in that time, namely a micro-kernel and a window manager. Before getting into osdev my programming interests were game engines and system utilities. My first programming project that I finished was a task manager clone in C#. These days C++ is my language of choice, I like the freedom the language offers, even if its the freedom to cause a triple fault.* - Dean.
 
+## Our Projects:
+
+* DreamOs64: A x86_64 kernel written in C, with memory management, scheduling and a VFS. Written by Ivan. [https://github.com/dreamos82/Dreamos64](https://github.com/dreamos82/Dreamos64)
+* Northport: 64-bit kernel supporting multiple architectures (x86_64 and riscv64) and SMP. Written in C++ by Dean. [https://github.com/DeanoBurrito/northport](https://github.com/DeanoBurrito/northport)