CST 363 - Week 4

 Hey everyone!

As I reach the halfway point in my database course, I've gained valuable insights into the world of databases. Here are five key things I’ve learned so far:

1. Database Fundamentals

Understanding the basics of databases has been crucial. I've learned about the differences between relational and non-relational databases and how data is structured within them. This foundational knowledge has set the stage for deeper exploration into database management.

 2. SQL Queries

One of the most practical skills I've developed is writing SQL queries. From manipulating data with commands like SELECT, INSERT, UPDATE, and DELETE to filtering and sorting data, mastering SQL has empowered me to interact with databases effectively.

3. Normalization

Exploring the principles of database normalization has been enlightening. I now understand how to organize data efficiently, eliminate redundancy, and improve data integrity, all of which are essential for maintaining a robust database.

 4. Table Structures

I’ve gained insights into different table structures, such as heap tables, sorted tables, and hash tables. Understanding their advantages and limitations, particularly in relation to performance and data retrieval, has enhanced my comprehension of how databases operate.

 5. Data Relationships

I've learned about the different types of relationships between data, such as one-to-one, one-to-many, and many-to-many. Understanding these relationships is essential for designing databases that accurately reflect the connections between different entities.


Despite the progress I’ve made, several questions remain:

1. Indexing: How do different indexing strategies affect query performance, and what are the trade-offs involved in creating indexes?

2. Data Security: What are the best practices for ensuring data security and privacy in databases, especially when dealing with sensitive information?

3. Database Scalability: What approaches can be used to scale a database effectively as the amount of data and user load increases?


As I continue this journey, I look forward to delving deeper into these topics and enhancing my understanding of database systems. The knowledge I’ve gained so far is just the beginning, and I’m excited about the learning that lies ahead!

Comments

Post a Comment

Popular posts from this blog

CST 334 - Week 6

 Hey everyone!      This week we submitted our research collab project. It was quite interesting and fun. I learned a lot and our team bonded more as well. We also learned many new things through our lectures and labs.       Concurrency is a critical concept in computer systems, enabling multiple processes to execute simultaneously. However, with great power comes great complexity.       A semaphore is a synchronization primitive that helps manage access to shared resources in a concurrent environment. Semaphores can be thought of as counters that control the number of processes allowed to access a resource. They come in two main types :             - Counting Semaphores : These can have values greater than one and are often used to manage a   pool of resources, such as threads or connections.           - Binary Semaphores : These function like locks and c...
Read more

CST 334 - Week 4

Hey everyone!       This week, I learned about how operating systems manage memory, which is one of their most important jobs. One topic was free space management , where the system keeps track of memory or storage that isn’t being used. Two common methods are bitmaps (using bits to mark if memory is free or taken) and linked lists (connecting free memory blocks together). Each method has its pros and cons, like how much space they use or how fast they work.      I also studied paging , which splits memory into small chunks called pages. These pages are mapped to physical memory, keeping processes separate and organized. However, this mapping can slow things down because the computer has to translate addresses often. To make it faster, Translation Lookaside Buffers (TLBs) store recent translations in a small, quick cache. I also learned about advanced page tables , which are smarter ways of organizing these mappings to save memory.    ...
Read more

CST 370 - Week 1

 Hey everyone, This week, we learned several important topics that form the foundation of computer science and programming. We started with GitHub and practiced using manual commands like git init, git add, git commit, and git push to manage our code. This helped us understand version control and how to keep track of changes when working on projects, especially when collaborating with others. We were also introduced to algorithms and learned what they are—step-by-step methods for solving problems. One example we focused on was Euclid’s Algorithm for finding the greatest common divisor (GCD) of two numbers. It uses a simple but powerful idea: repeatedly replace the numbers with GCD(b, a % b) until the second number becomes zero. We also practiced writing pseudocode, which helped us plan out algorithms in plain language before coding. We also had a homework assignment to help us further understand GitHub commands. Later in the week, we learned about graphs, both weighted and unweight...
Read more