Added tex file structure for each module

5 files changed, 419 insertions, 1 deletions

diff --git a/book/module2/ai_assisted_programming.tex b/book/module2/ai_assisted_programming.tex
new file mode 100644
index 0000000..2fee22b
--- /dev/null
+++ b/book/module2/ai_assisted_programming.tex
@@ -0,0 +1,65 @@
+\section{AI Assisted Programming}\label{ai-assisted-programming}
+
+\subsection{What is it?}\label{what-is-it}
+
+Artificial Intelligence (AI) has been around for a long time. However,
+not until recently did engineers make it easy and ``fun'' to work with.
+By now you probably have a pretty good idea of what AI can do. However,
+you may not have used an AI assistant before. As the name suggests, an
+AI assistant can help you develop code, speed up your writing with code
+suggestions and allows you to focus on solving the problem at hand
+rather. AI is a technology that is constantly improving. As engineers we
+need to \emph{understand} how we can use AI as a tool to achieve our
+goals more efficiently. This section cover good practices of how we can
+implement AI and lists some AI assistant tools that we can use. \#\#
+Good vs.~Bad uses of AI Don't try to get AI to do work \emph{for you}
+but \emph{with you}. You need to understand what you're doing. If you
+don't understand what the AI is doing, then you're not in control of the
+work. You're not going to go far until something unexpected happens.
+
+AI is a great learning tool, research as show that students can benefit
+from using AI as personal tutor
+\href{https://hbsp.harvard.edu/inspiring-minds/ai-as-personal-tutor}{more}.
+\#\# Available tools Below is a comprehensive list of tools that are
+available at not cost to you.
+
+\begin{longtable}[]{@{}ll@{}}
+\toprule\noalign{}
+Name & Features \\
+\midrule\noalign{}
+\endhead
+\bottomrule\noalign{}
+\endlastfoot
+GitHub Copilot & Paid, but free for students. Integrated in GitHub. \\
+ChatGPT & Free, optional paid upgrade \\
+Grok & Free, optional paid upgrade \\
+Gemini & Free, optional paid upgrade \\
+GPT4ALL & Free and Open-Source \\
+Code GPT & Free and Open-Source \\
+Cody & Free and Open-Source \\
+DataLab AI & Free \\
+Codeium & Free \\
+aiXcoder & Free \\
+\end{longtable}
+
+Many of the tools above come with similar, if not, the same features.
+Some of the tools come as chatbots on the web and others are extensions
+that can be implemented in your favorite IDE. \#\# VSCode and GitHub
+Copilot Integration We will not cover how to use VSCode in this course,
+however it is a very versatile IDE that comes with many other extension,
+for example git, github and github copilot integration. There are also
+other extensions for other IDE's however we will only cover some basic
+features that the GithHub Copilot extension in VSCode can do.
+
+Copilot Comes with the following features: - Get code suggestions as you
+type - Ask questions about the code - Inline chat to generate code. -
+Fix and debug code using the chat window - Generate code documentation
+
+\href{https://code.visualstudio.com/}{VSCode}
+\href{https://code.visualstudio.com/docs/copilot/setup-simplified}{Copilot
+extension} \#\# A note on integrity If you have a
+non-disclosure-agreement (NDA) with your employer, it may not always be
+possible to use AI for security and integrity reasons as you may risk
+exposing confidential information with third party vendors. It is highly
+recommended to be able to be able to write program independently of an
+AI assistant. Always think before you share data.
diff --git a/book/module2/debugging_code.tex b/book/module2/debugging_code.tex
new file mode 100644
index 0000000..ce3e99e
--- /dev/null
+++ b/book/module2/debugging_code.tex
@@ -0,0 +1,144 @@
+\section{Debugging Code}\label{debugging-code}
+
+\subsection{Introduction}\label{introduction}
+
+Have you ever had a piece of code not work the way you expected? What
+did you do? You may have , asked a friend or used an AI assistant. In
+this section, the following concepts are introduced - definition of a
+bug, common types of bugs and debugging techniques.
+
+A \emph{software bug} is an unintentional mistake or defect with a
+program, this comes either from when the programmer makes a mistake in
+writing the code or the code works in a way which has consequences that
+were not foreseen by the programmer. Debugging is the act removing the
+bugs in the software. Debugging is a normal part of programming that
+even experiences developers spend a lot of time on.
+
+\subsection{Types of Bugs}\label{types-of-bugs}
+
+When writing code you are guaranteed to have bugs in your code. These
+bugs can be categorized in the following three groups.
+
+\begin{itemize}
+\tightlist
+\item
+  \textbf{Syntax errors} - this type of error occurs when the code fails
+  due to missing colons, missing indentation or a typo in code - some
+  languages like python are case sensitive meaning that the a capital
+  letter are different symbols.
+\item
+  \textbf{Runtime errors} - e.g., dividing by zero or file not found.
+\item
+  \textbf{Logical errors} - this may be the most dangerous that we need
+  to be careful with because this error can occur without any error
+  messages but it gives you the wrong result.
+\end{itemize}
+
+\subsection{Debugging Techniques}\label{debugging-techniques}
+
+\paragraph{Print Debugging}\label{print-debugging}
+
+Insert print statements to check values of variables throughout the
+program.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ add(x, y):}
+    \BuiltInTok{print}\NormalTok{(}\SpecialStringTok{f"x = }\SpecialCharTok{\{}\NormalTok{x}\SpecialCharTok{\}}\SpecialStringTok{, y = }\SpecialCharTok{\{}\NormalTok{y}\SpecialCharTok{\}}\SpecialStringTok{"}\NormalTok{)}
+    \ControlFlowTok{return}\NormalTok{ x }\OperatorTok{+}\NormalTok{ y}
+\end{Highlighting}
+\end{Shaded}
+
+In the example above the print statement gives us feedback on what the
+code is doing. The function in this example is obviously very simple,
+but when we start applying more complex equations or function then
+checking to see if the input variables are correct can indicate whether
+there is an issue lies within the \texttt{add()} function or if the
+function is given an incorrect input.
+
+\paragraph{Rubber Duck Debugging}\label{rubber-duck-debugging}
+
+This is a technique by which you explaining your code line by line in
+natural language to someone else, yourself or an inanimate object like a
+rubber duck. This can help you spot your mistake in the code.
+
+\paragraph{Commenting Out Code}\label{commenting-out-code}
+
+Using comments to temporarily suppress parts of your code help you
+isolate and find the bug.
+
+\paragraph{IDE Debugging tools}\label{ide-debugging-tools}
+
+Depending if you use an IDE, they often come with some sort of debugging
+tools such as breakpoints, step into/over and variables explorers.
+
+\paragraph{AI Chat}\label{ai-chat}
+
+AI chat bots can help you find typo or fix logic in your code. You may
+find yourself going through the steps above when using an AI assistant
+to help you debug the code. However \emph{never} assume that the code AI
+gives you works the way you intend it to work.
+
+\subsection{Interactive Debugging
+Activity}\label{interactive-debugging-activity}
+
+In the following code snippets, debug the code and document the
+following: - What the bug is - How you found it (technique used) - What
+actions you took to fix the bug
+
+\paragraph{Code 1}\label{code-1}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ greet(name)}
+    \BuiltInTok{print}\NormalTok{(}\StringTok{"Hello, "} \OperatorTok{+}\NormalTok{ Name)}
+\NormalTok{greet(}\StringTok{"John"}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\paragraph{Code 2}\label{code-2}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ImportTok{import}\NormalTok{ numpy }\ImportTok{as}\NormalTok{ np}
+
+\NormalTok{x }\OperatorTok{=}\NormalTok{ np.linspace(}\DecValTok{0}\NormalTok{,}\DecValTok{5}\NormalTok{,}\DecValTok{100}\NormalTok{)}
+\NormalTok{y }\OperatorTok{=} \DecValTok{1}\OperatorTok{/}\NormalTok{x}
+
+\BuiltInTok{print}\NormalTok{(}\StringTok{"Result:"}\NormalTok{, y[}\DecValTok{0}\NormalTok{])}
+\end{Highlighting}
+\end{Shaded}
+
+\paragraph{Code 3}\label{code-3}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ f(x):}
+    \ControlFlowTok{return}\NormalTok{ x}\OperatorTok{**}\DecValTok{2} \OperatorTok{{-}} \DecValTok{4}  \CommentTok{\# Root at x = ±2}
+
+\KeywordTok{def}\NormalTok{ bisection(a, b, tol}\OperatorTok{=}\FloatTok{1e{-}5}\NormalTok{, max\_iter}\OperatorTok{=}\DecValTok{100}\NormalTok{):}
+    \ControlFlowTok{if}\NormalTok{ f(a) }\OperatorTok{*}\NormalTok{ f(b) }\OperatorTok{\textgreater{}=} \DecValTok{0}\NormalTok{:}
+        \BuiltInTok{print}\NormalTok{(}\StringTok{"Bisection method fails. f(a) and f(b) should have opposite signs."}\NormalTok{)}
+        \ControlFlowTok{return} \VariableTok{None}
+
+    \ControlFlowTok{for}\NormalTok{ i }\KeywordTok{in} \BuiltInTok{range}\NormalTok{(max\_iter):}
+\NormalTok{        c }\OperatorTok{=}\NormalTok{ (a }\OperatorTok{+}\NormalTok{ b) }\OperatorTok{/} \DecValTok{2}
+        \ControlFlowTok{if} \BuiltInTok{abs}\NormalTok{(f(c)) }\OperatorTok{\textless{}}\NormalTok{ tol:}
+            \ControlFlowTok{return}\NormalTok{ c}
+        \ControlFlowTok{elif}\NormalTok{ f(c) }\OperatorTok{*}\NormalTok{ f(b) }\OperatorTok{\textless{}} \DecValTok{0}\NormalTok{:}
+\NormalTok{            a }\OperatorTok{=}\NormalTok{ c}
+        \ControlFlowTok{else}\NormalTok{:}
+\NormalTok{            b }\OperatorTok{=}\NormalTok{ c}
+    \ControlFlowTok{return}\NormalTok{ (a }\OperatorTok{+}\NormalTok{ b) }\OperatorTok{/} \DecValTok{2}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Reflection}\label{reflection}
+
+\begin{itemize}
+\tightlist
+\item
+  What was the most challenging bug you found?
+\item
+  What debugging method did you find most useful?
+\end{itemize}
diff --git a/book/module2/intro_to_numerical_methods.tex b/book/module2/intro_to_numerical_methods.tex
new file mode 100644
index 0000000..737d69d
--- /dev/null
+++ b/book/module2/intro_to_numerical_methods.tex
@@ -0,0 +1,41 @@
+\section{Numerical Methods}\label{numerical-methods}
+
+Engineering
+
+\subsection{What is a numerical
+method?}\label{what-is-a-numerical-method}
+
+Numerical methods are techniques that transform mathematical problems
+into forms that can be solved using arithmetic and logical operations.
+Because digital computers excel at these computations, numerical methods
+are often referred to as computer mathematics.
+
+\subsection{Numerical Differentiation}\label{numerical-differentiation}
+
+Forwards difference Backwards difference
+
+\href{https://pythonnumericalmethods.studentorg.berkeley.edu/notebooks/chapter20.00-Numerical-Differentiation.html}{Read
+More}
+
+\subsection{Roots and Optimization}\label{roots-and-optimization}
+
+Incremental Search Bisection Modified Secant Newton-Raphson
+
+\subsection{Numerical Integration}\label{numerical-integration}
+
+Trapezoidal
+
+Simpson's Rule
+
+\href{https://pythonnumericalmethods.studentorg.berkeley.edu/notebooks/chapter21.00-Numerical-Integration.html}{Read
+More}
+
+\subsection{Numerical Solutions of Ordinary Differential
+Equations}\label{numerical-solutions-of-ordinary-differential-equations}
+
+Euler's Method - Forward - Backwards
+
+Runge-Kutta Method
+
+\href{https://pythonnumericalmethods.studentorg.berkeley.edu/notebooks/chapter22.00-ODE-Initial-Value-Problems.html}{Read
+More}
diff --git a/book/module2/module2.tex b/book/module2/module2.tex
index d5e9785..f16e7e2 100644
--- a/book/module2/module2.tex
+++ b/book/module2/module2.tex
@@ -1,2 +1,5 @@
 \chapter{Module 2}
-\input{module2/debugging}
+\input{module2/ai_assisted_programming}
+\input{module2/debugging_code}
+\input{module2/intro_to_numerical_methods}
+\input{module2/version_control}
diff --git a/book/module2/version_control.tex b/book/module2/version_control.tex
new file mode 100644
index 0000000..3c5ac6a
--- /dev/null
+++ b/book/module2/version_control.tex
@@ -0,0 +1,165 @@
+\section{Version Control Software}\label{version-control-software}
+
+\subsection{What is Version Control}\label{what-is-version-control}
+
+Version control is a system that tracks changes to files, enabling
+developers to collaborate, manage code history, and revert to previous
+versions when needed. The most used version control software (VCS) is
+git. In this course git is the VCS we will be using.
+
+In the open-source community VCS is the - Tracks changes and history. -
+Enables collaboration among developers. - Reduces errors by managing
+code versions. - Supports branching and merging for parallel
+development.
+
+In this section is divided up into two major sections. The first section
+\emph{Git} will cover the basics of how to create backups of your
+project. The second section will cover how to use git with GitHub to
+\emph{collaborate} on projects.
+
+\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}
+
+\subsection{Git}\label{git}
+
+Git is a version control program that tracks changes to files and
+directories using snapshots. It is a distributed version control system,
+meaning that each developer has a complete copy of the repository on
+their local computer. Git is the most widely used version control system
+and is popular among developers for its speed, flexibility, and
+efficiency.
+
+\subsubsection{The Three States}\label{the-three-states}
+
+Pay attention now --- here is the main thing to remember about Git if
+you want the rest of your learning process to go smoothly. Git has three
+main states that your files can reside in: modified, staged, and
+committed:
+
+\begin{itemize}
+\tightlist
+\item
+  \textbf{Modified} means that you have changed the file but have not
+  committed it to your database yet.
+\item
+  \textbf{Staged} means that you have marked a modified file in its
+  current version to go into your next commit snapshot.
+\item
+  \textbf{Committed} means that the data is safely stored in your local
+  database.
+\end{itemize}
+
+This leads us to the three main sections of a Git project: the working
+tree, the staging area, and the Git directory.
+
+\includegraphics{https://git-scm.com/book/en/v2/images/areas.png} \#\#\#
+Branching In git, branches allow for parallel workflow on a project. It
+give contributors the ability to work different features at the same
+time. Each branch represents an independent line of development, and
+once a feature or fix is complete, it can be merged back into the main
+branch. Here is a common branching structure used in many Git projects:
+- Main Branch - The main branch (a.k.a. master branch) is the default
+branch in a Git repository and contains the stable version of the code.
+- Development Branch - is created to develop a new feature or fix a bug
+without affecting the main branch. It isn't necessarily always stable,
+but whenever it gets to a stable state, it can be merged into master. -
+Topic Branch - A topic branch is a short-lived branch that you create
+and use for a single particular feature or related work.
+\includegraphics{https://git-scm.com/book/en/v2/images/lr-branches-2.png}
+\#\#\# Best Practices - Use descriptive commit messages. - Commit early
+and often. - Keep commits focused on a single change. - Use feature
+branches for new features or bug fixes. - Review and test changes before
+merging. - Resolve conflicts promptly. - Keep the commit history clean
+and organized.
+
+\subsubsection{Basic Commands}\label{basic-commands}
+
+Here is a list of some git commands to get you started. \#\#\#\#
+Starting your repository - \texttt{git\ init} - Initialize a new Git
+repository. - \texttt{git\ clone} - Clone an existing repository.
+\#\#\#\# Committing - \texttt{git\ status} - Check the status of the
+repository. - \texttt{git\ add} - Add files to the staging area. -
+\texttt{git\ commit} - Commit changes to the repository. \#\#\#\#
+Branching - \texttt{git\ branch} - List, create, or delete branches. -
+\texttt{git\ checkout} - Switch between branches. \#\#\#\#
+History/Inspection - \texttt{git\ log} - View the commit history.
+\#\#\#\# Collaborative - \texttt{git\ fetch} - Fetches updates from a
+remote but does not merge. - \texttt{git\ merge} - Merge changes from a
+named commit to the current branch. - \texttt{git\ pull} - Fetch and
+merge changes from a remote repository. - \texttt{git\ push} - Push
+changes to a remote repository.
+
+\subsubsection{More on git}\label{more-on-git}
+
+Interested in learning more about git? Here's a free book that teaches
+you everything about git and how to use it at a professional level.
+Available as both HTML and PDF download:
+\href{https://git-scm.com/book/en/v2}{Git Pro}.
+
+\subsection{GitHub - The collaborative
+platform}\label{github---the-collaborative-platform}
+
+GitHub is a web-based platform that hosts Git repositories and provides
+collaboration tools for developers. It allows developers to share code,
+track issues, and collaborate on projects with other developers. GitHub
+is widely used for open-source projects, team collaboration, and code
+hosting. \#\#\# GitHub Features - Remote Repository Hosting - GitHub
+allows you to host projects and code remotely on their servers. - Issues
+- Issues are used to track bugs, feature - Pull Requests - Internal
+request system for contributors to request code to be pulled. \#\#\#
+Workflow Depending on the size of the project and whether the project is
+closed- or open-source, the workflow of the project will differ. In this
+section we cover some git workflow models and the model you're going to
+be using for this course.
+
+\textbf{Centralized}: The project has only one central hub or
+\emph{repository}, can accept code and everybody synchronizes their work
+with it. This model is suitable for small and closed-sourced projects.
+\includegraphics{https://git-scm.com/book/en/v2/images/centralized_workflow.png}
+
+\textbf{Integration-Manager:} There are multiple public variants of the
+code original code known as \emph{forks}. The integration manager can
+decide what features to pull from the forks. This is the model that is
+similar to the one used on GitHub
+\includegraphics{https://git-scm.com/book/en/v2/images/integration-manager.png}
+
+\textbf{Dictator and Lieutenants Workflow:} This is similar to the
+integration-manager model, however due to the size of the project. A
+rank of integration managers is formed. one example of this is the
+development of the Linux kernel.
+\includegraphics{https://git-scm.com/book/en/v2/images/benevolent-dictator.png}
+
+GitHub is designed around a particular collaboration workflow, centered
+on Pull Requests. This flow works whether you're collaborating with a
+tightly-knit team in a single shared repository, or a
+globally-distributed company or network of strangers contributing to a
+project through dozens of forks. It is centered on the Topic Branches
+workflow covered in Git Branching.
+
+Here's how it generally works: 1. Fork the project. 2. Create a topic
+branch from master. 3. Make some commits to improve the project. 4. Push
+this branch to your GitHub project. 5. Open a Pull Request on GitHub. 6.
+Discuss, and optionally continue committing. 7. The project owner merges
+or closes the Pull Request. 8. Sync the updated master back to your
+fork.
+
+\subsubsection{Terms}\label{terms}
+
+\begin{itemize}
+\tightlist
+\item
+  Pull Request - A \emph{pull request} is a request to merge changes
+  from a feature branch into the main branch or from a forked repository
+  to the original or ``upstream'' repository.
+\item
+  Merge - A \emph{merge} combines the changes from one branch into
+  another branch.
+\item
+  Conflict - A \emph{conflict} occurs when Git cannot automatically
+  merge changes and requires manual intervention.
+\end{itemize}
+
+\subsubsection{Code resource - Using GitHub to re-use existing
+code.}\label{code-resource---using-github-to-re-use-existing-code.}
+
+In your engineering career, you will most likely use a computation
+method that has been come up with before. In such scenarios, open-source