diff --git a/.gitignore b/.gitignore
old mode 100644
new mode 100755
diff --git a/20200625123723-write_fleeting_notes_to_free_your_mind_of_recalling.org b/20200625123723-write_fleeting_notes_to_free_your_mind_of_recalling.org
new file mode 100755
index 0000000..fa63bbb
--- /dev/null
+++ b/20200625123723-write_fleeting_notes_to_free_your_mind_of_recalling.org
@@ -0,0 +1,16 @@
+#+title: Create a writing inbox to store your thoughts
+
+
+One of the best practices for [[file:note-taking.org][Note-taking]] is writing [[file:20200625131209-fleeting_notes.org][Fleeting notes]] which are used to store essential information so that your brain doesn't have to.
+Our brain is not good for storing ideas, only creating and jumping between them.
+
+Since fleeting notes are only made for quickly capturing thoughts, its input is often messy.
+The very least we can do to consistently retrieve our messy thoughts is to put it in a place: a writing inbox where we store all of our fleeting notes.
+
+We can then revisit our inbox for recalling.
+In my case, I use the inbox for task management and writing [[file:evergreen-notes.org][Evergreen notes]].
+
+Like our emails, our writing inbox should be cleaned up each time we visit our inbox.
+Feel free to remove entries that are not in need and replace them with new ones.
+If you want to store an idea for an indefinite future (e.g., a project idea, future hobbies) that you cannot surely do now, you can create an inbox for future ideas.
+(On the other hand, extending this system is closer to the [[https://en.wikipedia.org/wiki/Getting_Things_Done][Getting things done (GTD) method]].)
diff --git a/20200625131209-fleeting_notes.org b/20200625131209-fleeting_notes.org
new file mode 100755
index 0000000..7ae8261
--- /dev/null
+++ b/20200625131209-fleeting_notes.org
@@ -0,0 +1,17 @@
+#+title: Fleeting notes
+
+
+Fleeting notes are a valuable scratchpad for our messy thoughts — it's natural to have a messy input since they are catered only to yourself.
+It is the opposite of [[file:evergreen-notes.org][Evergreen notes]] in a way that can represent your experimental side.
+
+With messy thoughts and inputs, you should [[file:20200625123723-write_fleeting_notes_to_free_your_mind_of_recalling.org][Create a writing inbox to store your thoughts]] all in one place.
+You could search through them with various search techniques to quickly retrieve them (see [[file:apply-search-tools-and-techniques-for-your-digital-library.org][Apply search tools and techniques for your digital library]]).
+In this note-taking system, you can make fleeting notes as your "messy" notebook containing wild ideas and with evergreen notes as your "neat" notebook containing solidified ideas.
+
+Ideally, all of your notes should be evergreen but there are times where a note is [[https://notes.andymatuschak.org/z2ZAGQBHuJ2u9WrtAQHAEHcCZTtqpsGkAsrD1][more suitable to be transient]] (e.g., course notes, book summaries) and that's OK.
+There are a lot of ways you could use your fleeting notes.
+
+- Fleeting notes are solid foundations for your evergreen notes, essentially serving as a draft.
+- Fleeting notes can be used as a refresher on things you've done, tracing the steps and remembering the lessons as you go.
+- Since fleeting notes usually are disconnected, you could attach a randomizing system ala-[[https://apps.ankiweb.net/][Anki]].
+  Though, of course, use the tools that you're comfortable with.
diff --git a/20200625232424-structure_and_interpretation_of_computer_programs.org b/20200625232424-structure_and_interpretation_of_computer_programs.org
new file mode 100755
index 0000000..ec99b6e
--- /dev/null
+++ b/20200625232424-structure_and_interpretation_of_computer_programs.org
@@ -0,0 +1,390 @@
+#+title: Structure and interpretation of computer programs
+#+PROPERTY: header-args    :exports both
+#+ROAM_TAGS: @fleeting
+
+
+This is just my personal notes on [[http://mitpress.mit.edu/sicp][Structure and interpretation of computer programs]].
+I also studied with the [[https://archive.org/details/ucberkeley-webcast-PL3E89002AA9B9879E?sort=titleSorter][Brian Harvey's SICP lectures]] because I am a scrub. ;p
+
+Before you can use this document, you need to do some prerequisite installation of [[https://racket-lang.org/][Racket]] and [[https://docs.racket-lang.org/sicp-manual/][SICP package]].
+
+
+
+
+* Elements of programming
+
+Programming often requires the following:
+
+- Simple expressions with atomic value.
+- A way to combine procedures into complex expressions.
+- A way to define procedures for abstractions.
+
+In order to do programming, we must have a programming language.
+A programming language often requires the following to have an effective way of expressing code:
+
+- Expressions which varies from primitive expressions (e.g., ~42~, ~1.683~, ~53819492184~) to compound expressions (e.g., ~(+ 53 20)~, ~(- 464 254)~).
+- An environment of objects which you can refer by name either with values (e.g., ~(define x 10)~, ~(define pi 3.14)~, ~(define e 2.71828)~) or procedures (e.g., ~(define (square x) (* x x))~, ~(define (my-formula height weight length) (* 23 (/ height weight) (+ 3500 length)))~).
+- An evaluation model for expressions since certain procedures can have different output from the order of operations.
+
+A programming language lets us abstract procedures as a black box.
+Here's an example of implementing the square root given a number.
+
+#+BEGIN_SRC racket  :lang sicp
+(define (square x) (* x x))
+(define (improve guess x)
+  (/ (+ guess (/ x guess)) 2))
+
+(define (good-enough? guess x)
+  (< (abs (- (square guess) x)) 0.001))
+
+(define (sqrt-iter guess x)
+  (if (good-enough? guess x)
+      guess
+      (sqrt-iter (improve guess x) x)))
+
+(define (sqrt x)
+  (sqrt-iter 1.0 x))
+
+(sqrt 4)
+(sqrt 100)
+(sqrt 45.65)
+#+END_SRC
+
+#+RESULTS:
+: 2.0000000929222947
+: 10.000000000139897
+: 6.756478442187127
+
+In order to do the square root extraction in our implementation, we define multiple procedures with each solving a part of the procedure: one procedure for indicating whether the guess is good enough, one for creating an improved guess for the next iteration, and one for actually doing the square root extraction.
+
+In general cases, we don't implement things as one thing as it will result in a messy state of code.
+Instead, we modularize those functions.
+We classify these procedures as a *procedural abstraction*.
+
+
+
+
+* Higher-order functions
+
+Functions and data are often separated similarly to verbs and subjects.
+We tend to think of them as different things relying on each other to do things: functions need data to manipulate while data are raw information to be arranged by a function.
+However, the reality is that there is a blurry line to how distinct both of them are.
+Functions can be treated similarly to data and vice versa.
+
+The lesson of higher-order functions proves this.
+It is one of the foundations of functional programming.
+In order to learn about it, you need to know the key: *generalizing patterns*.
+
+For example, say we have different functions for knowing the area of a shape.
+
+#+BEGIN_SRC racket  :lang sicp
+(define pi 3.14)
+
+(define (square-area r) (* r r))
+(define (circle-area r) (* pi r r))
+(define (hexagon-area r) (* (sqrt 3) 1.5 r r))
+#+END_SRC
+
+This could pass as a decent code if each area function is distinct from each other.
+However, all of the given area functions involves squaring the given parameter (~r~).
+We can separate that step in a function like the following.
+
+#+BEGIN_SRC racket  :lang sicp
+(define pi 3.14)
+(define (area shape r) (* shape r r))
+
+(define square 1)
+(define circle pi)
+(define hexagon (* (sqrt 3) 1.5))
+#+END_SRC
+
+
+
+
+* Exercise solutions
+
+
+** Exercise 1.2
+
+#+BEGIN_SRC racket  :lang sicp  :results silent
+(/ (+ 5 4
+    (- 2
+        (- 3
+          (+ 6
+              (/ 1 3)))))
+  (* 3
+    (- 6 2)
+    (- 2 7)))
+#+END_SRC
+
+
+** Exercise 1.3
+
+#+BEGIN_SRC racket  :lang sicp  :results silent
+(define (square x) (* x x))
+(define (sum-of-squares x y z)
+  (define sum (+ (square x) (square y) (square z)))
+  (- sum (square (min x y z))))
+#+END_SRC
+
+
+** Exercise 1.5
+
+If the interpreter evaluates with applicative-order, it will never evaluate the if condition since ~(p)~ is now endlessly being evaluated.
+(Applicative-order evaulates each argument before passing on the function.)
+Meanwhile, if it's evaluated at normal order, it would simply expand then start to evaluate them in order.
+It would go evaluate the ~if~ condition and proceed to return 0 (since it returns true).
+
+
+** Exercise 1.6
+
+#+begin_quote
+Alyssa P. Hacker doesn't see why if needs to be provided as a special form.
+"Why can't I just define it as an ordinary procedure in terms of cond?" she asks.
+Alyssa's friend Eva Lu Ator claims this can indeed be done, and she defines a new version of if:
+
+#+BEGIN_EXAMPLE
+(define (new-if predicate then-clause else-clause)
+  (cond (predicate then-clause)
+        (else else-clause)))
+#+END_EXAMPLE
+
+Eva demonstrates the program for Alyssa:
+
+#+BEGIN_EXAMPLE
+(new-if (= 2 3) 0 5)
+5
+
+(new-if (= 1 1) 0 5)
+0
+#+END_EXAMPLE
+
+Delighted, Alyssa uses new-if to rewrite the square-root program:
+
+#+BEGIN_EXAMPLE
+(define (sqrt-iter guess x)
+  (new-if (good-enough? guess x)
+          guess
+          (sqrt-iter (improve guess x)
+                     x)))
+#+END_EXAMPLE
+
+What happens when Alyssa attempts to use this to compute square roots? Explain.
+#+end_quote
+
+The reason why ~if~ needs a special form is because of applicative-order evaluation.
+Scheme (or rather Racket with the SICP package) interprets with applicative-order evaluation which it means it has to evaluate all of the arguments first before proceeding to evaluate the procedure.
+As ~new-if~ is a procedure that we defined, it would cause an infinite loop of Racket trying to evaluate ~sqrt-iter~ inside of our ~new-if~ procedure.
+
+
+** Exercise 1.7
+
+#+begin_quote
+The ~good-enough?~ test used in computing square roots will not be very effective for finding the square roots of very small numbers.
+Also, in real computers, arithmetic operations are almost always performed with limited precision. This makes our test inadequate for very large numbers.
+Explain these statements, with examples showing how the test fails for small and large numbers.
+An alternative strategy for implementing ~good-enough?~ is to watch how ~guess~ changes from one iteration to the next and to stop when the change is a very small fraction of the guess.
+Design a square-root procedure that uses this kind of end test.
+Does this work better for small and large numbers?
+#+end_quote
+
+For Exercise 1.7, I'm afraid I cannot easily answer it since the results from the example implementation is already accurate due to the interpreter.
+
+For this exercise, let's pretend the interpreter is not great.
+For example, ~(sqrt 0.0001)~ results in ~.03230844833048122~ (should be ~0.01~).
+[fn:: You can test how it really goes with the MIT Scheme interpreter.]
+
+The reason varies from a combination of interpreter, hardware configurations, and implementation of arithmetics.
+This is especially true with floating points arithmetics.
+
+In implementing our improved square root implementation from the question, we start with editing the ~improve~ function.
+
+#+BEGIN_SRC racket  :lang sicp
+(define (square x) (* x x))
+(define (improve guess x)
+  (/ (+ guess (/ x guess)) 2))
+
+(define (good-enough? guess old-guess tolerance)
+  (<= (abs (- guess old-guess)) tolerance))
+
+(define (sqrt-iter guess old-guess x)
+  (if (good-enough? guess old-guess 0.0000001)
+      guess
+      (sqrt-iter (improve guess x) guess x)))
+
+(define (sqrt x)
+  (sqrt-iter 1.0 0.0 x))
+
+(sqrt 4)
+(sqrt 1)
+(sqrt 0.0001)
+(sqrt 0.00001)
+(sqrt 123456789000000)
+#+END_SRC
+
+#+RESULTS:
+: 2.000000000000002
+: 1.0
+: 0.01
+: 0.0031622776602038957
+: 11111111.060555555
+
+I've modified the ~good-enough?~ function by making the tolerance as an argument.
+Tested on the MIT Scheme v10.1.10, the results are more accurate closer to modern systems like Julia.
+Bigger numbers are also calculated quicker than the previous implementation (for some reason that I don't know).
+
+
+** Exercise 1.8
+
+#+begin_quote
+Newton's method for cube roots is based on the fact that if y is an approximation to the cube root of x, then a better approximation is given by the value
+
+
+\begin{equation*}
+    \frac{x / y^2 + 2y}{3}
+\end{equation*}
+
+Use this formula to implement a cube-root procedure analogous to the square-root procedure.
+(In section 1.3.4 we will see how to implement Newton's method in general as an abstraction of these square-root and cube-root procedures.)
+#+end_quote
+
+#+BEGIN_SRC racket  :lang sicp
+(define (square x) (* x x))
+(define (improve guess x)
+  (/ (+ (- x (square guess)) (* guess 2)) 3))
+
+(define (good-enough? guess x)
+  (< (abs (- (square guess) x)) 0.001))
+
+(define (cbrt-iter guess x)
+  (if (good-enough? guess x)
+      guess
+      (cbrt-iter (improve guess x) x)))
+
+(define (cbrt x)
+  (cbrt-iter 1.0 x))
+
+(cbrt 9)
+#+END_SRC
+
+#+RESULTS:
+: 3.000163135454436
+
+
+** Exercise 1.9
+
+#+begin_quote
+Each of the following two procedures defines a method for adding two positive integers in terms of the procedures ~inc~, which increments its argument by 1, and ~dec~, which decrements its argument by 1.
+
+#+BEGIN_EXAMPLE
+(define (+ a b)
+  (if (= a 0)
+      b
+      (inc (+ (dec a) b))))
+
+(define (+ a b)
+  (if (= a 0)
+      b
+      (+ (dec a) (inc b))))
+#+END_EXAMPLE
+
+Using the substitution model, illustrate the process generated by each procedure in evaluating (+ 4 5).
+Are these processes iterative or recursive?
+#+end_quote
+
+For the first definition, the resulting evaluation would have to look something like the following:
+
+#+BEGIN_EXAMPLE
+(+ 4 5)
+(inc (+ 3 5))
+(inc (inc (+ 2 5)))
+(inc (inc (inc (+ 1 5))))
+(inc (inc (inc (inc (+ 0 5)))))
+(inc (inc (inc (inc 5))))
+(inc (inc (inc 6)))
+(inc (inc 7))
+(inc 8)
+9
+#+END_EXAMPLE
+
+Based from the visualization, it seems it is a recursive process.
+
+As for the second definition, the resulting evaluation would look like the following:
+
+#+BEGIN_EXAMPLE
+(+ 4 5)
+(+ 3 6)
+(+ 2 7)
+(+ 1 8)
+(+ 0 9)
+9
+#+END_EXAMPLE
+
+As each iteration does not result in embedding procedures in one big procedure, I think it is considered as an iterative process.
+
+
+** Exercise 1.10
+
+#+begin_quote
+The following procedure computes a mathematical function called Ackermann's function.
+
+#+BEGIN_EXAMPLE
+(define (A x y)
+  (cond ((= y 0) 0)
+        ((= x 0) (* 2 y))
+        ((= y 1) 2)
+        (else (A (- x 1)
+                 (A x (- y 1))))))
+#+END_EXAMPLE
+
+What are the values of the following expressions?
+
+#+BEGIN_EXAMPLE
+(A 1 10)
+
+(A 2 4)
+
+(A 3 3)
+#+END_EXAMPLE
+
+Consider the following procedures, where A is the procedure defined above:
+
+#+BEGIN_EXAMPLE
+(define (f n) (A 0 n))
+
+(define (g n) (A 1 n))
+
+(define (h n) (A 2 n))
+
+(define (k n) (* 5 n n))
+#+END_EXAMPLE
+
+Give concise mathematical definitions for the functions computed by the procedures ~f~, ~g~, and ~h~ for positive integer values of $n$.
+For example, ~(k n)~ computes $5n^2$.
+#+end_quote
+
+For the sake of completeness, here is the function in question along with the given example usage (and its results in the following block):
+
+#+BEGIN_SRC racket  :lang sicp
+(define (A x y)
+  (cond ((= y 0) 0)
+        ((= x 0) (* 2 y))
+        ((= y 1) 2)
+        (else (A (- x 1)
+                 (A x (- y 1))))))
+
+(A 1 10)
+(A 2 4)
+(A 3 3)
+#+END_SRC
+
+#+RESULTS:
+: 1024
+: 65536
+: 65536
+
+As for notating ~f~, ~g~, and ~h~ into mathematical definitions:
+
+- ~f~ is $2n$.
+- ~g~ is $2^n$.
+- ~h~ is $2^{n}^{2}$.
diff --git a/20200627183140-when_reading_mathematical_texts_write_down_the_simplest_possible_example.org b/20200627183140-when_reading_mathematical_texts_write_down_the_simplest_possible_example.org
new file mode 100755
index 0000000..05f2a81
--- /dev/null
+++ b/20200627183140-when_reading_mathematical_texts_write_down_the_simplest_possible_example.org
@@ -0,0 +1,15 @@
+#+title: When reading mathematical texts, write down the simplest possible example
+
+
+On practice, writing down the simplest possible examples allows you to get started working on the definitions.
+When you're done with the simplest possible example, you can then start with a more complicated example (relative to the simplest one) until you worked your way to a real mind-boggling example that really made you bang your head to a wall.
+This is one of the foundation to building mathematical intuition.
+
+That said, this habit can mold well into writing [[file:evergreen-notes.org][Evergreen notes]].
+Since you're dealing with the simplest possible examples, you can write easy-to-understand notes which can help you retain information even more.
+This also makes a good transition in writing more complex topics and more complex examples.
+
+On the non-practical side, it is said to be a cultural thing for mathematicians.
+It is an unwritten rule for a reader to immediately write down examples and not pass through the text until they have understood it.
+Providing examples is not an obligation from the author but they may do so for the sake of easier understanding.
+However, to make sure you are paying attention, it is a recommendation that you have to practice this habit.
diff --git a/20200628061924-bidirectional_links.org b/20200628061924-bidirectional_links.org
new file mode 100755
index 0000000..ccbd255
--- /dev/null
+++ b/20200628061924-bidirectional_links.org
@@ -0,0 +1,16 @@
+#+title: Bidirectional links
+
+
+Ever since [[file:roam-research.org][Roam Research]] became a popular option for [[file:note-taking.org][Note-taking]], there has been interest in one of its popular features: bidirectional linking.
+This feature alone allows for a different way of thinking about note-taking — notes are better to be associative instead of hierarchical just like how our brain works.
+It allows for other Roam features such as backlinking and a visual representation of the notes with a graph.
+
+Compared to monodirectional links like in the web, bidirectional links have inherent social awareness: the ability to look back to linked pages.
+With this feature, you can easily form a graph of pages which you can easily establish contextual relationships between them.
+This is a feature that I've often sought after especially for technical websites such as [[https://encyclopediaofmath.org/][Encyclopedia of Mathematics]].
+
+That said, bidirectional links are not a silver bullet.
+If this is implemented on the web today, it would cause a lot of problems — spamming, trollish linking, and the fact you have no control over what pages being linked to your page requiring heavier moderation.
+Hence, this is more suitable for certain situations such as personal wikis (see [[file:create-evergreen-notes-with-a-digital-garden.org][Create evergreen notes with a digital garden]]).
+Certain software such as Mediawiki, Dokuwiki, and Tiddlywiki offer this feature either as a built-in feature or an extension.
+[fn:: Well, most of them have it as an extension.]
diff --git a/20200701231907-information_literacy.org b/20200701231907-information_literacy.org
new file mode 100644
index 0000000..cb58a5c
--- /dev/null
+++ b/20200701231907-information_literacy.org
@@ -0,0 +1,12 @@
+#+title: Information literacy
+
+
+Information literacy is defined as the ability to search information, sort the results, verify for legitimacy, and share the information effectively.
+It is one of the most important universal skills as internet became popular as a method of distributing information causing to often deal with the torrential amount of information.
+
+There are many ways to improve our information literacy including usage of various effective online searching, writing [[file:20200625131209-fleeting_notes.org][Fleeting notes]] for a quick capture system, and finally evaluating your search results with [[file:evergreen-notes.org][Evergreen notes]].
+For an increased output, you can [[file:maintaining-a-digital-library.org][Maintain your own digital library]] and [[file:apply-search-tools-and-techniques-for-your-digital-library.org][Apply search tools and techniques for your digital library]] where you can store your results and freely retrieve them whenever you wish.
+
+Having a sharp information literacy does not only mainly seen in technical fields like in research and academia (e.g., literature reviews, peer reviews) but also on everyday life as well.
+In fact, all of us practice it in some way.
+We use information literacy skills when we research for the laptop that brings the best value to our limited budget, verifying if the online seller is legitimate, or sharing certain information on our social media.
diff --git a/20200706034752-refer_to_advanced_resources_when_skill_building_for_a_solid_short_term_goal.org b/20200706034752-refer_to_advanced_resources_when_skill_building_for_a_solid_short_term_goal.org
new file mode 100644
index 0000000..f3be782
--- /dev/null
+++ b/20200706034752-refer_to_advanced_resources_when_skill_building_for_a_solid_short_term_goal.org
@@ -0,0 +1,13 @@
+#+title: Refer to advanced resources when skill-building for a solid short-term goal
+
+
+When starting out to build a skill like programming, 3D modelling, digital art, or cooking, you can look first for expert-created resources.
+For example, when starting out to 3D model, you can look for speedsculpting videos or a competition that involves many talented people in the industry.
+In programming, you could look for devlogs, highly advanced competitions, or a live coding session.
+You can then store the expert resources in your digital library (see [[file:maintaining-a-digital-library.org][Maintain your own digital library]]) for future references.
+
+The purpose of this is twofold: to serve as a solid short-term goal (as indicated by the title) and to create inspirations for your future projects.
+Other side effects include creating deliberate practice sessions and taking the stakes off to a higher start.
+
+Of course, this does not entirely replace looking out for beginner-friendly resources and communities as an entryway (see [[file:20200701231907-information_literacy.org][Information literacy]]).
+On the other hand, this prevents you from quickly entering tutorial purgatory where you'll be stuck for an indefinite amount of time.
diff --git a/a-good-tagging-system-for-files.org b/a-good-tagging-system-for-files-for-reducing-information-overload.org
old mode 100644
new mode 100755
similarity index 72%
rename from a-good-tagging-system-for-files.org
rename to a-good-tagging-system-for-files-for-reducing-information-overload.org
index e5c21cf..da54874
--- a/a-good-tagging-system-for-files.org
+++ b/a-good-tagging-system-for-files-for-reducing-information-overload.org
@@ -1,4 +1,4 @@
-#+TITLE: A good tagging system for files
+#+TITLE: A good tagging system for files for reducing information overload
 #+AUTHOR: Gabriel Arazas
 #+EMAIL: foo.dogsquared@gmail.com
 #+TAGS: writing note-taking
@@ -6,19 +6,15 @@
 #+OPTIONS: toc:t
 
 
-Digital note-taking is certainly different from traditional note-taking especially nowadays where topics are leaning toward heterogeneity.
+Nowadays, topics are starting to be viewed toward heterogeneity — they are a system of intra-related concepts.
 In my ideal system, topics that seems unrelated can easily link to one another and easily retrieve them whenever I want.
+This should be taken into consideration when we do [[file:note-taking.org][Note-taking]].
+
 Moreover, non-textual files such as images and videos should be included within the retrieval.
 This is ideal especially if you want to create your personal library of various stuff from books, images, videos, etc.
-This will also make [[file:maintaining-a-digital-library.org][digital library maintenance]] way easier as it is one of the top priority to make your library easy to navigate and refer to certain resources (like real-life libraries).
+This will also make [[file:maintaining-a-digital-library.org][Maintaining a digital library]] way easier as it is one of the top priority to make your library easy to navigate and refer to certain resources (like real-life libraries).
 
-
-
-
-* Related notes
-
-- [[file:note-taking.org][Note taking]]
-- [[file:personal-information-management.org][Personal information management]]
+A good tagging system should reduce information overload when we're searching for something.
 
 
 
@@ -26,7 +22,7 @@ This will also make [[file:maintaining-a-digital-library.org][digital library ma
 * What is good tagging
 
 To take advantage of tagging, we must ask what is good tagging.
-Just like how webpages used to fill up SEO metadata with tags [fn:: Tags are ignored by most search engines nowadays because of spam issues.], good tagging allows for easy retrieval of your files.
+Just like how webpages used to fill up SEO metadata with tags [fn:: Tags are ignored by most search engines nowadays because of spam issues, don't be that person who spams a lot of tags.], good tagging allows for easy retrieval of your files to be at the top result when being searched.
 In order to take advantage of it, we must establish good tagging practices.
 
 Stealing from [[https://www.youtube.com/watch?v=rckSVmYCH90][this talk]], the best (personal) practice for tagging include the following.
@@ -44,8 +40,7 @@ I've come across [[https://docs.tildes.net/instructions/hierarchical-tags][how a
   If a subtag are established enough, then you may classify it as a general tag.
 
 Since the above rule is not always applicable for easy retrieval (e.g., publishing as a website in Hugo), the resulting improvised system instead encourages the hierarchical tag to be the whole list itself.
-For example, ~sports.bowling~ should now be composed of two tags, ~sports~ and ~bowling~, and nothing else.
-Most systems should let you order the tags as-is so not much worry there.
+For example, ~sports.bowling~ should now be composed of two tags, ~sports~ and ~bowling~, in that order and nothing else.
 
 This type of tagging does have its problem with searching which can render this system useless.
 For this, a rule of thumb when it comes to searching is that always search with the general tag first before looking into its subtags.
@@ -61,7 +56,14 @@ For text files, most of the lightweight markup languages offer a way to define v
 Taking advantage of comments and/or variables, if applicable, we could create explicit tags/labels.
 
 To create our specific labels, we could format tags in certain ways.
-For example, you could format in ~[[-<NAME>-]]~ (e.g., ~??programming??~, ~;;physics;;~).
+For example, you could format in ~;;<NAME>;;~ (e.g., ~;;programming;;~, ~;;physics;;~).
 This is mostly the same as creating tags in [[https://orgmode.org/manual/Setting-Tags.html][Org-mode with ~+#TAGS~]] or in [[https://gohugo.io/content-management/taxonomies#readout][Hugo SSG with the taxonomy system]].
 
 We can then search through it with tools like [[https://github.com/BurntSushi/ripgrep][ripgrep]] to more sophiscated solutions such as [[https://www.lesbonscomptes.com/recoll/][Recoll]] where it can not only search text files fast but also metadata within certain media files such as audio (e.g., MP3, OGG), documents (e.g., PDF), and images (e.g., PNG, JPG, WebP).
+
+
+
+
+* References
+
+[[https://www.fun-mooc.fr/courses/course-v1:inria+41016+self-paced/info][Reproducible research: principles for transparent science]], Module 1: Lab books and notebooks, Section 5: Finding one's way with tags and desktop search application, retrieved as of June 2020 (2020-06-24)
diff --git a/search-tools-and-techniques.org b/apply-search-tools-and-techniques-for-your-digital-library.org
old mode 100644
new mode 100755
similarity index 87%
rename from search-tools-and-techniques.org
rename to apply-search-tools-and-techniques-for-your-digital-library.org
index f7ec600..31eec14
--- a/search-tools-and-techniques.org
+++ b/apply-search-tools-and-techniques-for-your-digital-library.org
@@ -1,4 +1,4 @@
-#+TITLE: Search tools and techniques
+#+TITLE: Apply search tools and techniques for your digital library
 #+ROAM_TAGS: pim
 
 
@@ -10,7 +10,7 @@ Your future self will thank you later.]
 In order to search effectively, you need to consider [[file:desktop-search-engines.org][Desktop search engines]] that can also search [[file:file-metadata.org][File metadata]].
 This is also great if you consider [[file:maintaining-a-digital-library.org][Maintaining a digital library]] for yourself.
 
-For text files, you can consider [[file:a-good-tagging-system-for-files.org][A good tagging system for files]] that also consider publication to the public (e.g., digital gardens, static site generators).
+For text files, you can consider [[file:a-good-tagging-system-for-files-for-reducing-information-overload.org][A good tagging system for files for reducing information overload]]  that also consider publication to the public (e.g., digital gardens, static site generators).
 
 Creating a search interface is one thing;
 having the ability for retrieving resources is a must especially if your collection is getting big.
diff --git a/computational-processes.org b/computational-processes.org
old mode 100644
new mode 100755
diff --git a/create-evergreen-notes-with-a-digital-garden.org b/create-evergreen-notes-with-a-digital-garden.org
new file mode 100755
index 0000000..1ae9993
--- /dev/null
+++ b/create-evergreen-notes-with-a-digital-garden.org
@@ -0,0 +1,26 @@
+#+title: Create evergreen notes with a digital garden
+#+ROAM_TAGS: @evergreen
+
+
+A [[https://github.com/MaggieAppleton/digital-gardeners][digital garden]] is a your space for creating carefully crafted notes (see [[file:evergreen-notes.org][Evergreen notes]]).
+Unlike a traditional blog where it concerns the final output, a digital garden cares more on the process of creating notes even if it's incomplete.
+Your notes will start as a seedling, then grow as you develop more insight, and turn into a fully-developed [[https://notes.andymatuschak.org/Evergreen_notes][evergreen note]].
+Examples of a digital garden includes [[https://notes.andymatuschak.org/][Andy Matuschak's]], [[https://maggieappleton.com/garden][Maggie Appleton's]], and [[https://www.mentalnodes.com/][Anne-Laure De Cunff's]].
+[fn:: In other words, a digital garden is a properly developed wiki.]
+
+There are many ways on creating a digital garden but here's my ideal type of a digital garden:
+
+- Features [[file:20200628061924-bidirectional_links.org][Bidirectional links]] between notes as well as listing referenced notes at the bottom.
+- Focuses on creating a graph of evergreen notes that can easily interrelate to one another.
+- Composes of different notes of different maturity level: either an incomplete seedling of a note, a partially complete note, or a fully-developed evergreen note.
+- Sports a [[file:note-taking.org][Note-taking]] workflow along with an easy-to-publish workflow (e.g., web, a set of PDF documents).
+- Easily creates evergreen notes for technical concepts so that I can easily linked concepts common to resources (e.g., books, courses, documents).
+
+The idea of a digital garden is mainly inspired from [[file:roam-research.org][Roam Research]] along with the focus for bidirectional linking and evergreen notes.
+
+There are many ways to start creating one but here's my take on it.
+An entry to the digital garden is created first as a fleeting note (or transient note) to be stored in your writing inbox.
+The writing inbox should not interrupt your work meaning a quick capture system should suffice (see [[file:20200625123723-write_fleeting_notes_to_free_your_mind_of_recalling.org][Create a writing inbox to store your thoughts]]).
+[fn:: Examples of tool that lets you quickly capture your thoughts include [[https://orgmode.org/manual/Capture.html][Org-capture]] or [[https://github.com/rolandshoemaker/theca][Theca]].]
+When you go back to your inbox to empty it, you can then start to create an evergreen note with it.
+If the concept of the fleeting note is not interesting enough to warrant a permanent note, feel free to archive or delete it.
diff --git a/desktop-search-engines.org b/desktop-search-engines.org
old mode 100644
new mode 100755
index 57fa4cb..07bfd3e
--- a/desktop-search-engines.org
+++ b/desktop-search-engines.org
@@ -1,20 +1,18 @@
-#+title: Desktop search engines
+#+title: Add a desktop search engine for your digital library
 
 
-With text files and a version control system in place, it is mostly complete.
-However, it's missing (or just lacking of) the retrievability of our notes.
-Fortunately, we can easily add that with a desktop search engine (which further highlights the modular aspect of our setup).
+Desktop search engines adds a crucial thing for [[file:maintaining-a-digital-library.org][Maintaining your own digital library]]: retrievability.
+With the ability to search and retrieve for information scattered throughout our files, we can then quickly connect and add information without much burden.
 
-As hinted from the module, an ideal desktop search engine can handle the following things:
+An ideal desktop search engine should have the following things:
 
 - Features both a graphics user interface (GUI) and a command-line interface (CLI).
-[[file:file-metadata.org][File metadata]]- Accepts not only plain-text files but other file formats such as images, videos, and audio.
-- Quickly searches through text and even metadata for binary files.
-- Integrates popular formats well.
+- Accepts not only plain-text files but other file formats such as images, videos, and audio.
+- Quickly searches through text and even [[file:file-metadata.org][File metadata]] for binary files.
 - Invites integration (and extension) with an API allowing for more control and features.
 - Highlights searching with a query language that is both simple and powerful.
 
-Among the recommended desktop search engines from the course, I found [[https://www.lesbonscomptes.com/recoll/][Recoll]] that fits the bill with the added bonus of being a cross-platform tool and easily configurable.
+With a cursory search, I found [[https://www.lesbonscomptes.com/recoll/][Recoll]] that fits the bill with the added bonus of being a cross-platform tool and easily configurable.
 
 A desktop search engine like Recoll and DocFetcher uses index-based searches which enables them to search quite fast.
 In order to achieve Google Search-level of search speed, you have to build an index based from the contents of the directory.
diff --git a/evergreen-notes.org b/evergreen-notes.org
new file mode 100755
index 0000000..aad08fc
--- /dev/null
+++ b/evergreen-notes.org
@@ -0,0 +1,28 @@
+#+title: Evergreen notes
+
+
+My concept of evergreen notes is mainly inspired from [[https://notes.andymatuschak.org/z4SDCZQeRo4xFEQ8H4qrSqd68ucpgE6LU155C][Andy Matuschak's version]] in a way that focuses writing evergreen notes as a way of developing your knowledge.
+As said from his note, an evergreen note focuses on evolving and being dynamic.
+It should be taken with you as you develop more perspectives and more insight between a graph of concepts.
+As such, with evergreen notes, you'll be doing more editing than creating as the web of notes widens.
+
+An evergreen note should have the following principles:
+
+- [[https://notes.andymatuschak.org/z4Rrmh17vMBbauEGnFPTZSK3UmdsGExLRfZz1][Evergreen notes should be atomic.]]
+- [[https://notes.andymatuschak.org/z6bci25mVUBNFdVWSrQNKr6u7AZ1jFzfTVbMF][Evergreen notes should be concept-oriented.]]
+- [[https://notes.andymatuschak.org/z2HUE4ABbQjUNjrNemvkTCsLa1LPDRuwh1tXC][Evergreen notes should be densely linked.]]
+- [[https://notes.andymatuschak.org/z29hLZHiVt7W2uss2uMpSZquAX5T6vaeSF6Cy][Evergreen notes should form an associative ontology rather than an hierarchical taxonomy.]]
+
+With that said, writing an evergreen note has no absolute rule.
+Furthermore, you shouldn't focus too much on how to write effectively since [[https://notes.andymatuschak.org/z8V2q398qu89vdJ73N2BEYCgevMqux3yxQUAC][most note-taking practices are generally ineffective]].
+Focusing on it is a distraction to the very objective of creating evergreen notes: [[https://notes.andymatuschak.org/z6cFzJWgj9vZpnrQsjrZ8yCNREzCTgyFeVZTb][developing insights]].
+
+To start writing an evergreen note, you could start with your [[file:20200625131209-fleeting_notes.org][Fleeting notes]] and outline the main ideas.
+An evergreen note does not have to be finished within one sitting.
+In fact, it is preferred to build it incrementally, editing the note as you go developing insights.
+(It is previously mentioned that evergreen notes should be taken with you, after all.)
+
+
+
+
+* References
diff --git a/file-encryption-with-gpg.org b/file-encryption-with-gpg.org
old mode 100644
new mode 100755
diff --git a/file-metadata.org b/file-metadata.org
old mode 100644
new mode 100755
index f33bcdc..8b074b5
--- a/file-metadata.org
+++ b/file-metadata.org
@@ -1,7 +1,8 @@
 #+TITLE: File metadata
 
 
-With our desktop search engine in place, we could take advantage of its features that can search with media files as well through its metadata.
+File metadata is one of the most subtle requirements in [[file:personal-information-management.org][Personal information management]] (or at least, that's what I think).
+With the right tools such as desktop search engines (see [[file:desktop-search-engines.org][Add a desktop search engine for your digital library]]), you can quickly retrieve information as well as preserve some of its related information.
 [[https://en.wikipedia.org/wiki/Metadata][Each type of files have different ways of embedding metadata.]]
 
 - Image files such as JPEG or PNG, metadata are embedded in [[https://wikipedia.org/wiki/Exchangeable_image_file_format][Exchangeable image file format]] (EXIF) and you can modify it with various tools such as [[http://owl.phy.queensu.ca/~phil/exiftool/][ExifTool]].
@@ -9,12 +10,13 @@ With our desktop search engine in place, we could take advantage of its features
 - HTML documents contain the [[https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML][~<head>~]] element to store the metadata.
 
 However, modern standards such as [[https://fr.wikipedia.org/wiki/Extensible_Metadata_Platform][Extensible metadata platform]] (XMP) targets unison of creating metadata among media files: images (e.g., MP3, OGG), videos (e.g., MP4, MKV), documents (e.g., PDF).
-It also supports file formats that doesn't support embedding them as a buddy file stored in ~.xmp~.
 Certain search engines such as Recoll and Tracker currently support searching metadata with XMP.
 
-Speaking of media files, some formats allow embedding of metadata for other software to integrate with (e.g., showing of the album and the composer for media players, retrieving camera info from a photograph).
-Certain desktop search engines such as Recoll and DocFetcher can search through the metadata of certain files.
-
 To modify the metadata of a file, certain tools such as [[https://exiftool.org/][Exiftool]] and [[https://www.alfresco.com/][Alfresco]] exists.
-The process of manually adding metadata to non-textual files can be tedious but it may be worth the price if we're trying to retrieve some things especially for note-taking.
+The process of manually adding metadata to non-textual files can be tedious but it may be worth the price if we're trying to retrieve some things especially for note-taking or [[file:maintaining-a-digital-library.org][Maintain your own digital library]].
 This also makes note-taking more dynamic with non-textual files and leverages more attachment to each linked note.
+
+Beware about caring too much on metadata to the point of our metadata takes more space than the data themsevles.
+Cautionary tales such as [[https://en.wikipedia.org/wiki/MS_Fnd_in_a_Lbry][MS Fnd in a Lbry]] have been written about it.
+They are, after all, merely data on data;
+if the referred data does not exist in the first place, might as well as the metadata.
diff --git a/maintaining-a-digital-library.org b/maintaining-a-digital-library.org
old mode 100644
new mode 100755
index 7b8219b..ba91e2c
--- a/maintaining-a-digital-library.org
+++ b/maintaining-a-digital-library.org
@@ -1,19 +1,17 @@
-#+TITLE: Maintaining a digital library
-#+ROAM_TAGS: pim
+#+TITLE: Maintain your own digital library
 
 
 Having your own digital library can be one of the most valuable thing for your life.
 It is flexible in purpose: you can use it as a personal knowledge base, digital novelties collection, and/or project repository.
-With all things personal, [[file:personal-information-management.org][expect it you should be familiar with a little bit of personal information management]] stuff.
 
 A digital library should have the following features:
 
-- Easy to maintain which is the top priority.
+- Easy to maintain (e.g., modifying [[file:file-metadata.org][File metadata]], adding more digital objects) which is the top priority.
 - Catalog the files using open standardized tools and specifications if available.
 - Provide an easy and reliable search interface with rich metadata.
 
-Instituition libraries such as Internet Archive and ArXiv have are the go-to examples for a long sustaining digital library.
-Personal digital libraries are basically personal information management systems where your resources are stored: documents, notes, references, and media files.
+Instituition libraries such as Internet Archive and ArXiv are the go-to examples for a long sustaining digital library.
+On the other hand, personal digital libraries are basically personal information management systems where your resources are stored: documents, notes, references, and media files.
 
 I have been thinking of creating a digital library for myself.
 These are the tools I've been using for my experiment:
@@ -21,10 +19,11 @@ These are the tools I've been using for my experiment:
 - Zotero as my reference management library.
 - Exiftool for annotating my files with metadata.
 - Recoll as the search interface.
-- Org-Mode with org-roam as my personal wiki/knowledge base and my go-to quick note-taking tool.
+- Org-Mode with org-roam as my personal wiki/knowledge base.
 
 There are a couple of minor things such as Buku as my bookmarks manager, lf as a file explorer, mpv for multimedia, and Firefox as my web browser.
 
+The digital library does not have to be integrated as the established libraries, you just have to loosely connect a system with each of the components of your library.
 My digital library are fragmented with each component located in its own directory (e.g., Zotero data directory is in ~$HOME/Documents/references~, books and documents are at ~$HOME/Documents/books~, wiki at ~$HOME/writings/wiki~) but it is a non-problem for me and it is easy to solve if it's a problem.
 
 
diff --git a/note-taking.org b/note-taking.org
old mode 100644
new mode 100755
diff --git a/org-mode-as-todo-list-manager.org b/org-mode-as-todo-list-manager.org
old mode 100644
new mode 100755
diff --git a/org-mode-babel.org b/org-mode-babel.org
old mode 100644
new mode 100755
index a87583c..c9021e2
--- a/org-mode-babel.org
+++ b/org-mode-babel.org
@@ -4,7 +4,7 @@
 
 
 Org-babel is the framework that enables [[file:org-mode.org][Org-mode]] to insert output of the code from programming languages.
-It is also the one thing that makes Org-mode to be used as a tool for reproducible research.
+It is also the one thing that makes Org-mode to be used as a tool for [[file:reproducible-research.org][Reproducible research]].
 As of 2020-06-08, [[https://orgmode.org/worg/org-contrib/babel/languages.html][Babel supports more than 50 languages]] with the possibility of adding of other languages that are not supported yet.
 
 
@@ -34,13 +34,10 @@ An array will create a table, for instance with ~:results value~ [[https://orgmo
 #+END_SRC
 
 #+RESULTS:
-| Item           | Value |
-| Baseball bat   |   123 |
-| Baseball glove |    25 |
-| Printed shirt  |    42 |
+: None
 
 You can also export graphics with tools such as [[http://gnuplot.info/][Gnuplot]], [[https://www.gnu.org/software/octave/][GNU Octave]], [[https://www.r-project.org/][R]], and even [[https://www.latex-project.org/][LaTeX]].
-With it, you can export the resulting graphical into a file (commonly with ~:file <PATH>~).
+With it, you can export the graphics into a file (commonly with ~:file <PATH>~).
 
 #+BEGIN_SRC gnuplot  :exports both  :file wooosh.png
 unset arrow
@@ -50,6 +47,7 @@ splot x**2+y**2, x**2-y**2
 #+END_SRC
 
 #+RESULTS:
+[[file:wooosh.png]]
 
 With Org-babel, you can share either the output, the code used to generate the output, or both.
 This is commonly set with the ~:exports~ header argument.
@@ -71,10 +69,8 @@ splot x*y with points
 
 * Sessions
 
-Each of the source code block runs in its own session meaning context is basically nonexistent between each block.
-
-What if you want each source block to be connected with each other with all of the variables and functions passed to one another?
-You can simply declare them to be in the same session with ~:session <SESSION NAME>~.
+Each of the source code block runs on an individual session.
+However, you can connect source code blocks (with the supported languages) in the same session with ~:session <SESSION NAME>~.
 
 Let's start with a simple example where we want to demonstrate some Python shenanigans.
 Here's one Python code block.
@@ -85,13 +81,9 @@ print(x)
 #+END_SRC
 
 #+RESULTS:
-: Python 3.8.3 (default, May 17 2020, 18:15:42)
-: [GCC 10.1.0] on linux
-: Type "help", "copyright", "credits" or "license" for more information.
 : 35
-: python.el: native completion setup loaded
 
-After a few explanations later...
+Then here's another code block in the same session.
 
 #+BEGIN_SRC python  :results output  :session python-example
 for i in range(5):
@@ -110,6 +102,8 @@ In certain code where the output can still change (for example, try executing th
 To correct this, simply execute ~org-babel-execute-buffer~.
 
 
+
+
 * Integrating between different programming languages
 
 You can also pass Org-mode variables (from ~#+NAME: <VAR>~) [fn:: Technically called an internal link (https://orgmode.org/org.html#Internal-Links).] into the source code blocks with the ~:var <NAMEC>=<DATA>~ (though, this may vary among Babel runtimes).
@@ -117,16 +111,16 @@ You can also pass Org-mode variables (from ~#+NAME: <VAR>~) [fn:: Technically ca
 #+NAME: example_string
 This is the string.
 
-#+BEGIN_SRC python  :var example=example_string  :outputs value
+#+BEGIN_SRC python  :var example=example_string  :results value
 example
 #+END_SRC
 
 #+RESULTS:
-: This is the string.
+: None
 
 This is the source code from the document, for reference.
 
-#+BEGIN_SRC org
+#+BEGIN_SRC org  :exports code  :results silent
 ,#+NAME: example_string
 This is the string.
 
@@ -138,17 +132,6 @@ example
 ,: This is the string.
 #+END_SRC
 
-#+RESULTS:
-: #+NAME: example_string
-: This is the string.
-:
-: #+BEGIN_SRC python  :var example=example_string  :outputs value
-: example
-: #+END_SRC
-:
-: #+RESULTS:
-: : This is the string.
-
 Org-mode variables does capture an element as its input.
 This has a lot of implications of passing data between different sessions and even different languages.
 
@@ -167,5 +150,4 @@ as.numeric(python_var) + 2
 #+END_SRC
 
 #+RESULTS:
-:
 : [1] 62
diff --git a/org-mode.org b/org-mode.org
old mode 100644
new mode 100755
index c2b24ee..f0d7af8
--- a/org-mode.org
+++ b/org-mode.org
@@ -1,8 +1,5 @@
 #+TITLE: Org-mode
-#+AUTHOR: Gabriel Arazas
-#+EMAIL: foo.dogsquared@gmail.com
 #+TAGS: tools writing
-#+LANGUAGE: en
 
 
 At its core, [[https://orgmode.org/][Org-mode]] is a [[file:personal-information-management.org][Personal information management]] tool that deals with your tasks and schedules.
diff --git a/org-roam.db b/org-roam.db
new file mode 100755
index 0000000..ce29685
Binary files /dev/null and b/org-roam.db differ
diff --git a/personal-information-management.org b/personal-information-management.org
old mode 100644
new mode 100755
diff --git a/precalculus-review.org b/precalculus-review.org
old mode 100644
new mode 100755
diff --git a/references.bib b/references.bib
new file mode 100755
index 0000000..8a67796
--- /dev/null
+++ b/references.bib
@@ -0,0 +1,122 @@
+
+@video{AlanKayLecture2016,
+  title = {Alan {{Kay}} - {{Lecture}}: {{History}} of {{Computers}} \& {{User Interface Images}} \& {{Symbols}} - {{Oct}} 1987},
+  shorttitle = {Alan {{Kay}} - {{Lecture}}},
+  date = {2016-04-18},
+  url = {https://www.youtube.com/watch?v=6ZdxiQoOBgs&feature=youtu.be&t=3080},
+  urldate = {2020-07-06},
+  abstract = {This is part of the University Video Communication - Distinguished Lecture Series on history of computers and human machine interaction. Alan Kay in this lecture goes over the full history of computer with special empahis on first attempts for creating an interactive User Interface and the mouse/keyboard. 
+
+This lecture goes under the title: "Doing with images makes symbols : communicating with computers" which was recorded in Oct 27, 1987 and sponsored by Apple Computers.
+
+For those who do not know - Alan Kay's research and ideas on User Interface Design were the foundation of Apple and Windows.
+
+This is of two vidoe tapes I had laying in my library for many years - since 1994 -  and recently decided to digitize and upload and share.}
+}
+
+@article{beardEBethArkeSyriacDigital2017,
+  title = {The {{eBethArké Syriac}} Digital Library: A Case Study},
+  shorttitle = {The {{eBethArké Syriac}} Digital Library},
+  author = {Beard, Isaiah},
+  date = {2017-01-01},
+  journaltitle = {Digital Library Perspectives},
+  volume = {33},
+  pages = {40--47},
+  publisher = {{Emerald Publishing Limited}},
+  issn = {2059-5816},
+  doi = {10.1108/DLP-07-2016-0017},
+  url = {https://doi.org/10.1108/DLP-07-2016-0017},
+  urldate = {2020-06-25},
+  abstract = {Purpose The purpose of this paper is to review and describe the teamwork, collaboration and learning experiences involved in meeting the unique challenges of establishing a new digital library for Syriac collections. The eBetharké Syriac Digital Library Portal is a collaborative effort between the libraries at Rutgers, The State University of New Jersey, and the Beth Mardutho Syriac Institute, a traditional library of texts, to create a specialized digital library collection online. This digital library features content in and relating to Syriac, an Aramaic dialect spoken in the first century A.D. and for which a great deal of historically significant documents was written during the period. Design/methodology/approach This task required effort and research on multiple fronts, including software development; collaboration on technical, interpersonal and policy-based levels; and in overcoming challenges related to the predominant computing platforms installed and in use by potential users of this digital library. Findings This collaboration provided significant new challenges and learning experiences among the staff who worked on this project and provides a base upon which our digital library platforms can diversify and be more culturally aware. Social implications There have been increasing calls within the academic community for better support in the technological space for this and other contemporary languages of the region. Creation of such a platform and expanding it significantly would benefit scholars of Middle Eastern texts in much the same way digital repositories have revolutionized online text access for the Western world. Originality/value The project is unique in that it is believed to the first production-level, digital preservation-specific Syriac digital library of its kind. It supports the display of metadata and descriptive details for digital library objects not just in English, but in Arabic and Syriac languages as well, where appropriate},
+  file = {/home/foo-dogsquared/library/references/storage/8HCG86JC/html.html},
+  keywords = {Beth Mardutho,Digital library,Institutional repository,Preservation,Rutgers,Syriac},
+  number = {1}
+}
+
+@article{civanBetterOrganizePersonal2009,
+  title = {Better to Organize Personal Information by Folders or by Tags?: {{The}} Devil Is in the Details},
+  shorttitle = {Better to Organize Personal Information by Folders or by Tags?},
+  author = {Civan, Andrea and Jones, William and Klasnja, Predrag and Bruce, Harry},
+  date = {2009-06-01},
+  journaltitle = {Proc. Am. Soc. Info. Sci. Tech.},
+  volume = {45},
+  pages = {1--13},
+  issn = {00447870},
+  doi = {10.1002/meet.2008.1450450214},
+  url = {http://doi.wiley.com/10.1002/meet.2008.1450450214},
+  urldate = {2020-06-22},
+  file = {/home/foo-dogsquared/library/references/storage/L2WJNYJ4/Civan et al. - 2009 - Better to organize personal information by folders.pdf},
+  langid = {english},
+  number = {1}
+}
+
+@online{CreativeScala,
+  title = {Creative {{Scala}}},
+  url = {https://www.creativescala.org/},
+  urldate = {2020-06-22},
+  file = {/home/foo-dogsquared/library/references/storage/7CYJREI4/www.creativescala.org.html}
+}
+
+@online{EvergreenNotes,
+  title = {Evergreen Notes},
+  journaltitle = {Andyʼs working notes},
+  url = {https://notes.andymatuschak.org/Evergreen_notes},
+  urldate = {2020-06-25},
+  file = {/home/foo-dogsquared/library/references/storage/CX538XPI/Evergreen_notes.html}
+}
+
+@online{EvergreenNotesShould,
+  title = {Evergreen Notes Should Be Concept-Oriented | {{Evergreen}} Notes Should Be Atomic | {{Evergreen}} Note Titles Are like {{APIs}}},
+  journaltitle = {Andyʼs working notes},
+  url = {https://notes.andymatuschak.org/Evergreen_notes_should_be_concept-oriented?stackedNotes=z4Rrmh17vMBbauEGnFPTZSK3UmdsGExLRfZz1&stackedNotes=z3XP5GRmd9z1D2qCE7pxUvbeSVeQuMiqz9x1C},
+  urldate = {2020-06-23},
+  file = {/home/foo-dogsquared/library/references/storage/HU2ZC9ST/Evergreen_notes_should_be_concept-oriented.html}
+}
+
+@article{galanterWhatGenerativeArt,
+  title = {What Is {{Generative Art}}? {{Complexity Theory}} as a {{Context}} for {{Art Theory}}},
+  author = {Galanter, Philip},
+  pages = {21},
+  abstract = {In this paper an attempt is made to offer a definition of generative art that is inclusive and provides fertile ground for both technical and art theoretical development. First the use of systems is identified as a key element in generative art. Various ideas from complexity theory are then introduced. It is noted that systems exist on a continuum from the highly ordered to the highly disordered. Citing examples from information theory and complexity science, it is noted that highly ordered and highly disordered systems are typically viewed as simple, and complex systems exhibit both order and disorder. This leads to the adoption of effective complexity, order, and disorder as organizing principles in the comparison of various generative art systems. This inclusive view leads to the somewhat surprising observation that generative art is as old as art itself. A number of specific artists and studies are discussed within this systems and complexity theory influenced paradigm. Finally a number of art theoretical questions are introduced to exercise the suggested generative art definition and implicit paradigm.},
+  file = {/home/foo-dogsquared/library/references/storage/QXUELZE8/Galanter - What is Generative Art Complexity Theory as a Con.pdf},
+  langid = {english}
+}
+
+@online{InformationLiteracyUser2014,
+  title = {The {{Information Literacy User}}'s {{Guide}}: {{An Open}}, {{Online Textbook}}},
+  shorttitle = {The {{Information Literacy User}}'s {{Guide}}},
+  date = {2014-04-04T18:20:08+00:00},
+  journaltitle = {Open SUNY Textbooks},
+  url = {https://textbooks.opensuny.org/the-information-literacy-users-guide-an-open-online-textbook/},
+  urldate = {2020-07-01},
+  abstract = {Good researchers have a host of tools at their disposal that make navigating today’s complex information ecosystem much more manageable. Gaining the knowledge, abilities, and self-reflection necessary to be a good researcher helps not only in academic settings, but is invaluable in any career, and throughout one’s life. The Information …},
+  file = {/home/foo-dogsquared/library/references/storage/8YJDMZEN/the-information-literacy-users-guide-an-open-online-textbook.html},
+  langid = {american}
+}
+
+@online{JuliaCliCalculator,
+  title = {Julia as a Cli Calculator},
+  url = {https://krasjet.com/rnd.wlk/julia/},
+  urldate = {2020-06-22},
+  file = {/home/foo-dogsquared/library/references/storage/8AGYC43A/julia.html}
+}
+
+@book{kunProgrammerIntroductionMathematics2020,
+  title = {A Programmer's Introduction to Mathematics},
+  author = {Kun, Jeremy},
+  date = {2020},
+  edition = {2},
+  url = {https://pimbook.org/}
+}
+
+@book{robinsonTextMining,
+  title = {Text {{Mining}} with {{R}}},
+  author = {Robinson, Julia Silge {and} David},
+  url = {https://www.tidytextmining.com/},
+  urldate = {2020-06-15},
+  abstract = {A guide to text analysis within the tidy data framework, using the tidytext package and other tidy tools},
+  file = {/home/foo-dogsquared/library/references/storage/BANUJYQE/www.tidytextmining.com.html},
+  keywords = {data-mining}
+}
+
+
diff --git a/reproducible-research-principles-for-transparent-science.org b/reproducible-research-principles-for-transparent-science.org
old mode 100644
new mode 100755
index 41381c1..02ae454
--- a/reproducible-research-principles-for-transparent-science.org
+++ b/reproducible-research-principles-for-transparent-science.org
@@ -62,7 +62,7 @@ Examples include Markdown, Asciidoctor, Org-mode, and reStructuredText.
 
 ** Search tools and techniques
 
-I've created a dedicated note (see [[file:search-tools-and-techniques.org][Search tools and techniques]]) on this as derived from this course.
+I've created a dedicated note (see [[file:apply-search-tools-and-techniques-for-your-digital-library.org][Search tools and techniques]]) on this as derived from this course.
 
 With digital files comes digital tools (and some techniques) to help us in searching for our notes.
 These can vary from complex technologies to simple format-agnostic techniques that can make querying files with specific information to be a breeze.
diff --git a/reproducible-research.org b/reproducible-research.org
old mode 100644
new mode 100755
diff --git a/roam-research.org b/roam-research.org
old mode 100644
new mode 100755
index 73ac759..99c0b5d
--- a/roam-research.org
+++ b/roam-research.org
@@ -1,16 +1,20 @@
 #+TITLE: Roam Research
 
 
-Sports the following features:
+Roam Research is a newly developing tool created by Conor White-Sullivan that focuses on creating a graph of notes instead of the traditional hierarchical system of most note-taking systems.
+It is largely inspired from the Zettelkasten method with the emphasis for bidirectional linking.
+
+It sports the following features:
 
 - Backlinking of notes which are then used for creating a graph of related topics.
 - A quick capture system for mobile experience (though it's not complete).
 - A daily notes system, making this viable as a journal as well.
 
+As such, Roam is a solid [[file:note-taking.org][Note-taking]] system that easily integrates as a [[file:personal-information-management.org][Personal information management]] system.
+With the Zettelkasten-inspired system, you can use it to easily [[file:create-evergreen-notes-with-a-digital-garden.org][Create evergreen notes with a digital garden]].
+[fn:: Well, it is a glorified wiki with the focus for backlinks and knowledge graph.]
 
+Roam is gaining popularity and more are considering to use it.
+However, it is closed source and thankfully open source alternatives like [[https://github.com/jethrokuan/org-roam][Org-roam]], [[https://github.com/andjar/dokuroam/][Dokuroam]], and [[https://github.com/athensresearch/athens][Athens]] started to fill our Roam-voided hearts.
 
-
-* Related notes
-
-- [[file:note-taking.org][Note-taking]]
-- [[file:personal-information-management.org][Personal information management]]
+For seeing how Roam works, you can see the following videos by [[https://www.youtube.com/watch?v=RvWic15iXjk][Nat Eliason on using Roam to quickly outline an article]] and [[https://www.youtube.com/watch?v=vxOffM_tVHI][Thomas Frank covering the feature set of Roam]].
diff --git a/text-encoding-initiative.org b/text-encoding-initiative.org
old mode 100644
new mode 100755
diff --git a/the-overview-of-a-programming-environment.org b/the-overview-of-a-programming-environment.org
old mode 100644
new mode 100755
diff --git a/threeeeeeD.png b/threeeeeeD.png
new file mode 100755
index 0000000..99340cf
Binary files /dev/null and b/threeeeeeD.png differ
diff --git a/wooosh.png b/wooosh.png
new file mode 100755
index 0000000..4f9801c
Binary files /dev/null and b/wooosh.png differ
diff --git a/writing-clean-code.org b/writing-clean-code.org
old mode 100644
new mode 100755