SLOG Entry#10

     Its finally here faithful SLOG readers. My final SLOG entry of this semester. Hope you've all enjoyed yourselves. I know I have. In computer science this week, we talked about how dictionaries were far more efficient in accessing and inserting data then trees. Even sorted trees. This is because dictionaries are basically lists, and in Python, lists have constant access to their elements. The downside to this is that dictionaries may not be sorted. So there is a trade off for the efficiency. The rest of the week was then spent in review for the final exam. That will be interesting. This is my final SLOG entry. Thank you all for reading. Good luck and have fun.

SLOG Entry#9

     Here's another SLOG entry. Its midterm week again. On Monday we covered some more about big-oh, talking about how O(lg n) is the big-oh of a function that cuts a list in half again and again for a certain amount of recursion. Most of the fun was on Wednesday when we had another midterm. It wasn't so bad, and I found it easier then the last midterm. Tune in in next time for more computer science.

SLOG Entry #8

     Here's my weekly SLOG entry. This week, in computer science, we covered some questions about assignment two and learned some new sorts. The sorts we learned were quick sort and merge sort. In quick sort, a pivot is chosen, the list is sorted around the pivot and then each new partition is then also quick sorted. In merge sort, the list is divided in half, each half is merge sorted and then the two halves are joined together. These sorts are more complicated then the sorts we learned before, but they are also quicker and more efficient, as shown when we calculated their big-ohs. Check in next week for more computer science!

SLOG Entry #7

     Well here's another SLOG entry. Sorry for the wait. This week, in the world of computer science, we learned about performance and big oh. Performance basically asks how efficient is a certain function for this task. In our case, it was which sorts take less time. Depending on the type of tests the function is going to be called on, examples being best-case-scenario and worst-case-scenario, each function has a different algorithm that shows it's processing time. These alogriths can be represented by big-oh, or O(y) for y being the complexity of the algorithm. This is useful, as we can compare effeciencies of different functions by comparing different O's. By testing the performance of our sorts, we saw that several were far more effecient then others in the worst-case-scenario. This seems like a useful skill that will be helpful for far larger and more complicated programs, for which a fast performance is vital. That's all for this week.

SLOG Entry#6

     Hello SLOG blog readers. This week in computer science, we looked further in depth into Linked Lists. To restate from last week, Linked Lists are trees with one child and an empty last node. But they can be implemented in two different ways. Linked lists can consist of an item and a link to another Linked list, or an object with a reference to another object. These seem identical, but there's a difference in the semantics. Which in turn, requires different methods of coding in the Linked List class.We also covered Binary Search Trees, trees that are sorted by the values of their objects, making searches quicker and more efficient. It was a fun week. Come back next week for another computer science update.

SLOG Entry#5

     How was everyone's Reading Week? Mine was good. Too short, but good. But now its midterm week. That wonderful time where you have midterms and assignments that you were supposed to have been preparing for last week. Yikes. Well, I did my computer science midterm, and compared to some of my other classes, it wasn't that bad. A lot shorter, that's for sure. But this week wasn't all tests this week. There was also education. Specifically, on Monday we covered Linked Lists, trees with exactly one child  and with the last node being empty. A different way of organizing data, Linked Lists are basically lists in tree form. Lots of fun. That was it for this week. Tune in in next time for more computer science.

SLOG Entry#4

     Greeting to all my SLOG blog readers. This week in computer science, we went over Trees. Not the kind of trees you find outside in a park. The Trees we talked about were a special kind of list. A Tree is basically an object that holds a value and points to some other objects that also hold values and also point to some more objects that hold values and so on. We talked about simple Trees, called Binary Trees as each object only pointed to up to two other objects, as they were the easiest to work with. We went over all the terminology one uses when working with Trees and the different methods to traverse them. The last topic specifically used recursion, an important concept we went over with some detail these past few weeks. Trees are an important data structure to know, as it is one of the commonly used Abstract Data Types. That's what I learned about this week. I will not be updating my blog next week sadly, as its Reading Week, not so sadly, so there won't be any lectures to blog about. Tune in in two weeks for more computer science.