I program professionally for about 8 years and most of my career was developing in C/C++, still I don’t consider I know everything about this terrific language. One prove is that I found an interesting feature available regarding #define macros!

Let’s LOG

One important thing of every program is log. It’s used to trace program’s flow or even debug on some cases where you cannot use GDB/DBX.

That being said, one important thing to put on your logs is the file name and line number where the it occurs. On my early days I though to have found a smart way to do it!

Well, I created a log function that here I’ll simplify it a little:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include
#include 
 
void log(const char* fileName, int line, const char* msg, ...)
{
    va_list args;
    va_start(args, msg);
 
    fprintf(stdout, "%s, %d:", fileName, line);
    vfprintf(stdout, msg, args);
    fprintf(stdout, "\n");
 
    va_end(args);
}

Now I can use this just like a simple printf:

10
11

int var = 50;
log("MyFile.cpp", 11, "Hello var: %d", var);

The problem with this, show up when I add couple lines before it:

10
11
12
13

// trace var value
int var = 50;
 
log("MyFile.cpp", 11, "Hello var: %d", var);

This time the output of this will still be:

MyFile.cpp, 11: Hello var: 50

The problem is this line is wrong now! And imagine fixing all the logs of a 1000 LOC file if you just add an include?

How to solve this?

Standard Predefined Macros

If you check The GNU C Preprocessor page that talks about Standard Predefined Macros you’ll find two interesting macros that solve our problem:

• __FILE__ – This macro expands to the name of the current input file, in the form of a C string constant.
• __LINE__ – This macro expands to the current input line number, in the form of a decimal integer constant.

Well, now if we use our log function with this macros we’re safe:

10
11
12
13

// trace var value
int var = 50;
 
log(__FILE__, __LINE__, "Hello var: %d", var);

This time the output of this will be:

MyFile.cpp, 13: Hello var: 50

Cool right?

Yes but if you start working with a bunch of people you’ll realize that use this standard macros might confuse some folks and others tend to use plain printf just because they don’t know how to use it.

Now, how to solve THIS problem?

#define Macros to save us

It turns out there is a feature on standard C called Variadic Macros that I didn’t know before this week that simply solve this issue and make log functions elegant and efficient.
I’ll point you again to the The GNU C Preprocessor on the Variadic Macros page so you can read the details, but in a glimpse here is its syntax:

#define MACRO_NAME(arg, ...) somefunc(arg, __VA_ARGS__)

One thing to notice though is that with this syntax you must pass at least one argument as variable arguments due the comma on your macro definition. But don’t look to this post with this face! There is a second syntax of Variadic Macros that will calm you down:

#define MACRO_NAME(arg, ...) somefunc(arg, ##__VA_ARGS__)

With those double pounds before the __VA_ARGS__ keyword, the C preprocessor will know if you don’t add variable arguments and will take the comma out.

Now, how this will help us on our log function?

Easy, we create this macro:

#define LOG(msg, ...) log(__FILE__, __LINE__, msg, ##__VA_ARGS__)

Now our code snippet can be re-writen to use this new macro:

10
11
12
13

// trace var value
int var = 50;
 
LOG("Hello var: %d", var);

As I said: cleaner and more elegant !

Sometimes you’re doing some personal project like a test algorithm, your personal web site or the next millionaire software; doesn’t meter, if you’re like me and like to test on your own stuff, you probably get to a point were you changed so much that going back to the original state takes so long that you choose keep trying to fix the current one.

Well, for me git came to save me for those hassles and once I started to do it, I install git on every machine I work… even in my day job!

Keep reading to find out how it works for me!

From now on, I’ll assume that you, at least, knows what git is and how it basically works. If you don’t, check git’s official site and its documentation, but to make your life easier I’ll recommend you the first 4 tutorials on the documentation section:

• The official Git tutorial
• Everyday Git in 20 commands
• The SVN Crash Course
• Git for the lazy

We’re good? Ok, lets move one!

The start up of a new project

By a “new project” I mean “every thing you do on your computer that can be isolated”. This means that a project can be a shell script, a word processing document, a spreadsheet, an entire site or even a complete program.

I’ll not lie to you, there are many “projects” on my computer that don’t have a git repository but trust me, from now and then I always regret myself to not had created one.

Anyway, first thing most people do is to create an empty repository and start doing their stuff inside it. Well, that quite doesn’t work for me. See, most of the times I create 3 or 4 start up projects before be completely satisfied with it and start coding, for that reason I only create a git repository when I have the basic skeleton of my future project. When I’m satisfied with my starting project, then I issue the following commands:

$ git init
$ git add .
$ git commit -m "Initial revision"

I use these commands so much that I have an alias to do them for me:

$ alias projinit='git init && git add . && git commit -m "Initial revision"'

Ok, with that ready my next step is to ignore some files that I don’t want to track, like .o files in C/C++ project. To do so I edit the .gitignore file and add those extensions there. Again, I’ll assume you know how to do it, if you don’t, check my recommended links above.

The code workflow

You might ask:

“How often you commit your work?”

Well, I always do commits when I finish a small milestone of my project, and when I say small, I mean it. For instance, if I’m doing a Vim plugin, when I finish the start code snippet that contains a check if the plugin is already loaded, I commit. Check it out:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" AutoClose.vim - Automatically close pair of characters: ( with ), [ with ], { with }, etc.
" Version: 2.0
" Author: Thiago Alves <thiago.salves@gmail.com>
" Maintainer: Thiago Alves <thiago.salves@gmail.com>
" URL: http://thiagoalves.org
" Licence: This script is released under the Vim License.
" Last modified: 05/11/2010
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
let s:debug = 0
 
" check if script is already loaded
if s:debug == 0 && exists("g:loaded_AutoClose")
    finish "stop loading the script"
endif
let g:loaded_AutoClose = 1
 
let s:global_cpo = &cpo " store compatible-mode in local variable
set cpo&vim             " go into nocompatible-mode

For me, this worth a commit!

Of course I forgot to commit that often, but when that happens I use the cherry pick commit from git where you can selective choose which lines you want to stage, then I create as many commits as it needs.

Please, don’t think I keep committing my code every dozen lines, is not like that. Some times it takes me one or two days and about 5-6 files to I feel like my changes worth a commit. Honestly this is up to you decide how often you’ll gonna commit.

Here is a snapshot of my git repository from my Vim plugin called Autoclose:

At this point I have a growing repository with a bunch of commits that keeps track of what I’m doing and suddenly I get to a point where I’ll try a crazy change on my code that will delete a big chunk of code. What do I do?

Branching

I create a branch! On git it is as easy as type one command line:

$ git checkout -b mycrazytest

Done! I’m on a new branch ready to rape my code as much as I want without loosing any code done so far.

When I finish this crazy test I check if it worth something and if it is, I go back to my master branch and merge the changes:

$ git checkout master
$ git merge mycrazytest

And if I feel like this was all crap, I just delete the branch:

$ git checkout master
$ git branch -d mycrazytest

This way I never loose code and I feel confident to change  as much as I want.

Going pro

Some project demand a better approach then a master repository and a bunch of test ones. For these cases I always follow this steps:

1. Initialize my repository;
2. Create a development branch
3. Do all my coding on development branch
4. When project reaches some release milestone I merge development with master and tag master with the milestone description
5. Get back to development branch and continue coding

This small recipe is helping me doing some Indie projects on a more professional way and so far it’s working like a charm.

Now that you know my workflow be prepare to 2 or 3 more posts about git. I’m planning to write about git host (public and private, specially on Webfaction) and about repository conversion (from SVN to git, Mercurial to Git, etc.).

With some luck I make the action of writing here a habit and sooner or later I will have some people actually reading this blog

Cheers!

I don’t know if was the complexity of having a server machine to host my repositories or was just pure laziness but the fact was I never used a VCS until I knew git!

The joy of a DVCS

What most call my attention was the possibility to have my whole repository locally, independent of a separate server! I would have no excuses to not use it, just run couple commands on your directory and I would be done.

Not that fast! One thing kept poking my mind:

And if I loose everything on my hard drive?

If I use a “traditional” VCS I would have all my code backup on the server, and with git? Well,  it turns out that git has a smarted solution for this and is the D on DVCS: Distribution. Linus Torvalds had this idea that every copy of the repository should be a backup of the entire source tree, this way if you look your copy, you can just grab a copy of your neighbor and you have a full copy of your tree.

Of course there are some details about it that you should check on the links at the end of this post, but the important thing here is: I founded a software that would keep history of my projects locally plus allowing me to share my work and as result have multiple backups of my source code.

You might be thinking: Git is the way to go? There are any alternatives out there?

In fact there are!

Alternatives to Git

If you read about git and like the concept but something looked weird, you can still try couple more DVCS. The most famous are:

• Bazaar
• Mercurial

Both are awesome and looks very similar to each other including git.

Anyway, doesn’t meter which software do you choose, the only thing that meters is that now there is no more excuses to not versioning your personal code! Believe me, if you spend some time reading about DVCS you’ll find out that you should be doing it already.

And where can you read more about it?

Further knowledge

First I would like to point you out to the 3 main pages of each DVCS:

• git: http://git-scm.com/
• Bazaar: http://bazaar.canonical.com/en/
• Mercurial: http://mercurial.selenic.com/

Then if you want to dig deeper into git I indicate the following links:

• The Git Book (which is the place where I took the image of this post)
• PeepCode (this one is paid, but definitively worth the money)

I know this post is just too small to talk about git or DVCS but I just wanted to spit it out to start a path for future posts and perhaps one or two articles/tutorials. Keep tuned!

Well the day to know it come and almost everybody was disappointed with it. The question is: Why?

In my humble opinion the problem happen because everyone was expecting a step above the laptop and no one like it when they realize that this new product come below laptops.

The dreamed tablet running MacOS X unmodified has to wait, but lets face it, what are the main uses for a tablet?I can come up with some:

• Specialized softwares like medical or coaches play book
• Reading
• Students notes

Honestly I can’t see further use for it since they first appears in 2001 as the first public prototype from Microsoft.

The industry didn’t put any effort to bring tablets to the mass until they realize that Apple was doing it. But we cannot talk about tablets before say a word or two about NetBooks for two reasons: First they came to life as the gadget between smart phones and laptops (which is exactly what Apple claims iPad is) and the second because Steve Jobs talk about then on his Key Note.

Unfortunately I have to agree with Mr. Jobs. I can’t see my self programming, writing long texts, playing a game or even watching a movie on a NetBook. But I can see myself taking notes from a class on it, reading an email on the road and doing a quick post on this blog.

But for those tasks that a NetBook will fit I can’t avoid to think in: open my bag, take the little gadget from it, open the lid, wait for it come to life, start the desired application, use it, close the application, shutdown the NetBook and put it back on the bag.

This is exactly the same process to use my laptop only the gadget is smaller. Sorry but I can’t see any different for me.

Also we have to think about NetBooks performances. I don’t have one so I cannot talk to much about it but I wonder if a NetBook is faster enough to a “quick post” before an appointment. Imagine your self coming to an office for a meeting and the secretary says that you’ll have to wait a little.

“No problem I can take my NetBook and do some notes on it while I’m waiting!”

Well, if the waiting time is shorter than the time your gadget takes to turn on it will be embarrassing.

So why NetBooks exists in first place? Contrary to Mr. Jobs, NetBooks do 2 things way better then a laptop:

They are smaller and cheaper then laptops!

And that are two things that mobile professionals love!

“A full computer a little bigger then my smartphone? Who cares if this computer doesn’t do as much as my laptop! I can put it in a purse and it cost way less than a laptop!!!!”

And the NetBook market was formed. The industry starts to think in ways to improve it, make it better, bigger, smaller, prepare your breakfast and everything you can imagine until Apple did what they are really good about:

Get a small set of tasks and do them in the best possible way.

You can see this in MP3 players. Everybody knows that a generic MP3 player does a bunch of tasks more than an iPod but for those tasks that an iPod does every one else fails miserably. Microsoft felt this with its Zune.

And what are those tasks Apple try to embrace with iPad? As I can see (disregard what Mr. Jobs said) these are the key features that iPad intent to do:

• Reading
• Browsing
• Email
• Movies
• Specialized apps

And I’m pretty sure that Apple will do them brilliantly as always.

So imagine your self reading a book or a magazine on a NetBook, than imagine the same thing with an iPad. Which one is better?

“Aha! But for read books I have a Kindle and iPad will never be a Kindle killer!”

Exactly! iPad is not a Kindle killer either because it doesn’t intent to! Remember that iPad has its place between smartphones and laptops and eBook Readers are a whole different category.

“But Apple launch the iBookStore! How can you say that this is not their intent?”

Well I think on iBookStore as another media store for Apple devices. Imagine 3 years from now with iBookStore having almost the same books as Amazon and then Apple launch an eBook Reader with eInk. It’s device will have all those title available just like Apps for iPad!So reading on iPad is probably way better then any other device except eBook readers.

Now, on the category of Specialized Apps that iPad will shine. Which you think is better, play a game on a NetBook or play a game on an iPad? A medical care software used on hospitals being used on a NetBook or on an iPad?

That’s the point! Apple didn’t tried to launch a concurrent for laptops or smartphones, even because they will not have two products concurring with each other (they already learned that lesson), they launch a new platform for new possibilities and we’ll only see what iPad is good for in a year from now with help of iPad developers.