Backstory

Recursion has been very difficult for me to understand ever since I took my data structures and algorithms class, all the way up to the start of my Fall 2024 semester. When watching YouTube videos on recursion and explanations of examples, the solutions and ideas made sense, but the concept was still difficult to apply to problems I had never seen before. I’d fall into the trap of thinking about every single recursive call and get lost when trying to follow my own code.

I’ve also found that many videos and articles explaining recursion use very simple examples like Fibonacci, which are great introductions but fall short in helping people generalize the concept.

After spending over 100 hours using a functional language (Scheme), where you can only use recursion and have to prove why functions are correct, I want to share my insights and hope readers find them helpful in understanding recursion better.

What to Expect

I’ll start by explaining how to recognize when recursion is needed and the purpose it serves. If you understand why your problem requires recursion, solving it becomes much simpler. I’ll then discuss the thought process for solving recursive problems and finally walk through three moderately challenging examples to really drive the concept home.

I won’t go into theory or topics like recurrence relations in depth, though they might be implicitly discussed.

When to Use Recursion

It usually becomes clear that recursion is needed when you notice a pattern of “going down one path” or when you can identify smaller components that build up to the final result. Many combination or permutation problems typically use recursion as well.

What does “going down one path” mean? It means you’re exhausting one direction until you can’t go any further, and then doing the same for the next direction. You’re essentially going depth-first and repeating the same pattern. When you see yourself solving the same problem repeatedly, you likely need recursion.

The less obvious clue is identifying the sub-problem: being able to recognize a simpler version of the problem. Usually, it’s something like, “Would having the result of the problem with one less than my current position help solve my current position? And for that result, would having one less help? And so on…” Essentially, it’s the same problem but slightly smaller each time.

Identifying the sub-problem makes the entire problem much easier. The purpose of recursion is to break down a big problem into very small parts and then build the solution back up. Understanding what the sub-problem is gives you an idea of what pattern to apply and what possible base cases to use.

Thought Process

Alright so you have a feeling that you have a problem that requires recursion.

Sub problems

The first step is to think about the sub‑problems and decisions you need to make. It varies from problem to problem, but in trees you can see that a tree is composed of smaller trees: a left subtree and a right subtree.

In other cases, you can think of the smaller component as the new value that results from making a decision. In Fibonacci, the smaller components are n − 1 and n − 2, which correspond to two decisions. In LCS (Longest Common Subsequence), the smaller component is the substring of the current string, where you decide which string(s) to break down.

This will become clearer in the examples later on.

Base Cases

Possible base cases are usually the points at which you cannot make any more decisions. For any recursive problem, you are given a limit of some form. If the limit involves an amount of money or a number of items, one base case would be when you exceed the threshold; when you no longer have enough money or items to make a decision. In graphs, the base case occurs when you exit the grid; in trees, it occurs when you reach a null node.

Think about situations in which you can no longer make a decision, or about the smallest possible component for your sub‑problems.

What you return in base cases are important, because the type of data you’re returning needs to be consistent with all your other recursive calls. For example, if you’re returning a list in your base case that holds variables that represent something, your other recursive calls would need to be lists and represent the same thing.

If you know your base cases, creating the recursive calls is a bit easier because you know what you’re aiming to return for them.

Another reason base cases help is that you can think about the call that immediately follows the base case and figure out what logic to apply. If the logic works for the call right before the base case, it should work for every other call.

Assume Recursive Call Works

One of my biggest breakthroughs with recursion was trusting that the recursion will return what I want it to. If you know your base cases and what sub‑problems you’re solving, you shouldn’t have to worry about testing every single call to see whether it returns the correct value.

You can, of course, test your program to verify that you are solving the right sub‑problems and that you have covered all base cases, but you shouldn’t need to test every call.

If you don’t know or can’t trust what the recursive calls are returning, it becomes difficult to handle the current call. In Fibonacci, if you don’t know that a recursive call returns the value at the (n − 1)‑th position, how do you know you need to add it to the other recursive call? If your recursive program returns a list and you don’t know what the list represents, how would you implement logic at the current call that uses this value?

What a value represents is based on the sub‑problems you decided on, so if you can’t trust the recursive call, you should probably re‑evaluate your sub‑problems and base cases.

[Optional] Think about different types of cases for any given position

Some problems require you to execute certain logic based on what value is returned or what your parameter is. Usually there’s a structure of some sort, so you need to handle each component and consider what types of inputs you can run into.

More Tips

Recursion might be hard to grasp because we’re so used to for loops and other iterative approaches. It can help to remember that recursion breaks the input down and then puts the pieces back together. If you’re familiar with stacks, recursion follows the same process: you “iterate,” in a sense, while breaking down the input by adding to the stack. When you hit your base case, you can start popping values from the stack (i.e., returning from recursive calls). In a sense, you’re going backward, similar to unwinding a for loop.

I touched upon typical ways of breaking down inputs earlier, but to put them back together you need to see the results of recursive calls as values you can use in your logic. If it helps, try to think about what values you need at any given call for your problem.

If this section confuses you, feel free to ignore it; I added it mainly to provide insight into how to shift your perspective from iteration to recursion.

Examples

Leetcode Problem: Count nodes equal to average of tree

Given the root of a binary tree, return the number of nodes where the value of the node is equal to the average of the values in its subtree

Understanding Problem

The problem wants you to figure out how many valid nodes there are in a tree. What makes a node valid? Getting the average of all the nodes in a tree, and if the root node is equal to the average, it’s a valid node. A tree is compromised of many smaller trees so you need to compute the average for all sub trees. Looks like a recursion problem 👀

Sub Problems

Since this is a tree we know our sub problems would be a left sub tree and a right sub tree. Now we think, what does our sub problem represent? The problem wants number of nodes that has the root node as the average of the tree, so the sub problem would represent number of nodes that has root node as average in the sub trees.

Base cases

The smallest possible sub problem is when our root node is null, in which case the number of valid nodes is 0. Another base case is when root node is a leaf node, in which case the number of valid nodes is 1.
The issue is we can’t just return the count from a sub tree, because we need to keep track of all the values we traversed on our sub tree so that we can get the average of all nodes in the overall tree for the root. Hence when we go down a sub tree, we need to return the sum and the count of all the nodes in the sub tree.

Hence in the base case, we’d return 3 values, the number of valid nodes, the sum of all nodes, and count of all nodes.

Assume Recursive Call Works

Since we have our base cases, we should try to think of what will we do once we got our base case values. Let’s assume we’re at the call right before a leaf node, and that both our left and right subtrees are leaf nodes. In other problems, if this strategy (thinking in terms of call right before base case) doesn’t apply, you should at least trust what kind of values the recursive call is returning. We know for any given call in this problem, we’d get back a sum, number of nodes, number of valid nodes for all nodes in the sub tree.

Anyways, back to assuming we’re at a call right before base case. The recursive call on the left sub tree returns a sum, number of nodes, and number of valid nodes. Same with the call on the right sub tree.
Now the easy part, figuring out what to do with these values. We already know what we’re supposed to return at each call, so to get the sum of all the nodes in this current tree we need to add the sums from the left sub tree, right subtree, and add our root node value.

To get total number of nodes, we add the number of nodes from left subtree, number of nodes from right sub tree, and add 1 for root node. We then figure out if the root node is a valid node, so we compute the average and check if it’s equal to the root node value. We increment the total number of valid nodes (add total valid nodes from left and right subtrees) if it’s valid, otherwise just return the total number of valid nodes.

Figuring out the logic was straight forward only because we were able to trust that the recursive call returns what we wanted. Having descriptive names helps a lot as well. Also helpful to understand that whatever is being returned from the recursive calls, you need to keep the current call consistent with it when returning.

You can use this tool to follow the calls on an example: Link

def averageOfSubtree(self, root: TreeNode) -> int:
     
    def dfs(node):
        if not node:
            # if null, it's not possible to have valid nodes because
            # there aren't any nodes, which also means no sum either
            return [0, 0, 0] # sum, total nodes, valid nodes
        if not node.left and not node.right:
            # leaf nodes only have one node, which is themselves
            # hence sum is current node value and count is 1
            # leaf node would be a valid node since the average would
            # equal itself hence it's 1
            return [node.val, 1, 1] # sum, total nodes, valid nodes
        # get sum, count, and number of valid nodes in left sub tree
        leftSum, leftCount, leftValid = dfs(node.left)
        # get sum, count, and number of valid nodes in right sub tree
        rightSum, rightCount, rightValid = dfs(node.right)
        # total sum including self
        total = leftSum + rightSum + node.val
        # count of all nodes including self
        count = leftCount + rightCount + 1
        # total number of valid nodes
        totalValid = leftValid + rightValid
        # average of all nodes
        average = total//count
        
        # if average equals root node value, we add 1 to number
        # of total valid nodes
        if average == node.val:
            return [total, count, totalValid + 1]
        else:
            return [total, count, totalValid]

    return dfs(root)[2]

Leetcode Problem: Target Sum

You are given an integer array nums and an integer target. You want to apply one of the two operations to each element in nums , add element or subtract element. Return the number of different ways you can evaluate to target.
For example:
nums = [1, 1, 1] , target = 1
output = 3
Explanation:
1. +1 -1 +1
2. -1 +1 +1
3. +1 +1 -1

Understanding Problem

We have an option to either add or subtract each value within the nums list. The problem requires us to go through every item in the list and make a decision for each one. It seems we need to exhaust every possible combination to find the total number of ways to get to the target.

Some ways to combine the numbers might be:

• add every item
• subtract every item
• add every item, and only subtract the last one
• …and so on.

We can see a pattern here: for each number, we make a choice, and then we move on to the next number and face the exact same kind of choice. That signals we should use recursion.

Sub Problems

Since we process the list one element at a time, our subproblem can be defined by where we are in the list. It needs to find the number of ways to reach the target using the rest of the list given our current sum (that was decided on choosing addition or subtraction). If we know the total number of ways to get to target if we add the current number, and the total number of ways to get to target if we subtract the current number, we can know total number of ways to get to target by adding or subtracting the current number by adding the two values we computed.

Base Cases

What’s the simplest, smallest possible subproblem? It’s when we’ve made a decision for every single number in the nums list. This happens when our index i is equal to the length of nums.

At this point, our path of additions and subtractions is complete. We just need to check if we succeeded.

• If our currSum equals the target, it means this specific combination of + and - was successful. We found one valid way, so we return 1.
• If our currSum does not equal the target, this path was a dead end. It contributes 0 ways to the total.

Assume Recursive Call Works

Now, let’s assume our recursive call works. For any number nums[i] (that isn't a base case), we have two choices. We need to explore both and add up their results.

1. The “Add” Path: We can choose to add nums[i]. Our new sum becomes currSum + nums[i]. We then make a recursive call, dfs(i + 1, currSum + nums[i]), to find out how many ways there are to reach the target using the rest of the numbers, starting from this new state. We trust that this call will give us the correct count for this branch.
2. The “Subtract” Path: We can choose to subtract nums[i]. Our new sum becomes currSum - nums[i]. Similarly, we make the recursive call dfs(i + 1, currSum - nums[i]) and trust it to return the count of valid ways for this branch.

We essentially keep branching from each decision until we’ve gone through every item in the list.

Think of the call right before base case. Lets say when we add the last item, it reaches target and when we subtract, we don’t reach the target. The adding call would return 1 and the subtracting call would return 0. To get total number of ways for this sub-list of just itself (aka a list with only the last number) we get 1 + 0 (totaling the number of ways if we add and number of ways if we subtract).

So total number of ways from our current position (i) is simply the number of ways from the "Add" path plus the number of ways from the "Subtract" path. We're essentially adding up all the valid outcomes from the two branches of our decision tree.

def findTargetSumWays(self, nums: List[int], target: int) -> int:

    def dfs(i, currSum):
        # our only limit is when we iterated through every number 
        # in the list
        if i == len(nums):
            # since we tried every item, we can check if we reached target
            # if we did, that means we found 1 way to get to the target
            if currSum == target:
                return 1
            else:
                return 0

        addSum = currSum + nums[i]
        subSum = currSum - nums[i]
        return dfs(i+1, addSum) + dfs(i+1, subSum)

    return dfs(0, 0)

Max Interior Node

Use cases to write max-interior, which takes a binary tree of numbers
with at least one interior node and returns the symbol associated with an interior node with a maximal leaf sum.
> (define tree-a (interior-node ‘a (leaf-node 2) (leaf-node 3)))
> (define tree-b (interior-node ‘b (leaf-node -1) tree-a))
> (define tree-c (interior-node ‘c tree-b (leaf-node 1)))
> (max-interior tree-b) returns ‘a
> (max-interior tree-c) returns ‘c
The last invocation of max-interior might also have returned a, since both the a and c nodes have a leaf sum of 5.

Understanding the Problem

The image should help with understading what the problem is asking. Essentially there are interior nodes which are made up of leaf nodes or other interior nodes. It holds 3 pieces of information, a letter (to identify it), a left interior/leaf node, and a right interior/leaf node. Out of all the interior nodes in the tree, we want to find the letter associated with the largest sum totaled from adding up all the values in the interior node.

You can already tell this uses recursion because there are smaller components (an interior node is made up of other nodes). We also have to repeat a process at every node.

Sub-Problems

The sub problems are the left and right nodes. If we know what the max value/sum of the left node is and the max value/sum of the right node is, we simply have to add each side together, and compare all the values to get the overall max sum. However, there are a few different cases we can run into and have to handle them accordingly.

Base Case

Since the tree is only made up of interior nodes, the smallest possible case is an interior node with a left leaf node and a right leaf node, which you just add together the values. Technically you can have leaf node as a base case, where it just returns the value, but for my implementation in scheme, it was simpler to have an interior node (with only leaf nodes) as base case.

If you’re wondering what leaf-sum is, it’s just a function that gets the value of the leaf node — makes my life easier to create a function for that simple task in scheme.

Assume Recursive Call Works

The question you want to ask is what are we returning and what does that data represent? We want the max interior node of the whole tree, and we know that the sub problem to this is finding the max interior node of the left interior node of the root and the max interior node of the right interior node of the root (to keep it simple, we can just say left subtree and right subtree).

If we know the max of left subtree, and max of the right subtree, we can figure out what’s the max for the overall tree by comparing the 3 values (left max, right max, and left sum + right sum). However, keep in mind, we don’t want to return the value, we want to return the key itself.

To make this possible, we need to return 3 values at each call. The key, the max sum of the current subtree, and the sum overall of the current subtree. We now know what values to expect from our recursive calls and also what values to return.

The code might look a bit complex due to number of lines, but conceptually it’s pretty simple. We have 4 cases.

The base case, where we have two leaf nodes in the interior node. The max interior node of this interior node is just itself since there are no other interior nodes. We simply add the two leaf node values together to get sum, and return [key, sum, sum] (where the first sum represents max sum, and the second instance of sum represents the total sum).

The second case is when the left subtree is a leaf node and the right subtree is an interior node. Again the logic is pretty simple since we know our right subtree is returning the max sum and the total sum of the right subtree. To find the max interior node at this tree, we add the right subtree total sum and the left subtree (just leaf node value) to get current sum, and see whether right subtree max sum is greater than the current sum. If current sum is greater, we return the current key, and current sum twice (similar to base case). If right subtree max is bigger, we return key of the right subtree max sum, the max sum, and the current sum.

The third case is when the right subtree is a leaf node and the left subtree is an interior node. You do the same thing we did for the second case.

The final case is when both the left and the right subtree are interior nodes. In this case, you need to add the total sum of the left subtree and the total sum of the right subtree to get current sum. Then get the max of left subtree max, right subtree max, and current sum. If right subtree max is the largest, we return the key associated with right subtree max, right subtree max, and current sum. If left subtree max is the largest, we return the key associated with left subtree max, left subtree max, and current sum. Otherwise we return current key, current sum, current sum.

We were only able to figure out the logic easily because we could trust that our recursive calls were returning those 3 values.

Scheme Implementation

(define (max-interior tree)
  (letrec ((helper
  (lambda (tree)
    (cases bintree tree
      (interior-node (key left right)
       (let* ((left-sum (leaf-sum left))
              (right-sum (leaf-sum right)))
         (cond 
           ((and (is-leaf-node left) (is-leaf-node right))
             (list key (+ left-sum right-sum) (+ left-sum right-sum)))
           ((is-leaf-node left)(let* ((right-call (helper right))
                                      (right-max (cadr right-call))
                                      (right-total-sum (caddr right-call)))
                                 (
                                      if (>= (+ right-total-sum left-sum) right-max)
                                   (list key (+ right-total-sum left-sum) (+ right-total-sum left-sum))
                                   (list (car right-call) right-max (+ right-total-sum left-sum)))))
           ((is-leaf-node right)(let* ((left-call (helper left))
                                       (left-max (cadr left-call))
                                       (left-total-sum (caddr left-call)))
                                  (
                                    if (>= (+ left-total-sum right-sum) left-max)
                                   (list key (+ left-total-sum right-sum) (+ left-total-sum right-sum))
                                   (list (car left-call) left-max (+ left-total-sum right-sum)))))
           (else (let* ((left-call (helper left))
                        (right-call (helper right))
                        (left-max (cadr left-call))
                        (right-max (cadr right-call))
                        (left-total-sum (caddr left-call))
                        (right-total-sum (caddr right-call))
                        (current-sum (+ left-total-sum right-total-sum)))
                   (find-max (list key current-sum current-sum)
                       (list (car left-call) left-max current-sum)
                       (list (car right-call) right-max current-sum)))))))
    (else 'ignore)))))
(car (helper tree))))

Python Implementation

def max_interior(tree):
    def helper(tree):
        key = tree.key
        left = tree.left
        right = tree.right
        
        left_sum = getLeafNodeVal(left) # equavalent of leaf-sum in scheme implementation
        right_sum = getLeafNodeVal(right)
        
        # Case 1: Both children are leaf nodes
        if is_leaf_node(left) and is_leaf_node(right):
            total = left_sum + right_sum
            return [key, total, total]
        
        # Case 2: Left is leaf, right is interior
        elif is_leaf_node(left):
            right_call = helper(right)
            right_max = right_call[1]
            right_total_sum = right_call[2]
            current_sum = right_total_sum + left_sum
            
            if current_sum >= right_max:
                return [key, current_sum, current_sum]
            else:
                return [right_call[0], right_max, current_sum]
        
        # Case 3: Right is leaf, left is interior
        elif is_leaf_node(right):
            left_call = helper(left)
            left_max = left_call[1]
            left_total_sum = left_call[2]
            current_sum = left_total_sum + right_sum
            
            if current_sum >= left_max:
                return [key, current_sum, current_sum]
            else:
                return [left_call[0], left_max, current_sum]
        
        # Case 4: Both children are interior nodes
        else:
            left_call = helper(left)
            right_call = helper(right)
            left_max = left_call[1]
            right_max = right_call[1]
            left_total_sum = left_call[2]
            right_total_sum = right_call[2]
            current_sum = left_total_sum + right_total_sum
            
            return find_max(
                [key, current_sum, current_sum],
                [left_call[0], left_max, current_sum],
                [right_call[0], right_max, current_sum]
            )
    
    result = helper(tree)
    return result[0]  # Return just the key

Conclusion

Thanks for getting this far into the reading. I hope the formula to solving a recursive problem and the examples helped in understanding recursion better. It’s still not always easy to create recursive solutions given finding sub problems and base cases aren’t always trivial. Sometimes there are more abstractions, sometimes it’s unclear what the base cases should be, and so on.

However, with most things, knowledge isn’t enough. You need to apply it to new problems and build the intuition.

Good luck, especially to those taking Paradigms at CCNY.

The captain makes a lot of mistakes, that not only makes the journey longer but also causes cracks and tares on the ship. Sometimes he feels the sudden vibration, or a slight decrease in elevation, but it’s not prominent enough for him to make drastic changes.

He patches up the cracks he can find, though patching up a hole may solve the issue of water flowing in, that part would still be vulnerable.

The captain wonders why he continues to make the same stupid STUpid STUPID mistakes. He has a map, a functional ship with everything he needs, and he’s a captain…so logically he believes the only problem lies with him.

Through the journey, he experiences foggy nights, storms, and turbulent seas. Surprisingly, the captain enjoys it, not because there’s some challenge or fun surrounding it, but because he can feel the chaos with all his senses which he cannot do with his inner quarrels.

For some reason, he feels comfort within the turmoil caused by the weather and the sea. Perhaps it gives him a sense of power, being able to sit in a physical manifestation of madness, or maybe he feels thats where he belongs because having sunshine and rainbows doesn’t reflect himself.

It’s a weird quirk that makes him question, what kind of captain likes such things?

The captain’s eyes go dull, with light stretching and the water blurring, not from looking out to sea for so long, but looking within and holding back tears.

Despite the captain’s efforts, he fears the ship might be slowly sinking. Not to the point where it’s noticeable now, but could build up in the foreseeable future.

He has a map, yet he feels the hopelessness of being lost. He’s unsure of what it will take for him to become the captain he longs to be, and only has the dream of his destination to keep him going.

Memories of when he first set out to sea as a captain appears, he was so confident and naive. He believed in himself even though he had no reason to, he felt like he can do anything and figure it out… The cracks in his soul is now too much to bear.

Regardless, he continues to still believe in his ship.

That the ship with all of its cracks and tares will endure, and is headed in the direction of the destination. All the glory is there for him to be taken, and the foolish captain will find out that he wasn’t that foolish after all.

Prologue

Roughly 2–3 weeks ago, I attended a data science hackathon at Georgia Institue of Technology called Hacklytics. My team and I chose the sports track and had plans to have graphs/visualizations that were interactive and Machine Learning technologies to output relevant information.

Given this was a data science hackathon, we didn’t want emphasis on the frontend, however, we also wanted it to look somewhat appealing. One of the prizes was “Best Use of Taipy” and at a glance it seemed similar to a technology we were familiar with, Streamlit. We believed it would be a good chance to try out a new technology, wouldn’t be too hard to implement, and we have more chances at winning.

We were wrong on the second part, the technology was new (so less help available), documentation was difficult to navigate, and unlike streamlit, it wasn’t as intuitive. Hence the motivation to write this article.

Configuration

Installation

Downloading Taipy is simple, run the command pip install taipy and it should be within your environment.

In main.py, you should add the following imports:

from taipy.gui import Gui
import taipy as tp

Themes

light_theme = {
    "palette": {
        "background": {
            "default": "#d580ff"  
        },
        "primary": {"main": "#ffffff"}
    }
}

dark_theme = {
    "palette": {
        "background": {
            "default": "#471061"  
        },
        "primary": {"main": "#000000"}
    }
}

Taipy uses other libraries out there for their own configurations. For themes, they follow Material UI’s practices. These two variables are the parameters for light and dark mode. Background sets the color of the whole background while primary is meant for the text color. I am not too familiar with the Material UI library but for simple cases you can look at this part of the Taipy github to change the theme as you see fit. It gives you a good sense of what you can change and update.

Initializing

app = Gui()

if __name__ == '__main__':
    
    app.run(title="SoccerStatusTech", use_reloader=True, port=3636, light_theme=light_theme, dark_theme=dark_theme)

The first line creates the GUI instance. app.run() tells the program to run Taipy (it seems to be built on top of flask). Title sets the name of the site at the top for your browser, use_reloader doesn’t require you to refresh the page manually when you make changes, then the rest is configuring your theme and port.

Multi-Page Functionality

The intriguing part about Taipy is how it reads instructions through markdown. It’s not the typical markdown where you’re bolding with astrics or highlighting code with backticks, but a different syntax within a markdown file that Taipy reads and outputs on the frontend.

In your repository, create a directory called pages . Within this directory, create the following: root.py root.md and directories for all your pages

Repository
->  main.py
->  pages
    ->  root.py
    ->  root.md
    ->  directories for each page 

Here’s how our group structured ours:

You might be thinking that root.py is the home page, but it’s actually what’s consistent throughout all the pages, like a navbar for instance. I initially neglected the root files but it ended up creating weird user experiences when navigating through the pages.

Within root.py , add the following:

from taipy.gui import Markdown

root = Markdown('root.md')

Markdown essentially reads the instructions from the markdown file. For all your pages, you should have a python file and a markdown file.

For example, for home page, I have a home.py file and a home.md file. In each python file for each page, you should have a the code you put for the root.py file but different variable names and accessing the associated markdown. In home.py , I would have

from taipy.gui import Markdown

home_md = Markdown('home.md')

Finally now to connect all your pages, go to your main.py file add/update the following:

from pages.home.home import home_md
from pages.prediction.predictions import predictions_md
from pages.charts.charts import charts_md
from pages.root import root

pages = {
    '/':root,
    'home':home_md,
    "statistics":charts_md,
    "predictions":predictions_md,
}

app = Gui(pages=pages)

# I added in the variables we created from the python files in pages 
# directory, as well as, the pages dictionary to map endpoints to 
# associated GUI instructions. 

First you should access all the variables you created in your python files in pages.

Like most web apps, I thought the the slash would signify that as being the homepage. To reiterate, it isn’t. Create a pages dictionary, the slash should map to root, the other endpoints naming convention is up to you. Each endpoint should map to their corresponding page / variable.

The last part is to update the initialization of GUI, set pages parameter to your pages dictionary.

Markdown Syntax & More

So far we’ve covered only configuration. We will now touch upon the weird syntax that’s used within markdown.

Navbar & Darkmode

<br/>
<|layout|columns=1fr auto 1fr|class_name=container align_columns_center|
<|part|
**<|SoccerStatusTech|text|height=50px|width=50px|style="font-size: 50px;"|>**
|>
<|part|class_name=align_item_stretch|
<|navbar|class_name=fullheight|>
|>
<|part|class_name=text_right|
<|toggle|theme|>
|>
|>

We used this piece of code in root.md. It’s a mix of XML, HTML/CSS, markdown, and probably some other syntax I don’t know.

• <br/> does a line break
• <|layout|> structures how you want things to be placed. It’s similar to a div or span in css where you have multiple parts and want them in the same row
• similar to html, you want the parts to be within the closed brackets. Weirdly, if you have stuff within setting the element type, you have to end it with |> and not just >
• <|part|> lets the interface know it’s an element of a layout
• columns=1fr auto 1fr|class_name=container align_columns_center is setting css rules for the layout. 1fr means the first part takes up one fraction of available space, and auto adjusts based off content.
• class_name=align_item_stretch and other css properties don’t have dashes, instead it uses underscores.
• For text, <|"your text without quotes go here" |text|height=50px|width=50px|style=”font-size: 50px;”|> , for other configurations you can check documentation
• For navbar, <|navbar|> uses the endpoints from your main.py
• For darkmode/lightmode functionality, <|toggle|theme|> creates a toggle with an icon for dark and light theme
• Make sure you close each property properly

Drop Down, Cards, and Buttons

<|text-center|
<br/>
<|card|
<h3>Choose your team</h3>
<|layout|gap=10px|class_name=container align_center|
<center>
<|{value1}|selector|lov=Arsenal;Aston Villa;Bournemouth;Brentford;Burnley;Wolverhampton;Brighton Hove;Chelsea;Crystal Palace;Everton;Fulham;Liverpool;Luton Town;Man City;Man United;Newcastle;Nottingham;Sheffield Utd;Tottenham;West Ham|dropdown|label=Team 1|>
</center>

<center>
<|{value2}|selector|lov=Arsenal;Aston Villa;Bournemouth;Brentford;Burnley;Wolverhampton;Brighton Hove;Chelsea;Crystal Palace;Everton;Fulham;Liverpool;Luton Town;Man City;Man United;Newcastle;Nottingham;Sheffield Utd;Tottenham;West Ham|dropdown|label=Team 2|>
</center>
|>
<|Generate|button|on_action=button_pressed|class_name=button|
|>

The following code was used in home.md which is the landing page we want users to see, and where we get inputs.

• a card is essentially just a square box that you can place information in. You create a card by having a <|card| at the start and then place the parts within it, ending with |> .
• Dropdown menus are bit more complex where the first value is the name you want to set the selector as so you can access it in your python file. Essentially, your identifier, letting you access the user input from the state. The second value is justselector letting Taipy know it’s a drop down selection, and the third part is your options. lov stands for list of values and you just state the options separated by semi colons. Finally the last part is your label, which is essentially what the user sees before selecting an option.
• Buttons are pretty simple, You start with the button name, in my case, it’s generate . You can have submit, update, add, etc. depending on what your button does and what you want the user to see. Second part is just button letting Taipy know it’s a button, and the third part is on_action which will set off the events you want. You can set on_action equal to anything, like “clicked_button” or “submit”, but in your python file, you’d need a function that starts with the same name.

Graphs, Charts, & Toggles

<|part|render={showToggles}|
<center>
<|{selected_team}|toggle|lov={values}|on_change=toggle_choice|>
</center>
|>
<br/>
<|layout|column=1 1|
<|part|render={showGraphs}|
<|{data}|chart|type=pie|values=Count|labels=Country|title=Percentage of Players by Nationality|>
|>
<|part|render={showGraphs}|
<|{dataframe}|chart|type=bar|x=Season|y[1]=W|y[2]=L|layout={layout}|>
|>
|>
<|part|render={showGraphs}|
<|{allFrame}|chart|mode=lines|x=Season|y[1]=Goals Scored|y[2]=Goals Conceded|y[3]=Points|>
|>

• In the following markdown, I started with a toggle button. First section is the label, basically the text the user sees on the toggle itself. Next is toggle to let the user know that it’s a toggle, and right after is the list of the values (lov). The last section is the on_change.
• The values within curly braces are the names of variables within the state that holds certain information. values is a list that holds two items, team 1 and team 2, selected_team is a new variable defined in the markdown that allows us to access which team was clicked on in python file.

All the charts follow a similar pattern, each one are in a part where they have a parameter called render which lets us know whether to show graph or not. showGraphs is initially False but when a user clicks on a team on the toggle, it’s set to True.

The first section on the chart is the data itself, which could be a dataframe (pandas) or a dictionary with values that are lists. Second section is chart to let Taipy know it’s a chart, third section is the type of chart, so in this instance (below), it’s a pie chart. values , labels, and title are self explanatory.

<|part|render={showGraphs}| <|{data}|chart|type=pie|values=Count|labels=Country|title=Percentage of Players by Nationality|> |>

Other charts follow a similar pattern, though for bar and line graphs you’d have to specify x and y and optionally, label that is defined in python file.

State

I probably should’ve covered this first given how prevalent it is in the code. State is how you get the information from the user interactions on the frontend. When creating a function for an on_change the function has a parameter called state allowing you to access inputs or modifying values.

If you want to define variables in curly brackets , you’d create a variable in the python file and access it in the markdown with curly braces.

Here is the python code for the markdown we looked at earlier.

layout = {
    "yaxis": {
      "side": "left",
      "title": "Games"
    },
    "title": {
        "text" : "Win vs Losses Throughout the Season(s)"
    }
}

dataframe = {"Season":[], "W":[], "L":[]}
allFrame = {"Season":[], "Goals Scored":[], "Goals Conceded":[], "Points":[]}

data = {"Country":[], "Count":[]}
logo = ''
selected_team = ''
def toggle_choice(state):

    state.logo, countries = nationalityChart(state.selected_team, state.response) 

    state.data = {
        "Country": list(countries.keys()),
        "Count": list(countries.values())
    }

    state.dataframe = df[df['Team']==state.selected_team].copy()
    state.allFrame = df[df['Team']==state.selected_team].copy()
    state.showGraphs = True

The layout was defined in python , and was able to get accessed in the markdown within the curly braces.

Within the def toggle_choice(state), we were able to change the interface logic, such as showing data only for the team that was selected, setting a logo for the team, and rendering all the graphs by setting showGraphs to true.

State seems to be something that you can only access within on_change functions , though at the start before you run your application , you’re able to add values to the state so you can access in other pages.

You do so by using GUI.add_shared_variables which allow you to access variables and data across other pages. It’s not technically using state here , since there isn’t anything changing, but makes states easier to manage when user interactions occur.

response = requests.get(API_URL, headers=headers)

value1="select a team"
value2="select a team"

showToggles = False

app = Gui(pages=pages)

values = ['team1','team2']

Gui.add_shared_variables(values, showToggles, response)

Conclusion and Source Code

What we thought would be an easy tool to use , turned out to be difficult and took a long time to figure out how to put it together. The most difficult part was sharing data across multiple pages, such as knowing whether the generate button was pressed or not, which teams were selected, etc. We had to learn the technology as well as build our application at the same time within a constrained amount of time.

For full transparency, I feel that there’s still a lot of gaps in what I know about the library, but I hope what I shared provides some insights or guidance on helping you build your Taipy project.

Github: https://github.com/IshmamF/SoccerStatusTech
Project Showcase: https://devfolio.co/projects/soccerstatustech-fde8

Thank you for reading!

How to Practice PHP :

You can run PHP within W3Schools web editor or find a video tutorial to setup PHP on your editor/compiler on your local computer. Here’s a link to a mac setup I used: https://youtu.be/1ZxKPA2jJvw?si=a4WS2372n0Zf9LfA.

Basic Syntax:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <?php 
        echo "<p>hello world</p>"; 
        // comment 1 line
        # comment 1 line 
        /* comment on 
          multuple lines */ 
        $string = "my fav number is 7";
        echo $string;
        $bool = true;
        $float = 3.21;
        $int = 12;
    ?> 
    <?php $booleanVar = true ?>
    <?php if ($booleanVar) {; ?> // able to apply logic to html
    <p>Hello world</p>
    <?php }; ?>
    <?php 
        // create an array/list 
        $values = [1,3,2,4]; 
        $values2 = array(1,3,2,4);
        // if statements are simple
        if ($values[2] + $values[1] == 3) {
           echo 23;  
        }
        else {
           echo 10;
        }
    ?>
    <p> <?php echo $values[0] /*can access list within html tags*/ ?></p>
</body>
</html>

• PHP opening tags start with <?php> and end with ?> , the echo outputs the strings to the browser (since this is within an HTML template). Sometimes these strings could have html/css instructions within them.
• Instead of echo, you can also use PHP for the logic aspect with html properties within it. The code for a PHP tag trails on the next PHP tag even if there are semi colons.
• Variables in PHP are dynamically typed and start with a dollar sign, meaning you don’t have to explicitly say that it’s an int or a string. Arrays can be called with list comprehension similar to python, with square brackets.
• How to comment is shown in the example code (#, // , /* */ )
• Every line should end with a semicolon
• If the file is pure PHP, then you only need an opening php tag (<?php)

Executing the Code Outputs the Following:

Functions & Loops:

<?php 


function addTwoNums ($x, $y) {
 echo $x . " + " . $y . " = " . ($x + $y) . "<br>";
 return $x + $y;
}

for ($i = 0; $i<10; $i++) {
 echo $i . "<br>";
}

$n = 0;
while ($n < 3) {

  echo $n . "\n";

  $n += 1;
}

echo "<br>";

addTwoNums(4,6);

$fruitColors = [
    "apple" => "red",
    "banana" => "yellow",
    "grapes" => "purple",
    "berries" => "blue",
    "orange" => "orange",
];

foreach ($fruitColors as $fruit => $color) {
    echo "The color of " . $fruit . " is " . $color . "<br>";
}

?>

• Functions are defined by calling function followed by name of function and putting parameters in parentheses.
• Loops are called how you would normally call them in most languages as shown above.
• The foreach loop takes an array and allows you to only get the item without having to use index and access a specific position within array. Within foreach parenthesis , call the array then as then a name you want to call each item as. If it’s a dictionary, you would have to create two variable names , where the first variable is the key and the second variable is the value.
• Somethings to note, to concatinate an integer an a string, use . (period) and to set/use dictionaries in PHP, you use => between a key and a value , within square brackets.

Executing the Code Outputs the Following:

Superglobal Variables:

Super globals are variables that are built in already and allow you to access information about certain things like incoming http requests, user interaction such as uploaded files, session information, etc.

• $GLOBALS — An array of global variables, essentially variables that can be accessed anywhere including within functions and other files.
• $_SERVER — Has information regarding headers, request method, file path, server name, etc.
• $_REQUEST — Contains submitted form and cookie data, it includes $_GET, $_POST, and $_COOKIE.
• $_POST — An array of data that is collected from a POST request. Allows you to access data once a user submits a form (information from a post request).
• $_GET — An array of data that is collected from a GET request. Allows you to retrieve data from user submissions, query parameters, etc.
• $_FILES — An array of items collected from files uploaded via HTTP POST method.
• $_ENV / $_SESSION / $_COOKIE— Variables are self explanatory, they allow you to get the associated information.

<html>
<body>

<form method="POST" action="<?php echo $_SERVER['PHP_SELF'];?>">
<!--$_SERVER['PHP_SELF'] provides file name of the script executing the script-->
  Name: <input type="text" name="fname">
  <input type="submit">
</form>

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") // checks request method used
{
  $name = htmlspecialchars($_POST['fname']); // gets information from POST request
  # htmlspecialchars cleans the string input for html injections 
  if (empty($name)) { 
    // Empty is a built in function
    echo "Name is empty";
  } else {
    echo $name;
  }
}
?>

</body>
</html>

MYSQL Functions:

PHP has MYSQL built into it making accessing the database seamless.

To initialize the database , you use new PDO($datasource, $username, $password) where the variable names have your associated credentials.

To access and use MYSQL functions, you use the arrow notation -> followed by the name of the function you want to use.

prepare checks the syntax for SQL injections and saves it to the server for later use. The question mark is a place holder for a parameter you might want to use to filter your query.

execute carries out the SQL query, and substitutes input values with the question mark.

fetchAll retrieves all the data where the column is an index number and rows are a dictionary/array of the query data. fetch retrieves only one row.

$dbms = new PDO($datasource, $username, $password)
$query = $dbms->prepare("SELECT * FROM files WHERE location = ?")

$locations = $query->execute($_POST['location'])

result1 = $locations->fetchAll(PDO::FETCH_NUM)
result2 = $locations->fetch(PDO::FETCH_NUM)

Any and all feedback are appreciated!

Pro Tips with Ted Sanders, OpenAI

What I Resonated With:

Ted Sanders talks about how he started, and how his background wasn’t out of the ordinary when it comes to coding. He picked up Electrical engineering because it incorporated physics, he learned a little bit of programming in college and during his masters, and from there pivoted into data science at Netflix.

It could be him being humble in the interview since he had awards and scholarships for mathematics (it seems) during college. You do need a level of smarts to pursue a PhD in physics.

Regardless, I relate to his struggles and some parts of his background. He shares how he cried freshmen year when he couldn’t get code to work, how he didn’t really know what he wanted to do, and how he wasn’t some whiz who started young at 16.

Personally I tried a little (VERY MARGINAL) programming when I was in middle school. I recall trying to create shapes and snow mans in Khan Academy in some JavaScript language and there was some mobile app that taught me how to send an alert. It fascinated me, but I got bored of drawing shapes and at the time, I was dealing with the struggles of middle school / life in general. I did some scratch in high school, which honestly, doesn’t “scratch” (pun intended) the surface of programming in my opinion.

I didn’t start truly programming till the second year of college, when I was finally able to take computer science classes (didn’t meet math/science pre requisites prior) and I still don’t know what field of computer science I want to pursue. I did try to do CS50 I think at some point before this but I gave up when I couldn’t do a basic nested loop!

What I’ve Learned and Took Away:

Patience

Hearing about his humble beginnings, it helped me understand what is possible with some time. He wasn’t someone special or super smart during the start of his journey, and yet he found himself in environments that only consisted of super smart or special people. All it took was a decade of learning and some persevering!

Curiosity

He got into AI because he was curious about random things like what's the trajectory of technology or how do we know what’s true. I think his interest with probability and statistics, math, and physics influenced his curiosity a lot. The idea in which what you’ve exposed yourself to, what generally interests you, or philosophical questions you think about can actually connect with unrelated things like technology is interesting.

It seems throughout his journey, he always gravitated towards what looked interesting to him despite not knowing where he would end up — and that helped him land and succeed in roles that are difficult.

AI won’t replace programming or Juniors (maybe)

His main view is that AI will help juniors more than seniors. He does think it’s possible where Seniors no longer need juniors because they have AI to do the trivial / smaller tasks. However, he leans towards more as AI being a tool to help juniors succeed in their roles since they don’t always have to ask seniors for help — they can ask ChatGPT.

He also doesn’t think AI will replace programming altogether, or maybe it might just replace the idea we have of programming, but create more opportunities and fields. For example, in the early days, people would use punch cards and assembly, but now those are pretty much obsolete (in the sense that not a lot of people use it).

It will most likely lead to a position where there’s higher levels of abstraction in terms of giving instructions to computers and fewer lines of code.

Build Skills Complimentary to AI

He says a mistake that most might make is, since there's a lot of hype with AI, people think they should focus on only learning prompt engineering/calling via APIs and AI in general. Instead you should try to learn skills that could be used with AI, but not directly AI.

An example he uses that makes that idea clearer is earlier in the days when electricity was introduced and factories were to take advantage of it. If you’re a shoe factory owner like Nike, electricity could change how the factory is run and other processes but it won’t help you make great shoes. You would have to learn other skills like designing and sales to get the outcome you want.

It looks to me he views AI to be an integral tool and utility of society that could aid big ideas.

Personally I have more of a data science background, and I believe in his sentiment that building skills outside of AI is key to being successful when starting out. I was initially fascinated by what AI could do like predicting the progression of Alzheimer's disease (since my grandma has a form of dementia) and predicting a song based on how similar the lyrics are to your text / the sentiment comparison.

However, despite the cool functionalities of AI, I want to learn more about how I can make it usable to other people, how I can allow users to have more functionality beyond predicting / classifying things — like saving user data for future reference for users, the updating information, deploying, etc.

Learn multiple languages & Rely on ChatGPT if you’re a beginner

He briefly mentions that to be a well rounded programmer you shouldn’t be monolingual because a lot of concepts are repeated across different languages.

I agree with that sentiment, because I officially started out with C++ and it was difficult and learning the fundamentals, I didn’t understand what those concepts achieve. Like when learning math, you don’t know how useful math concepts are because you’re always learning the theory and not the application. I did create small programs but it didn’t do anything interesting.

However, when I switched to python, a lot of the fundamentals carried over, and I was able to learn quickly as well as create data visualizations, predictive models, and scripts that helped solve some issue. Then learning JavaScript, HTML, CSS, Java I found more utility with programming and was able to build some cool apps/websites.

He said ChatGPT is really great for beginners because when starting out you can ask a lot of dumb questions you’d be scared to ask in public. It helps understand the fundamentals and get up to speed.

In my experience, ChatGPT has helped me explain a lot of concepts for me and understand what stupid mistake I made that caused a bug. However, I think a mistake that can be made is using it as a shortcut for programming. I think early on its best to not rely heavily on ChatGPT so you can build that problem solving ability.

Conclusion:

If you’re worried about AI replacing programmers, you shouldn’t, though I think the level of expertise needed is increased. We should focus on building skills that interest us (or profitable ones depending on your situation) that can be boosted with AI. We shouldn’t feel rushed (it’s something I’m still trying to overcome) and continue to persevere through the many obstacles in the tech industry. We might feel a certain way about our abilities right now but in the future, 10 years down the line, we’ll be proud of making the tough choices now, following our curiosity, and building our skills, because we will be in positions that we once thought allowed only unique/special individuals.

Data models are a way to describe information. It’s described through structure (relational model), a limited set of operations that provide programmers the ability to describe at a high level and have management systems that are efficient, and constraints.

Other models are mentioned and spoken in depth like XML but relational models are emphasized more in the chapter.

Relational Models

Relational models consists of structure (basically tables), the operations are associated with relational algebra , and constraints can be anything like last row must have a specific value.

It’s preferred over other models because of ease of use. It provides a simple approach to structuring data, and allows for anything to be modeled. It also provides a limited set of operations.

Terminology:
relation = table
attribute = column
schema = relation + attributes
tuple = row of data in a table
domain = data type
instance = set of tuples
key constraints = set of attributes where no two tuples share the same values

order of tuples and attributes doesn’t impact the relation, though you should update the schema.

Keys:
If you have a set of attributes defined as S and a relation defined as R, two tuples in R cannot have the same attribute values within the set S, unless one of them is NULL. Otherwise it’s not a DBMS

Example:

Relation would be Movies; attributes would be title, year, length, genre; schema would be Movies(title, year, length, genre); tuple would be (Gone with the wind, 1939, 231, drama), and domain could be string for title and genre, while int for year and length. A key constraint can be title and year since you can safely assume that no two movies within the same year will have the same name.

SQL

Pronounced Sequel, allows for describing and manipulation of relational model database.

There are 3 kinds of relations: tables, views (set by a computation), temporary tables. To set datatypes for attributes you use the following mentioned below.

Data Types:
CHAR(n) : fixed length string made up of n characters
VARCHAR(n) : same as CHAR(n) except no padding of blank spaces if it’s smaller
BIT(n) : same as CHAR(n) except it’s a string of bits
BIT VARING(n) : same as VARCHAR(n) except it’s a string of bits
INT or INTEGER : self explanatory
DATE : quoted string of a format YEAR-MONTH-DAY (ex: DATE ‘2003–07–27’)
TIME: quoted string of a format HOUR:MINUTE:SECONDS.MILLISECONDS
(ex: TIME ‘16:26:03.2’)
FLOAT or REAL : floating point numbers
DOUBLE PRECISION : floating point numbers with higher precision
DECIMAL(n,d) : can set real numbers to a fixed decimal point where n is the number of digits and d is the number of positions from the right

CREATE TABLE
When creating table you use the declaration CREATE TABLE followed by relation name and a parenthesis that has attribute name + space + data type, each separated by commas.
ex: CREATE TABLE movie(title VARCHAR(100), year INT)
ex:

DROP TABLE R
Deletes a whole table (where R is the name of a table)

ALTER TABLE
Ability to do the bullet points below
- ADD ATTRIBUTE data type <- create a column/attribute
- DROP ATTRIBUTE <- delete a column/attribute
(ATTRIBUTE should be the name of a column/attribute)
ex:
ALTER TABLE movies ADD date DATE
ALTER TABLE movies DROP date

DEFAULT VALUE:
Replace empty or unknown values with a default/value of your choosing.

To set a default for an attribute that’s already created:
ALTER TABLE relation ALTER COLUMN attribute data type SET DEFAULT value;
ex: ALTER TABLE movies ALTER COLUMN year INT SET DEFAULT 2024

To set a default for a new attribute:
ALTER TABLE relation ADD attribute data type DEFAULT value;
ex: ALTER TABLE movies ADD date DATE DEFAULT ‘2024–01–10’

SET KEYS:
To set the keys for a relation, use either PRIMARY KEY or UNIQUE.

PRIMARY KEY and UNIQUE are pretty much the same thing except when using PRIMARY KEY, none of the values can be NULL.

ex: CREATE TABLE Movies (
title CHAR(100) PRIMARY KEY,
year INT,
genre VARCHAR(10)
) ;

ex: CREATE TABLE Movies (
title CHAR(100) ,
year INT ,
genre VARCHAR(10),
PRIMARY KEY(title,year)
) ;

Relational Algebra

Relational algebra allows you to query data and manipulate it allowing you to create new relations. It’s useful because it’s less powerful compared to programming languages like C or Java making it easy to use and highly optimized. Algebra is a mix of variables and operators that create an expression. In relational algebra, variables are substitute for relations and constants are finite relations.

SET OPERATIONS:
If there are two arbitrary sets, R & S, then…
- Union between R & S is a set with elements in R or S and elements only appear once (if they show up in both)
- Intersection between R & S is a set with elements that are both in R and S
- Difference between R & S, such as R — S, is a set with elements that has elements from R but no elements from S. The opposite is true if it’s S — R.

In order to be able to do set operations both R & S must have the same structure in terms of attributes, data type, and order of attributes.
If corresponding attributes are the same but have different names, you can rename to meet the criteria.

PROJECTION & SELECTION:
Projection operator creates a new relation from a relation that's already made and is a subset of the relation’s attributes. If you had a relation, movies(title,year,genre,rating), a projection could be just genre, where its a set (meaning no duplicates) of the genre column or it could be just title and year.

Selection operator creates a new relation from a relation that’s already made and is a subset of the relations tuples, where the tuples meet a condition. For example, if you had a relation of all movies, but wanted all movies from a certain year, you’d use selection operator.

CARTESIAN PRODUCT:
A set formed by taking set R and set S, and the first element of R is used followed by the first element of S, and then second element of S, and so on. Then taking second element of R, and first element of S, and so on. It’s essentially a union of the tuples of two sets. If there are attributes in common, you need to create new attributes with different names, like R.B and S.B.
Example:

THETA AND NATURAL JOINS:
Natural join is first putting all the attributes from R & S together, they should have an attribute in common. Then on that common attribute if they share common values, you’re able to pair the tuples from set R and set S.

Theta join is first doing the cross product of set R & S, then selecting the tuples that meet a condition.

RENAMING & ADDITIONAL INFORMATION:
It’s usually convenient to rename attributes to make operations easier and/or making the relation easier to understand.

The previous operations mentioned can be used with each other to form queries, and you can have the same query with different combinations of operations such as the intersection of R & S is the same as R — (R-S).

CONSTRAINTS:
Constraints can be used in various ways, such as keys mentioned previously, or asserting that the values in one relation shows up in another relation or domain contraints or even value constraints.
Example:
The following is to constrain the gender values to only be M or F

Through this journey, I hope to not only make sure I fully grasp what I’m reading by teaching/sharing it with the world (aka just the internet), but also hope my insights bring more clarity or knowledge about databases to whoever reads my posts!

Database Management System

For starters, a database is a collection of information that is stored and persists for a period of time.

A database management system (DBMS) enable the creation, querying, modification, and administration of databases. Additionally, also allows for setting a schema (structure/rules), storing large amounts of data over a long period, effectively recovering data, and controlling access.

The earliest forms of commercial DBMS was the file system. Although it supported some functionalities of what makes a DBMS like creation of databases allowing for storage of substantial quantities of information, it was difficult to query complex processes and manage control access, and it had no recovery unless you backed up data.

Many early DBMS faced similar limitations, primarily with querying. Which changed with the introduction of the relational model and SQL.

As companies and projects begin to grow, so does their data and data management. Large organizations tend to have many different database systems, with some being legacy databases.

To deal with the different systems, there are two approaches most companies take:

• Having Data warehouses which adds and stores all the data in one place giving a unified view of all the information.
• Using a middleware/mediator which allows for databases to communicate/share with each other on the fly

In a DBMS, an administrator uses data definition language (DDL) to set rules and structure of how data would look like, formatted, etc…

Storage and Buffers

Storage and Buffer managers are like a library where the vast amount of books in a room is the disk, while the librarian is the storage manager who brings relevant books to someone interested in something and places it on specific part (buffer) on a table (main memory).

Storage managers know where everything is, and it’s role is to move the files from disk to the main memory. The buffer manager’s role is to organize the space on the main memory and ensure there’s a spot for the data, you’re looking for, to go to.

Transactions:

A group of database operations is called a transaction which should pass the ACID test; Automaticity (if one part of the transaction fails, the whole transaction fails, and no changes are made), Consistency (in terms of rules and constraints), Isolation (one transaction does not impact another directly), and Durability (changes can never be lost).

A transaction must log every change (in the event a crash happens), provide concurrency control by having a scheduler that ensures the sub operations of multiple transactions occur in order, and deadlock resolution which is intervene and cancel transactions when no more resources are available.

Query Processing:

The Query Processor in a DBMS helps efficiently execute queries which comprises a Query Compiler that transforms queries into a structured series of operations through parsing (structuring text into a tree), preprocessing (transforms tree into a tree of algebraic operations), and optimization (transforms into best plan for the operations), and an Execution Engine that implements these operations while coordinating with other DBMS components.

It might be because I’m mixing my interest of journaling my everyday with my interest of helping people. So I’ve Decided I’m Going to do my journaling privately, and if I’ve learned something new, found something cool/insightful, gained new experiences, or lived through a challenge that I think could help someone, I’ll Share that here.

I don’t Think anyone’s Reading this right now, and they may never will. One day, though, my writing will lift someone up, give them the vision they need to get through their challenge, and/or carve a genuine smile.

Today was a lot better than the past two days. I’ve been able to hold my focus for a lot longer and indulge in less time waste. It seems the times where I take in a lot of carbohydrates is when my focus drifts. Another thing I need to work on is getting adequate sleep.

5:30 am to 6:00 am I tried to stay awake, and even meditate. I knew if I fell asleep, it would be a big mistake. 6:08 am I left to go pray, came home around 6:40, and then went did 50 pushups and ran until 7:30. From 7:30 to 8, I took a colder shower and moisturized. From 8am to 12pm I was able to stay focused on completing a 1 hour tutorial on a spam classifier. It took the full 4 hours because I was researching what every function and things I didn’t understand, and experimenting with the code a little. It’s also interesting that, even though the tutorial was in Hindi, I was able to understand it. From 12 to 1, I went on my phone, watched a youtube video, prayed, and ate a piece of salmon and a veggie patty. From 1 pm to 6 pm I was working on my Software Design homework, however, I had to take a 30–40 minute nap. From 6pm to 9pm, I joined a call with my group to discuss plans for our project, where we take input about someones day, and predict the emotion of their day, and based off the emotion and the content of their day, we provide songs that are related to it.

There were times, where I had to help my family with groceries or laundry, or one rule I have is that, if I’m tired, I should go for a walk. I don’t regret any of that, so overall it’s been great. It’s interesting I was getting tired after I ate salmon and veggie patty, foods I assumed were low carb and wouldn’t impact my energy levels.

Avoiding carbs till later seems to really help with staying focused. After 9pm I was wasting time and well now here I am talking about.

Many areas I can still improve, though today, I did better than yesterday, and that’s all that matters to me right. I’ll improve everyday, even if it’s slightly.

After that, I helped my sister with her computer science homework and watched some programming videos, and well…. the rest of the day didn’t go as planned. It seems after 7pm ish, it becomes more difficult for me to stay focused or not waste time. Goal is to make 100% efficient use of every second, so I’ll have to do better. I’ll figure something out.