2009 didn’t kick off quite well. I got the flu immediately after New Year’s day and that lasted for almost a week. Luckily for me, my midterm exam that was scheduled on the 10th was postponed for the 17th. Even that was a disaster (here’s to hoping I didn’t mess that one up).

But regardless of that, there were a few highlights this month that tells me that 2009 will be an exciting year. KDE 4.2, which is going to be released really soon now, marks another milestone release from the KDE 4 series, boasting a lot of improvement and interesting changes. Furthermore, last week, Nokia, now the owners of Qt Software (formerly Trolltech) announced that the next release of Qt will also be available under the LGPL, hopefully pacifying/satisfying a lot of “I-don’t-want-to-use-Qt-because-of-the-license” people. And last but definitely not the least, hopefully this month, I will be getting my Nokia N810!! So yes, 2009 is probably going to rock!

And what new year would be complete without a set of new year’s resolutions? Here’s my 10 Commandments for 2009.

1. Discipline and Focus. Combat procrastination, perhaps my numero uno character flaw.
2. Be Health Conscious. The final months of 2008 really shook me up physically. It’s time to pay more attention to my health and weight (and shape ).
3. Blog Early, Blog Often. But also Blog Shorter. I should try writing more in shorter spurts than writing a novel in one go. And maybe not limit myself to only KDE/FOSS subjects (though those won’t appear on Planet KDE unless relevant).
4. Finish pending projects ASAP before turning to new ones. Prevent “project” creep from overwhelming me.
5. Schedule. Try as I might, I couldn’t live without some form of structure or guidance. While I do like the occasional spontaneity, I cannot thrive on random chaos. Of course, the effectiveness of a schedule relies on resolution #1…
6. Code more! My primary motivation for free software and KDE was programming. 3 years later, I haven’t done much progress. Time to move forward! Need to spit out actual KDE and Qt code.
7. Get a hobby. There’s life away from computers… I just need to discover it.
8. Sharpen the mind. I’ve been worried (read: paranoid) that my memory and sharpness seems to be declining lately.
9. Save money. Need to pay back Mama for (half of) the N810 and probably open up my own bank and PayPal account.
10. Document! Take note of important procedures I’ve done or scripts I’ve used. I’ve lost count of the number of times I’ve had to redo something I’ve done before, only to realize I’ve forgotten how I did it in the first place. It’s a habit I hope to develop and carry over to coding.

And now for the hardest part: actually doing all these.

I could probably say that half of the busy-ness of November was devoted to personal matters: birthdays, church/community activities, and health problems. I got a very big wake up call regarding my physical status, so I need to put a lot of effort into losing weight and staying fit. I’m not sure if the hacker’s diet is something that I can apply, given culture and situation considerations, but I’ll give it a try. In the meantime, I’ve taken some preventive measures and have declared war on all forms of soda/pop/soft drinks/whatever-you-call-them-in-your-country which started three weeks ago. That means (sniff) farewell to Mountain Dew.

But I’ve also been busy with the tech side of life. School has started again next month, and this time my subjects are more interesting and challenging (and the books equally incompetent) than last semester: Data Structures and Algorithms and Computer Structure and Organization. I’m really starting to feel that I’ve enrolled in a Computer Science course.

I was also finally able to finish (technically) a major web-related project that has been going on (very slowly) for months. It was my first attempt at using Textpattern, which probably gives me enough experience to start migrating my whole site over to it. Sure it’s not as simple as WordPress, where you can just install it (or have it installed) and blog away. But it isn’t that complicated. Understanding how it’s basic presentation components work together is the key. The hardest part for me was actually “translating” the plain XHTML/CSS to Textpattern, complete with dynamic content and such. In a way, it’s a lot like programming with a library (TXP Tags), which I actually found appealing.

Last, but definitely not the least, I managed to cram my way through my Qt book finally. Although I have to admit that skipped on a few chapters that either didn’t interest me or were well beyond my current areas (databases, threading, OpenGL, embedded). I focused mostly on the beginning chapters, which is IMHO the minimal Qt necessary to start KDE hacking. Just for fun, I put together this very simple, crude, and primitive “web browser”:

(P.S. This made an early college Windows fantasy of mine come true. But I have no intentions of going beyond that). The book, by the way, is available for free (legally) at the Qt documentation pages (unfortunately, only the first edition is available for free, which is a bit dated now).

But more than actually finishing a book that I bought a year ago, this milestone practically means that I’m ready for real KDE coding, which has been the ultimate goal for the past 2 years. I might be able to blog about the many KDE tutorials as I go along (but knowing my own blogging discipline, or lack of it, I won’t hold my own breath). Now I’m really excited.

Cheers to an eventful November and here’s to an even busier December!

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++.

• School: The past 2 weeks have been stressful. First preparing for an exam and then cramming for an assignment in discrete math. My fault entirely though. Procrastination rears its ugly head again.
• Discrete structures/math: Except for the cramming I did last week, I think I’m doing ok with this subject. But I’m just not happy with our textbook’s presentation and content. I could buy another recommend book, but is this subject worth investing that much in? So far no one I asked has been able to give me a straight answer to the question “What are the practical applications of discrete math in actual software development?”. Any ideas, LazyWeb?
• KDE Talk: I’m giving a talk on the 23rd about “Kubuntu & KDE: Contributing to an International Software Project” at a gathering of the local Ubuntu community. It’s my first public speaking engagement as a FOSS and KDE advocate, and probably the first (and most probably not the last) time I’ll be using TeX (courtesy of KDE presentations templates). Hope everything goes well.
• CWG: So it’s official. The KDE e.V. has approved the Community Working Group of which I am a part of. To put it simply, its mission is to take care of the community and communication aspects of KDE. As almost everyone is still at Brussels, we haven’t put up anything official yet. Hopefully we can do that in the coming days. But one of the current projects of the group is the End User FAQ and KDE Glossary. This FAQ is by no means comprehensive nor finished. It’s mostly taken from FAQ’s I’ve encountered in #kde. I have plans to improve it, so stay tuned.
• Updating guides: After doing the FAQ and mirroring it on my site, I realized that I have quite a number of KDE/Kubuntu guides. I have to update them for KDE 4, specially the theming and autostart guides, since there are major changes for KDE 4. And there are some that I probably no longer need (or want) to update. Hopefully I can whip myself into action ASAP.
• My Non-KDE/Kubuntu/FOSS on Planets? I’m still quite undecided on this. I have a few posts in mind that I’d probably want to share with others and ask people’s opinions. However, they’re not exactly KDE/Kubuntu/FOSS related (at least some of them). So I’m kinda hesistant whether I should let them be aggregated here. Decisions, decisions, decisions.

For something that’s supposed to be short, I have again successfully made it long.

2. KDE 4.1 is so going to rock! At least it already does for me. And I include a disclaimer that I’m not your average KDE joe, so YMMV (Your Mileage May Vary). Seeing the project evolve as a whole (and not just focusing on some more visible part) is truly amazing. Of course, some will not like it, and some will. What’s important at this point IMHO is that things aren’t stagnating. Of course, it’s not yet complete (depending on your “completeness” requirements). But I firmly believe that it’s too early to really bang the gavel on KDE 4. Only time would tell (and there’s always KDE 3.5 while waiting). As for me, I’m planning to migrate my main user (jucato) to KDE 4.1 this week.

3. We had our class’s first online session last Saturday. We were told that we’d be using Yahoo! Messenger. Not knowing how it will be done, I opted to use the real client on Windows XP. It turns out we’ll be using the conference feature, which is perfectly supported by Kopete, so no need to switch for the next sessions. Right now I’m considering suggesting and helping setup a more permanent online session place (like IRC) for group studying (because people might prefer synchronous communication than forums). A friend suggested using a web app like Campfire. I’ll have to take a long look at it since it’s not something I’m familiar with and, thus, can’t confidently recommend. I’ll try to see if the university can setup something for us and make it more “official”.

4. I’m considering migrating my blog from WordPress to Textpattern. When I do that, I’d probably make all the static pages I have in my site also under Textpattern. I don’t have any problems with WordPress actually, and it has served me quite well. Textpattern just happens to come highly recommended by a good friend compared to WP. Other supposed advantages of Txp include: better and cleaner template system (no messy PHP, which I’m not really keen on learning right now), more CMS than blog (whereas WP is more blog than CMS), and created by writers for writers (like me?). Anyway, it’s probably not going to happen immediately as I still need to actually use Txp. And when that time comes, I hope I don’t flood the Planet and get kicked.

5. One of my subjects this semester teaches Principles of Programming using the C programming language. Having some previous experience gives me a bit of an edge in class. One of the things I’ve noticed is how our book really doesn’t say much about good programming practices. It’s a very short, direct to the point textbook. I presume that we are being encouraged to research on our own. For example, the book mentions that something like sum1 = sum2 – (x – (y = 10)) * 4; “makes the code unreadable, but certainly shorter”, either implying that “shorter” is to be preferred over “unreadable”, or not explicitly discouraging such kind of code. Anyway, I don’t really expect much from the book and the professor, since the study program is more or less based on independent studying, but I’m somewhat uncomfortable that beginning programmers aren’t being taught good habits as early as possible. Fortunately, the subject makes use of Moodle, which has a forums feature which I can probably share my thoughts, as well as solicit other people’s experiences.

Hm… I really need to learn to write shorter…