I have mixed feelings about how this particular course has gone. For starters, we were “required” to use Turbo C. Well actually we were allowed to use something else as long as they display and compile properly on TC, which means setting text editors to use CR\LF as end of lines (DOS style) and testing them in TC (of course I used GCC (g++) and beloved Kate). I don’t know why it was the recommended IDE and compiler, though, since I think it sucks on both aspects. Other than that, I’m quite satisfied with the course. I’ve come across some algorithm issues in my assignments that I haven’t really thought much about before, so I had a chance to flex my brain muscles and understand some aspects of the language much better. One of those “Eureka!” moments.

Pointers to Pointers

In one of the assignments, our teacher made some notes about this topic which the book failed to cover. A pointer to a pointer, which in turn points to something else, might sound useless, but there’s definitely one use case we encountered that needed it: passing pointers and modifying them in functions.

Simple case: You have a generic function for opening files and checking for errors. Normally you’d declare a pointer to a file in main() and pass it to the function, like so:

int openfile(FILE *fileptr, char *name, char *mode)
{
    fileptr = fopen(name, mode);

    ...
}

int main()
{
    FILE *fp;

    openfile(fp, "foo", "r");

    ...
}

You’d think that would work, but it doesn’t. In fact, it would error when you try to use that file pointer. Because the address of the opened file isn’t getting assigned to fp in main(), although it was getting assigned to fileptr of course. It wasn’t clear to me at that time. After all, I did pass a pointer, right? Yes, I did, but not for the effect that I thought it would have. I scanned over my old C books and didn’t really see anything that discusses this topic. I have the K & R book, but I haven’t read it much, so I can’t really say. So instead, I’m just going to write this down, maybe to be able to help somebody else in the future (or some of my classmates who might be reading this).

The real issue here is that while pointers are used to pass by reference, the pointers themselves are passed by value. While you can modify the variable that the pointer is pointing to, you cannot modify the pointer itself. It’s probably easier to understand once you see that a pointer is just a variable. It’s a variable who only accepts memory addresses as its value, just like an int would accept integer values, etc. So like any variable, when passed to a function, a copy of that pointer is made and the original pointer’s value is untouched. So when you, for example, assign a memory address like a pointer to a file you opened in openfile(), that address gets assigned to the copy of fp, which if fileptr. Once the function ends, that copy is destroyed and the handle to the file is lost. Same goes for assigning a block of memory for a linked list or making a pointer to the head of a linked list point to something else.

So what do you do to be able to modify the pointer in a function? Simple, just like any other variable, you need to pass the address of that variable to the function and the function should receive that address in a pointer. In this case, you pass the address of a pointer and received with a pointer to a pointer. And to access what it is pointing to, as usual, you will need to use the dereference (*) operator. So the above code will now be like so:

int openfile(FILE **fileptr, char *name, char *mode)
{
    *fileptr = fopen(name, mode);

    ...

}

int main()
{
    FILE *fp;

    openfile(&fp, "foo", "r");

    ...
}

I hope that this could help some poor soul whose brain has been plagued by the same problem. It would probably be easier to have done this in C++, using references (&), though I think even that has its own problems. And anyway, the class was on C, not C++.

So that basically ends my formal C education. Not much was added to what I’ve already learned by myself years ago, except for some of the exercises. Now I feel I need to review my C++.

* So I finally submitted my application for UPOU two weeks ago and got their “received your application” e-mail the other day. Now comes the agonizing wait for news whether I get accepted or not. They said they’ll probably have the partial list in the website by the end of March or in April, but I still have to wait for an official parcel before I can enroll.

* My writeup about Dispel, the spell remover part of Sorcery, Source Mage’s powerful BASH-based package manager, is up. With fancy charts!

* Last year I had this plan to write about some of my favorite KDE 3 apps, focusing on how to use them and/or special features that make them wonderful. Procrastinator that I am, I let the idea sleep for a while. And now KDE 4 is here with a brand new set of amazing apps. Aaron has started his own series about falling in love all over again with these apps. So I’m kinda indecisive (no surprise there) whether such writeups about KDE 3 apps are still worthwhile.

* I’m currently in the middle of *trying* (and probably failing miserably) implementing a feature request for Konversation, under the watchful guidance of Eike. It’s my first real attempt at creating (not just copying) a feature in a real-world application. This is me, straight from the pampered world of C++ in books (more on that some other time). The process of trying to figure out how things work, (which, in my work process, is an essential part of figuring out where and how to insert a new feature) is exhilarating, adrenaline-pumping, and frustrating all at once. It’s fun *and* annoying. And I like it! Yeah, I’m crazy that way.

* I was able to buy a book on user interface design, “About Face” (first edition) by Alan Cooper. I think it was a pioneer book in the field of UI Design, dating back 1995. I didn’t expect much from the book at first being old and from “the father of Visual Basic”, but it actually turns out to be very nice and not so Windows-glorifying as I thought it would be. I also learned later that he’s one of the big names in the field of usability. I guess what really made me happy about the book (so far) is that it’s probably the first book I’ve seen where someone is advocating User Interface Design as a discipline/field, a subset of Software Design and distinct from Usability. I’m not sure if that ever came about or whether it is really distinct from Usability as a field. And I think Alan Cooper moved from emphasis on “User Interface Design” to “Interaction Design” in the most recent edition of About Face. As a side note, it’s quite amusing to see how some of his suggestions have been or are being implemented in KDE (or almost everywhere) today.

1. I suck at OOAD. (Object-oriented Analysis and Design). While I know the technical aspects of creating a class, I didn’t really know how to design one. I kept on asking myself again and again, should this be private, public, or protected, should I provide a setter/getter for this, etc. I guess one of the things lacking in my book is the integration of problem analysis and design into some of the example problems. I had this old C book (Hands-on Turbo C by Larry Joel Goldstein and Larry Gritz) that did just that. Even just the basics of designing classes would probably do a lot for a beginner to C++. In fairness, my book does have a sort of discussion about OOAD, but presented as a sort of add-on, rather than an important part of the process.

2. Nothing beats experience. Even if a book contained all the information and theory on software development, it still wouldn’t compare to the actual experience of writing code. Unfortunately, for months I leaned more towards the “I need theory first” excuse for procrastination, thinking that theory will properly equip me with the necessary arsenal to tackle any problem. Fortunately for me, Sho has always been there to knock some sense into me (I owe so much in that area that I should probably dub him as my Vox Rationis). Thing is, you need theory too, but it’s only half the story. Theory is nothing without practice, as they say. You can’t possibly learn everything through just reading programming books. At some point, you’ll need to apply that by actually writing code. Then, along the way, you’ll realize stuff that you haven’t really learned well enough or not learned at all. Then it’s time to learn about those. It’s a cycle. It’s a process. Either way, it needs to get started first.

3. KDevelop is… I really don’t know what to say about it. Touted as one of the best C++ IDE’s on Linux, I was really eager to give it a try. I didn’t use it while I was still learning because I thought it would overkill at that time, when my exercise programs spanned 3 files at most (main.cpp, Class.h, Class.cpp for example). But when Rolodeks grew to around 3 classes, I thought it was time to try it out. KDevelop is overwhelming, was my first and instant reaction. Unfortunately, it didn’t get better for me. For one, it’s Project system forced me to create C++ projects that used Autotools or CMake. I couldn’t just create a project with all files grouped together or let me use my own Makefile. In fact, KDevelop doesn’t even let you compile a single file C++ program at all. I might have missed some things though, since I haven’t read the KDevelop docs, but suffice it to say, I was pretty disappointed. Luckily, Kate is wonderful for what it is, and advanced text editor. With a few plugins, I was able to convert it to a mini-IDE, complete with a Makefile plugin. Although it’s still missing debugger plugins. Maybe I’ll have better luck next time.

Up next: Qt! And hopefully more exciting and worthwile software project.

January was as busy as December was, which didn’t give me much time to settle down after the holidays and do anything substantial, at least by my standards. I didn’t even get the chance to really digest the KDE 4.0 release and subsequent events, such as the KDE 4 release party. I’ve used KDE 4.0 for a few days now, but I’ve returned to 3.5.8 since I’m not sure what use I have for KDE 4.0 right now, or what I can do to help. So in the meantime, I have returned to a relatively problem-free setup.

The last 2-3 weeks have been pretty gruelling, more psychologically/emotionally than physically (but you’d notice that your body sort of “catches up” to your state of mind) and I’ve been treated to a few real-life lessons in dealing with people. I also had my first encounter with MS Office 2007 as well as meeting MS Publisher once more. I’d say that working with Publisher was quite easy, specially for simple purposes. The new ribbon interface in MS Office 2007 was a bit daunting at first though. Luckily, Publisher didn’t have that new UI. The most interesting (and frustrating) experience I had was that a publishing/printing house could get by with just having MS Word and Excel installed on their computers. Not even Adobe Photoshop. Quite intriguing.

In the meantime, I’ve been able to finish my C++ How to Program (Deitel & Deitel) book, although I just sort of skimmed on the last few chapters, unlike my intensive focus on the first ten chapters. I was pretty much disappointed by the quality of the material near the end. There were very obvious errata and it felt as if the last 10 or so chapters were written a bit hurriedly or, in this case, probably not fully revised (since this is the 5th edition). For a book that aims to be a classroom textbook, that’s a bit unfortunate. Anyway, I think I’ve gotten enough C++ to be able comfortably start learning Qt. This puts me one step closer to KDE and world konquest.

Hopefully the coming days will be better.

Updates on the C++ arena: I’ve basically finished the sort of “basics” of C++ and the next series of chapters will be more in-depth: inheritance, polymorphism, overloading, templates, etc. Right now, though, I want to redo all coding exercises from the beginning, to see how much I’ve retained. I’ve also been rethinking what would be my “term project” for C++. I wanted to develop a simple and small internet cafe system, using what I’ve learned from the book (which includes a bit of object oriented analysis and design). I would then try to create a GUI frontend for it when I got around to studying Qt, and finally a KDE frontend. But now I’m thinking that the project may not be too practical in the sense that I don’t know if I (or someone else) would be benefitting from it. But at the same time, I’m having a hard time thinking of a good project that will lend itself quite nicely to object-oriented analysis and design, Qt, and KDE programming. (I originally wanted to create a sort of vim-like text editor just for kicks) Need to brainstorm again…

And I’m still planning on “publishing” my notes online, partly for myself, and maybe for others. Yay! I’m going to add to the already hundreds of C++ guides out there.

Reviewing my notes and trying to answer past exercises sort of made me realize something that I have probably been taking for granted. It seems that my memory has been failing a lot recently. I can’t count how many times I’ve forgotten something that I’ve been thinking or been planning to do/say just a few seconds ago. I’ve also been having a hard time memorizing key terms, formulas, or definitions. Even though I do somehow understand the theory behind them, I can’t seem accurately communicate them. And, as one friend could testify, I often forget something that we’ve been discussing just a day or two before. It’s really got me worried. Before college, I had a good memory (except for History) and quite good at math. It seems now after college it has declined to a considerable degree. I don’t know whether it was because I developed a dislike for merely memorizing/parroting things in my Philosophy course in college or whether it was from lack of mental exercises 2-3 years after college. Either way, I hope it’s somehow reversible… I’m too young to be having this problem.

Anyway, time for more reviewing…

Updates:

1. Mandriva Spring review now up! Let me just explain some details about this Distro-Tour project I’m doing. It’s purpose is, first and foremost, my own learning experience. I do not want to go through my Linux life without having even experienced first-hand these distributions. I think it’s a good thing to gain a wider perspective of the landscape, and to see what other distros, including Kubuntu [1], have done right or wrong. An important consideration that I’m taking in this Distro-Tour is approaching the distro from the point of view of a relative newbie. In a sense, I’m a newbie when I start using these other distros, in the sense that I don’t know how things are setup or done. Every distro is relatively a new adventure. This perspective is also the reason why I focus mostly on the GUI apps and settings. I will probably try to learn more about the powerful command line backends that these GUI’s use some other time.

2. I finally finished most of the fundamentals of C++: control statements, functions, arrays, pointers, basic classes. The next chapters would focus on classes and object-oriented programming in more detail. However, I seemed to have discovered what is probably one of my weaknesses in programming. And no, it’s not about pointers (surprisingly). I realized that I have a hard time really grasping and putting into practice the concepts of recursion. Sure the chapter in the book made it look easy, but the exercises I encountered were definitely not (Towers of Hanoi and Fibonacci series anyone?). I’m not sure how much recursion is used in practice today, but I’ve been told repeatedly that it’s “a classic”, which means that I will most probably want to dig deeper into it. I have also been advised to take a look at the book Structure and Interpretation of Computer Programs [2], which uses Scheme [3], a dialect of LISP [4], as the example language. I’m hoping to find some equally helpful resources on recursion with C++. I don’t think I want to have to learn another language just to get to know recursion better, for now…

KDE 4.0

The release of KDE 4.0 is getting closer and closer [5]. The target release is in October of this year and, while I do hope that they do make it, I think that I wouldn’t mind a delay of a few weeks or even a month if that would mean more wrinkles would be ironed out. Besides, what better gift to get on Christmas than a fresh new KDE 4.0. I haven’t started to build KDE 4.0 from SVN, out of procrastination again. I could probably just apt-get the KDE 4 Series Alpha from kubuntu.org repositories [6], but I experienced some problems with it when I tried to two weeks ago. Anyway, it will be much easier to stay up to date (with the latest breakage) if I compile from SVN directly.

If you have noticed I kept on saying KDE 4.0 and referred to “KDE 4 Series”. I have noticed a sort of confusion that’s quite prevalent among KDE users, especially those not keeping watch on the Dot (not slashdot, mind you). Users seem to confuse KDE 4 with what will be the first release of KDE 4, which is KDE 4.0 out on October. To repeat what has been said before, KDE 4.0 != KDE 4 (!= means “not equal to”). This basically means that KDE 4.0 does not represent the complete fulfillment of what has been promised in KDE 4. KDE 4.0 is just the first release in a long series of releases that comprises the whole KDE 4 “lifecycle”. There will be other major releases, like KDE 4.1, KDE 4.2, etc. And there will be minor releases in between those, KDE 4.1.1, KDE 4.1.2, etc.

What’s my proposal to help solve this confusion? Let’s all start saying “KDE 4.0″ when referring to the first release or “KDE 4.x” when referring to a particular release, and use “KDE 4 series” or “KDE 4 cycle” when referring to the whole thing. In my most humble opinion, the confusion that could be solved or avoided justifies the extra letters one has to type. Of course, “KDE 4″ does sound cooler. Any other ideas? (Maybe KDE 4S… but that looks weird)

Needless to say, the KDE 4 Series will definitely rock!

Notes:
1. Kubuntu
2. Structure and Interpretation of Computer Programs
3. Scheme
4. Lisp
5. KDE 4 Series development schedule
6. Kubuntu.org KDE 4 Series Alpha

1. My workspace obsession has finally ended, resulting in a new room layout. Although a new LCD monitor would probably make me redo everything. But now I’m more “focused” on making/finding a laptop stand.

2. MOTU “project” put on hold: with a lot of stuff getting in the way, I have to temporarily put off studying packaging for Kubuntu. At least until the start of the academic year, when I hope to be a bit more free. I still help out in #kubuntu, of course

3. The Distro Tour project. Now that Byakko (the laptop) is here, time for doing something that I’ve always wanted to do. First to be tested: openSUSE 10.2. What happens to Kubuntu? In the end, Kubuntu will always be here. I will continue to help with Kubuntu, I will learn to package for Kubuntu, and hopefully even develop for Kubuntu. Kubuntu is a very special distro and it always has a place in my life.

4. C++ programming is progressing slowly, but at least it’s progressing. I’ve committed myself to one or two chapters a week. However, with the extensive note taking, summarizing, and exercise answering, I don’t think two chapters a week would be realistic. Still, I’m quite excited to get to the GUI part, and of course, to the KDE programming parts.

5. Feisty has been released last month, the Ubuntu Developers Summit has just finished, and development on Gutsy Gibbon has started. Time to think of some improvements for our beloved Kubuntu. I’m particularly interested in System Settings, specially regarding modules that, IMHO, should be there. Unfortunately, coder I am not, so I end up poking Tonio instead. My other areas of interest would be the GUI Upgrader and a Restricted Manager for Kubuntu.

6. Still waiting for the laptop’s wireless card to get fixed (or actually, waiting for the day that I can bring it to the store). Until then, I have to settle for disconnect/connecting whenever I need to switch machines.

7. On the negative side, I observed that my IRC support activities has somewhat lessened for the past 2 months. I’m not sure if it’s just the summer vacation atmosphere, or a case of burnout. I guess it’s really true, that too much of something is bad. I also feel that I have to cut down on IRC a bit in order to really focus on studying, if I want to reach my October deadline (to enroll in a distance/home education program). Of course, it doesn’t mean I’ll be abandoning my beloved fans.

… and then there’s my fever…