End of the Semester

So today is the last day of class for CS 371P, which brings this semester to a close.

I've felt like I've learned a lot this semester, about both C++ and OOP. Considering that I took this class so that I could learn more about these subjects, I definitely am happy with the end results. I was also happy that I became a little more experienced with UML and using Subversion, along with other tools. I think I'll be using at least some of these tools often in the future, so I like to get as much experience as possible while taking classes at UT.

I also had fun working with new people. There can be some downsides to this, but I do like working with others, especially learning what type of techniques they use when programming. I learned at least a few new things to help me in my programming based solely on the fact that I was working with new people this semester. Of course, it was always fun to figure out some topics to talk about on this blog. The Projects and Exams were challenging, but not overly so (at least, not compared to some of my projects/exams for my Operating Systems class).

In conclusion, I'm pretty happy with how the course ended up. In fact, this last semester for me (I'm graduating this semester) has gone really well so far. Hopefully I can continue that success post-UT.

Eclipse

I've been using Eclipse since around the beginning of my second year at UT (almost 3 years ago). I didn't really try any tutorials or anything, so I kind of had to pick up on things on the fly. While it did take me a little while to learn some basic things, I quickly learned to love Eclipse (especially compared to BlueJ, my previous Java IDE).

One thing that bothers me though is that I don't really use some of the nicer features of Eclipse. Although apparently, I'm not doing too badly (e.g., I've been telling some people about the "Correct Indentation" tool). Nevertheless though, I'd definitely like to learn more about the things I never touch (e.g., refactoring). In case others want to learn too, I decided to put some links I just searched for:

http://aspectprogrammer.org/blogs/adrian/2006/02/tips_for_using.html
http://dmy999.com/article/29/using-eclipse-efficiently
http://unitstep.net/blog/2008/02/10/eclipse-the-best-and-only-ide-youll-ever-need/
http://www.intelligentedu.com/blogs/post/best_new_training_sites/3467/best-eclipse-tutorials-and-videos-on-the-web

Some of these may refer to Java only (especially the last one I think), but I think some of it can refer to C++ development as well.

Inheritance

Inheritance isn't really anything new to me. It is one of those things that is drilled into our heads during our first few CS courses (or that's the goal anyway).

But most of that involved inheritance with Java. Simple inheritance, more or less. The type where a class can only inherit from one other class (i.e., only one parent).

But with C++ (and probably other languages), it is evident that inheritance can be much more complicated. Multiple inheritance, protected/private inheritance, double inheritance, virtual inheritance, etc. Some of these really involve drawing a picture of the whole hierarchy to understand what is going on. Granted, some things seem to be affected by odd design choices (e.g., using the same name for instance variables in each class), but it is helpful to know exactly how to work with the classes in these situations. Well...hopefully it is helpful outside of just taking tests about inheritance anyway. :)

Distributed vs Client-Server Revision Control

Sort of off-topic from the class, but while I was upgrading to the latest version of Ubuntu, I noticed a comment about how all of Ubuntu's core development was moved over to the Bazaar distributed revision control system. Looking into this, I found a Wiki entry on distributed revision control:

http://en.wikipedia.org/wiki/Distributed_revision_control

For the lazy:

Differences

* There may be many "central" repositories.
* Code from disparate repositories are merged based on a web of trust, i.e., historical merit or quality of changes.
* Lieutenants are project members who have the power to dynamically decide which branches to merge.
* Network is not involved in most operations.
* A separate set of "sync" operations are available for committing or receiving changes with remote repositories.

Advantages

* Allows users to work productively even when not connected to a network
* Makes most operations much faster since no network is involved
* Allows participation in projects without requiring permissions from project authorities, and thus arguably better fosters culture of meritocracy instead of requiring "committer" status.
* Allows private work, so you can use your revision control system even for early drafts you don't want to publish
* Avoids relying on a single physical machine. A server disk crash is a non-event with Distributed revision control

Disadvantages

* Concepts of DVCSs are more difficult for developers to grasp as they are required to know more about infrastructure.
* It's not possible to remove or change the whole history by only one party. This may be an issue for some companies, who would like to have full control over the history.
* A centralised server tends to be favored in corporate environment where access management and selective code visibility is more easily achieved; in this sense, tighter data security.
* There are no dedicated versions at one time, There are multiple variants.

Unclear

The following points are neither well documentated nor easily understandable:

* Will DVCS often require many more merge conflict resolution by hand efforts?
* Source code is considered the "crown jewels" of a software group. Centralized version control systems have been around much longer and thus perceived to be more stable.
* Some projects want or need centralized control.
* Distributed systems can end up with a person as the central point of control, rather than a server.

I'm kind of new to revision control (just started using SVN last semester, which is client-server). I'm pretty happy with SVN, but I wouldn't mind learning more about these others, especially if they have some nice advantages (of course, have to find the right combination of advantages/disadvantages).

C#

I never really looked into this language, but it seems like I might be working with it a lot in the near-future. Fortunately, our OOP book seems to refer to it a lot, about as much as C++ and Java, which should be very helpful. I'll have to go back through some of the chapters and review some of the C# stuff again (which I might have skipped previously). I seem to recall a few peculiar things, but then again, C++ and Java do a lot of strange things too. From the little bit I've seen, it doesn't seem too bad (unlike say Objective-C).

Darwin Follow-up

So I finished Darwin about a week ago (last Sunday). Didn't go nearly as smoothly as I had hoped, although I had some "distractions" that made it a bit difficult to get started on the project when I originally wanted to (yeah, I know...if I started a week earlier, this wouldn't have been a problem). I basically more or less started it the Friday night/Saturday morning right before it was due. Because of this, whenever I found a problem with my code, I decided to stick a "band-aid" on it instead of reconsidering my overall design. Eventually, I had a lot of band-aids and some poorly (in my opinion) designed code. It seemed to work for what I tested it with (I did get a 42/50, which is decent I guess), but it definitely was not easy to use the classes I created.

I'm hoping to do a better job with Life, which seems similar in some aspects to Darwin.

Don't Miss Class

A little over a week ago, I had to miss class due to a job interview. It was my first absence of the semester, and I feel like I missed a lot of information. It seemed like more topics were covered that day than any other (about 8 topics on the calendar). I did review some of the material, and I think I understood some/most of it. But I feel like maybe I was missing something important. I did ask a few people, but it turned out that either they missed class too or they couldn't really remember anything too important.

I don't think we got quizzed (directly?) over it, and I'm understanding the new material, so I guess it isn't a big deal. But nevertheless, I'm happy that I shouldn't have to miss any future lectures. We can cover a lot of material in a short amount of time in this class, and I think it can be a bit difficult to catch-up, especially if you miss a lot of days.