From a3e508b546c741536bec289bd9ebf8b0be3abda1 Mon Sep 17 00:00:00 2001
From: Steven Baltakatei Sandoval <baltakatei@gmail.com>
Date: Fri, 12 Aug 2022 21:47:26 +0000
Subject: [PATCH 1/1] feat(src/notes.tm):Add TeXmacs file for personal notes

---
 src/notes.tm | 225 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 225 insertions(+)
 create mode 100644 src/notes.tm

diff --git a/src/notes.tm b/src/notes.tm
new file mode 100644
index 0000000..c55e59e
--- /dev/null
+++ b/src/notes.tm
@@ -0,0 +1,225 @@
+<TeXmacs|2.1.1>
+
+<style|<tuple|book|style-bk>>
+
+<\body>
+  <chapter|Definitions>
+
+  <section|Terminology>
+
+  <\description-compact>
+    <item*|declaration<label|term declaration>>A construct that establishes
+    an association between a particular variable, function, or type and its
+    attributes. (See <hlink|cppreference.com|https://en.cppreference.com/w/c/language/declarations>
+    and <hlink|microsoft.com|https://docs.microsoft.com/en-us/cpp/c-language/c-declarations-and-definitions>).
+    Compare with <with|font-series|bold|definition>.
+
+    <item*|definition<label|term definition>>A construct that stablishes the
+    same associations as a declaration but also causes storage to be
+    allocated for the variable. (See <hlink|microsoft.com|https://docs.microsoft.com/en-us/cpp/c-language/c-declarations-and-definitions>).
+
+    <item*|enumeration<label|term enumeration>><hlink|Enumeration|https://en.wikipedia.org/wiki/Enumeration>
+    (or <code*|enum>) is a user defined data type in <name|C>. It is mainly
+    used to assign names to integral constants. For example, the declaration
+    <code*|enum year{Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov,
+    Dec};> allows writing a for loop with names of months <code*|for (i=Jan;
+    i\<less\>=Dec; i++)> to cycle <code*|i> through the integers <code*|0, 1,
+    2, 3, <text-dots>, 10, 11>.
+
+    <item*|escape sequence<label|term escape_sequence>>A set of characters
+    used to represent hard-to-type or invisible characters. Some commonly
+    used escape sequences in <name|C> include:
+
+    <\description-paragraphs>
+      <item*|<cpp|\\n>>Represents the <em|newline> character.
+
+      <item*|<cpp|\\t>>Represents the <em|tab> character.
+
+      <item*|<cpp|\\b>>Represents the <em|backspace> character.
+
+      <item*|<cpp|\\\\>>Represents the <em|backslash> (i.e.
+      \P<verbatim|<em|\\>>\Q) character.
+    </description-paragraphs>
+
+    All other escape sequences used in <name|C> are:
+
+    <\description-paragraphs>
+      <item*|<cpp|\\a>>Represents the <em|alert> (bell) character.
+
+      <item*|<cpp|\\f>>Represents the <em|formfeed> character.
+
+      <item*|<cpp|\\r>>Represents the <em|carriage return> character.
+
+      <item*|<cpp|\\t>>Represents the <em|horizontal tab> character.
+
+      <item*|<cpp|\\v>>Represents the <em|vertical tab> character.
+
+      <item*|<cpp|\\?>>Represents the <em|question mark> character.
+
+      <item*|<cpp|\\'>>Represents the <em|single quote> character.
+
+      <item*|<cpp|\\">>Represents the <em|double quote> character.
+
+      <item*|<cpp|\\><em|ooo>>Represents an <em|octal number> (e.g.
+      <cpp|\\012> is the <em|newline> character<\footnote>
+        <label|ref includehelp-oct-hex>See
+        <hlinkv|https://www.includehelp.com/c/octal-and-hexadecimal-escape-sequences.aspx>.
+      </footnote>).
+
+      <item*|<cpp|\\x><em|hh>>Represents a <em|hexadecimal> number (e.g.
+      <cpp|\\x0A> is the <em|newline> character<rsup|<reference|ref
+      includehelp-oct-hex>>).
+    </description-paragraphs>
+
+    <label|term garbage_collection><item*|garbage collection>The process of
+    freeing memory allocated by a program but which is no longer referenced.
+    Usually incurs a significant <hlink|speed
+    penalty|https://en.wikipedia.org/wiki/Overhead_(computing)>.
+    (<hlink|Wikipedia|https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)>).
+    The <name|C> Language does not provide garbage collection by default.
+
+    <item*|<label|term heap>heap>A large pool of memory that can be used
+    dynamically \U it is also known as the \Pfree store\Q. This is memory
+    that is not automatically managed \U you have to explicitly allocate
+    (using functions such as malloc), and deallocate (e.g. free) the memory.
+    Failure to free the memory when you are finished with it will result in
+    what is known as a memory leak. Is the diametrical opposite of the stack
+    (which, by contrast, is limited not by physical memory but by a
+    CPU-determined stack size). (See <hlink|craftofcoding.wordpress.com|https://craftofcoding.wordpress.com/2015/12/07/memory-in-c-the-stack-the-heap-and-static/>).
+
+    <item*|<label|term machine-independent>machine-independent>A property of
+    code that does not have to be modified in order to run on a different
+    hardware architecture. (e.g. \PC is called a portable language because
+    [code written in C] will run on any machine which supports C, without
+    modifying a single line of code.\Q; <hlink|link|https://www.log2base2.com/C/basic/introduction-to-c-language.html>).
+
+    <item*|<label|term operand>operand>A quantity to which an operator is
+    applied. (e.g. in the <name|C> math expression <code*|7 - 4 = 3>,
+    <code*|7> is the first operand and <code*|4> is the second operand.)
+
+    <item*|<label|term operator>operator>A special type of function with
+    limited numbers of parameters (e.g. 1 to 2) and syntax often requiring a
+    set of characters different from those normally use for naming variables
+    (e.g. the <code*|+> character in <code*|myVar = 1 + 2>, the <code*|&&> in
+    <code*|a && b>, or the <code*|++> in <code*|i++>.).
+
+    <item*|<label|term stack>stack>A region of memory for global variable
+    storage and is permanent for the entire run of the program. Stack size is
+    limited not by physical memory availability but by the CPU. Lifetime of
+    local variables declared within the stack is enforced by the Last-In,
+    First-Out nature of the stack; when a function returns a value, all stack
+    memory allocated by declarations within the function is automatically
+    freed. (See <hlink|craftofcoding.wordpress.com|https://craftofcoding.wordpress.com/2015/12/07/memory-in-c-the-stack-the-heap-and-static/>)
+
+    <item*|<label|term struct>struct>(short:
+    <hlink|struct|https://en.wikipedia.org/wiki/struct_(C_programming_language)>)
+    a <hlink|composite data type|https://en.wikipedia.org/wiki/Composite_data_type>
+    that defines a physically grouped list of variables under one name in a
+    block of memory, allowing the different variables to be accessed via a
+    single <hlink|pointer|https://en.wikipedia.org/wiki/Pointer_(computer_programming)>
+    or by the struct declared name which returns the same address.
+
+    <label|term structure_assignment><item*|structure assignment>The act of
+    <hlink|assigning|https://en.wikipedia.org/wiki/Assignment_(computer_science)>
+    a <hlink|struct|https://en.wikipedia.org/wiki/struct_(C_programming_language)>
+    to another struct. (?) (<hlink|example|https://stackoverflow.com/a/2302359/10850071>)
+
+    <item*|<label|term text_stream>text stream>A sequence of characters
+    divided into lines; each line consists of zero or more characters
+    followed by a newline character. (See K&R 2nd Ed. Section 1.5 \PCharacter
+    Input and Output\Q)
+  </description-compact>
+
+  \;
+
+  <section|Functions>
+
+  <subsection|Character Input and Output>
+
+  <\description>
+    <item*|<cpp|getchar()><label|func getchar>>Read one character at a time.
+
+    <item*|<cpp|for()>>A generalization of <cpp|while()>. Takes three
+    arguments:
+
+    <\enumerate>
+      <item>Local statement to run before loop (e.g. to initialize a counting
+      variable).
+
+      <item>Local statement that, if evaluated as true, permits running of
+      next iteration of loop.
+
+      <item>Local statement to run after loop (e.g. to increment a counting
+      variable).
+    </enumerate>
+
+    <item*|<cpp|putchar()><label|func putchar>>Write one character at a time.
+
+    <item*|<cpp|printf()>>Used for printing formatted text to console.
+  </description>
+
+  \;
+
+  \;
+
+  \;
+</body>
+
+<\initial>
+  <\collection>
+    <associate|preamble|false>
+  </collection>
+</initial>
+
+<\references>
+  <\collection>
+    <associate|auto-1|<tuple|1|?>>
+    <associate|auto-2|<tuple|1.1|?>>
+    <associate|auto-3|<tuple|1.2|?>>
+    <associate|auto-4|<tuple|1.2.1|?>>
+    <associate|footnote-1.1.1|<tuple|1.1.1|?>>
+    <associate|footnote-1.1.2|<tuple|1.1.2|?>>
+    <associate|footnr-1.1.1|<tuple|1.1.1|?>>
+    <associate|footnr-1.1.2|<tuple|1.1.2|?>>
+    <associate|func getchar|<tuple|1.2.1|?>>
+    <associate|func putchar|<tuple|3|?>>
+    <associate|ref includehelp-oct-hex|<tuple|1.1.1|?>>
+    <associate|term declaration|<tuple|1.1|?>>
+    <associate|term definition|<tuple|declaration<label|term declaration>|?>>
+    <associate|term enumeration|<tuple|definition<label|term definition>|?>>
+    <associate|term escape_sequence|<tuple|enumeration<label|term
+    enumeration>|?>>
+    <associate|term foo|<tuple|structure assignment|?>>
+    <associate|term garbage_collection|<tuple|1.1.1|?>>
+    <associate|term heap|<tuple|garbage collection|?>>
+    <associate|term machine-independent|<tuple|<label|term heap>heap|?>>
+    <associate|term operand|<tuple|<label|term
+    machine-independent>machine-independent|?>>
+    <associate|term operator|<tuple|<label|term operand>operand|?>>
+    <associate|term stack|<tuple|<label|term operator>operator|?>>
+    <associate|term struct|<tuple|<label|term stack>stack|?>>
+    <associate|term structure_assignment|<tuple|<label|term struct>struct|?>>
+    <associate|term text_stream|<tuple|structure assignment|?>>
+    <associate|term-sep XX|<tuple|structure assignment|?>>
+  </collection>
+</references>
+
+<\auxiliary>
+  <\collection>
+    <\associate|toc>
+      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|1<space|2spc>Definitions>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-1><vspace|0.5fn>
+
+      1.1<space|2spc>Terminology <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-2>
+
+      1.2<space|2spc>Functions <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-3>
+
+      <with|par-left|<quote|1tab>|1.2.1<space|2spc>Character Input and Output
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-4>>
+    </associate>
+  </collection>
+</auxiliary>
\ No newline at end of file
-- 
2.39.5