Brief overview of today's class:

• talked about arrays and linked lists, singly, doubly, etc.
• each item in a list is considered a node
• a singly linked list goes in one direction and loops back after the entire list has been run through
• the doubly linked list has two pointers that connect two nodes together

Build List for project:

• display
• insert
• append
• obtain
• clear
• quit

Today we talked about the importance of base conversions. It would be wise to memorise bases of 2,3,8,16 etc.

Pointers.

Pointers allow us to access data by referencing it. All pointers have three characteristics, Which is name, address, and contents.

when you use the & symbol in front of the pointer, you are referencing the address of the pointer.

Today we talked about different versions of linked lists, such as chain loops, grid structures, and regular loops.

When we are creating and manipulating lists, we make use of several common functions. These are as follows:

• input - append
• add - insert
• remove - obtain
• output - display
• create
• copy
• clear
• setpos
• getpos
• find
• swap
• sort
• compare

These functions will be implemented in the projects to come, and will build upon each other.

Cable management. Who would've thought it could be as complex and as important as this? Setting up the pods was the easy part. Organizing all the various cables that go along with them is the slightly more challenging part. Each of us tackled a different pod, and used twist ties and tape in order to tame the mess that was the inner part of the tables. This in itself brought up yet another problem. Since we had no unified plan, and we all had different ideas as to how the tables were to be organized, we ended up with four different styles of management. I took the route that traded a clean space behind the monitors for a clean floor that wouldn't suffer from foot interference. I believe that this was the optimal route, but each version had its perks. I personally think that there should be a class on this.

In today's data structures class, and continued to go over the SLN0 project and the debugger known as GDB.

A segmentation fault is basically a runtime error. This happens when a program tries to access a part of memory that we don't have access to, or simply doesn't exist.

In order to use the debugger, you run make and then make debug. This compiles the program with debugging symbols that can be interpreted by the debugger.

In order to view where your program interacts with the unit tests, you can add a breakpoint that stops the code when it hits your program.

When you hit enter, gdb repeats the last command that was run.

Step is also a very useful tool that goes through the programs and their interactions step by step, allowing you to pinpoint the errors.

Continue goes from breakpoint to breakpoint.

This week we are wrapping up SLL2. This project brought about some new things that we had not used currently. One of these things would be a double pointer in the obtain.c file. While seemingly daunting at first, the double pointer basically means that the node pointer (thatNode) is pointing to another node (tmp). This is done so that we can declare a variable for the node that we want to obtain, and then grab it with the use of thatNode.

This past week was rather exciting in HPC. I had the opportunity to play around with a bare-bones touch panel and OpenBSD. The side project came about when we were discussing the idea of creating an interactive thing of sorts for students to toy with outside of in the hall. We discussed having the video wall placed outside with a touch panel on each monitor and doing some sort of a huge game of tic tac toe or something. The only issue with that at the moment right now is that we don't currently have the video wall at our disposal, (its in the old lair) and we also don't have 8 more 15“ touch panels to configure. So for now, we were able to configure just one as a proof of concept model. I'm now working on a simple html program to implement a tic tac toe game. Things are coming along, but I'm quickly realizing that an html and java mix aren't the best option when it comes to making games. However, I'm invested, so lets see where this goes.

Woo! First week of November complete! This week, we discussed the tic tac toe game in datacomm. However, as opposed to making the bare bones program, we instead attempted to figure out the math behind tic tac toe. By doing this, we essentially are trying to “solve” tic tac toe for each possible win. In simpler terms, we are trying to get a single standalone equation that, when executed, all the possible win combinations will come out. It is rather fascinating. The grid of the game is a 3×3, looking like this if you were to number each cell:

0 1 2

3 4 5

6 7 8

It can be seen right away that there are patterns with each possible win. Going horizontally, each row goes up by 1. Vertically, each row goes up by 3. Left diagonal is by 4, while the right diagonal goes up by 2. We haven't solved the equation yet, but we got pretty darn close as of late.

This week we concluded the projects of DLL0 and DLL1. The projects were tough, and even though I didn't get all of it, I think my understanding is still improving more and more by the day. My 5+ hour sessions in the lair are mentally taxing sometimes, but I am getting things done and progressing in my understanding of data structures as a whole. In HPC, I am still working with the touchscreen, but I am attempting to implement it with other systems, such as Kodi (XBMC) that is running on a android base. Kyle also got it running with ubuntu in order to play his tic tac toe game he made in java. Which is pretty kickass, I must say. Tyler's iteration of the game in c is pretty awesome as well. Seeing a graphical application in the terminal is quite impressive. Makes my html/java application look rather lame… However, it's a work in progress. Hopefully we will be able to get the touchscreen out in the hall sooner than later.

This past week in HPC, I attempted to make an informational page in html. The goal is to have a single page that everyone in the lair can use as a one stop destination for stats relating to classes, system info, news and weather. I have a brief background in html, and I wanted to expand upon this knowledge with this project by creating something useful by using a combination of html, css, javascript, and bash. So far, I have created a basic page so far that has 6 subsections. In order to display stats from the lair, such as how many people are online, what the uptime is and etc, I created a simple bash script that took the output of a command and exported it as a text file into the public_html folder. From there I was able to grab the file and display it using the html side of the program. I set the page to refresh every minute, and every 5 minutes a cron job executed the bash script that would overwrite and update the text file in the public_html folder.

This past week in data structures, we completed our final projects of DLS0 and DLQ0. There is one week left of regular classes, with the release of the EoCE imminent. Things seem to move by extremely fast, and its amazing to think that we've done so much in such a little time. With these last two projects, I have gained a better knowledge of stacks and queues and how they work. I have also began to understand how these sort of structures play out in nature all around us. It is beginning to make sense as to what sort of scenarios that these things would be used in. Overall knowledge-wise, its amazing how far we've come since the beginning.