fix(book): add introduction

book/content/introduction.asc

@@ -1,59 +1,21 @@
 [preface]
 == Introduction
 
-You are about to become a better programmer and graps the fundamentals of Algorithms and Data Structures.
-Let's take a moment to explain how are we going to do that.
+You are about to become a better programmer and grasp the fundamentals of Algorithms and Data Structures.
+Let's take a moment to explain how we are going to do that.
 
-This book is divided in 4 main parts....
+This book is divided into 4 main parts:
 
-In *Chapter 1*, we're going to cover Version Control Systems (VCSs) and Git basics -- no technical stuff, just what Git is, why it came about in a land full of VCSs, what sets it apart, and why so many people are using it.
-Then, we'll explain how to download Git and set it up for the first time if you don't have already on your system.
+In *Part 1*, we will cover the framework to compare and analyze algorithms: Big O notation. When you have multiple solutions to a problem, this framework comes handy to know which solution will scale better.
 
-In *Chapter 2*, we will go over basic Git usage -- how to use Git in the 80% of cases you'll encounter most often.
-After reading this chapter, you should be able to clone a repository, see what has happened in the history of the project, modify files, and contribute changes.
-If the book spontaneously combusts at this point, you should already be pretty useful wielding Git in the time it takes you to go pick up another copy.
+In *Part 2*, we will go over linear data structures and trade-offs about using one over another.
+After reading this part, you will know how to trade space for speed using Maps, when to use a linked list over an array, or what problems can be solved using a stack over a queue.
 
-*Chapter 3* is about the branching model in Git, often described as Git's killer feature.
-Here you'll learn what truly sets Git apart from the pack.
-When you're done, you may feel the need to spend a quiet moment pondering how you lived before Git branching was part of your life.
+*Part 3* is about graphs and trees and its algorithms.
+Here you'll learn how to translate real-world problems into graphs and different algorithms to solve them.
 
-*Chapter 4* will cover Git on the server.
-This chapter is for those of you who want to set up Git inside your organization or on your own personal server for collaboration.
-We will also explore various hosted options if you prefer to let someone else handle that for you.
+*Part 4* will cover tools and techniques to solve algorithmic problems. This section is for those who want to get better at recognizing patterns and improving problem-solving skills. We cover sorting algorithms and standard practices like dynamic programming, greedy algorithms, divide and conquer, and more.
 
-*Chapter 5* will go over in full detail various distributed workflows and how to accomplish them with Git.
-When you are done with this chapter, you should be able to work expertly with multiple remote repositories, use Git over email and deftly juggle numerous remote branches and contributed patches.
-
-*Chapter 6* covers the GitHub hosting service and tooling in depth.
-We cover signing up for and managing an account, creating and using Git repositories, common workflows to contribute to projects and to accept contributions to yours, GitHub's programmatic interface and lots of little tips to make your life easier in general.
-
-*Chapter 7* is about advanced Git commands.
-Here you will learn about topics like mastering the scary 'reset' command, using binary search to identify bugs, editing history, revision selection in detail, and a lot more.
-This chapter will round out your knowledge of Git so that you are truly a master.
-
-*Chapter 8* is about configuring your custom Git environment.
-This includes setting up hook scripts to enforce or encourage customized policies and using environment configuration settings so you can work the way you want to.
-We will also cover building your own set of scripts to enforce a custom committing policy.
-
-*Chapter 9* deals with Git and other VCSs.
-This includes using Git in a Subversion (SVN) world and converting projects from other VCSs to Git.
-A lot of organizations still use SVN and are not about to change, but by this point you'll have learned the incredible power of Git -- and this chapter shows you how to cope if you still have to use a SVN server.
-We also cover how to import projects from several different systems in case you do convince everyone to make the plunge.
-
-*Chapter 10* delves into the murky yet beautiful depths of Git internals.
-Now that you know all about Git and can wield it with power and grace, you can move on to discuss how Git stores its objects,
-what the object model is, details of packfiles, server protocols, and more.
-Throughout the book, we will refer to sections of this chapter in case you feel like diving deep at that point; but if you are like us and want to dive into the technical details, you may want to read Chapter 10 first.
-We leave that up to you.
-
-In *Appendix A*, we look at a number of examples of using Git in various specific environments.
-We cover a number of different GUIs and IDE programming environments that you may want to use Git in and what is available for you.
-If you're interested in an overview of using Git in your shell, your IDE, or your text editor, take a look here.
-
-In *Appendix B*, we explore scripting and extending Git through tools like libgit2 and JGit.
-If you're interested in writing complex and fast custom tools and need low-level Git access, this is where you can see what that landscape looks like.
-
-Finally, in *Appendix C*, we go through all the major Git commands one at a time and review where in the book we covered them and what we did with them.
-If you want to know where in the book we used any specific Git command you can look that up here.
+Finally, in *Appendix A*, we summarize all the topics covered in this book in a cheatsheet. *Appendix B and C* covers self-balancing binary search tree algorithms. *Appendix D* cover the solutions to the problems presented at the end of each chapter.
 
 Let's get started.

book/readme.asc

@@ -44,7 +44,7 @@ include::content/dedication.asc[]
 
 include::content/preface.asc[]
 
-// include::content/introduction.asc[]
+include::content/introduction.asc[]
 
 include::part01-algorithms-analysis.asc[]