C on Zio Ivan

Scope 'this', and scope 'that'

Sun, 12 Feb 2012 00:00:00 +0000

As a guy that tries to live his professional life in the middle of the dichotomy “C/C++ - JavaScript”, I often find myself discussing the discrepancies, differences and implementation details of the latter (an half-assed prototypal language) using the former.

The other day I was chatting with Luca (@lucabox) about scope in JS, and we were describing the different situations you can end up with… and how we work our way out of those culprits.

Swap the value of two integers without temporary storage

Wed, 13 Jan 2010 00:00:00 +0000

Someone says this is an old lame trick. I think it’s simple and clever use of XOR.

How/Why does it work?

It’s built around the properties of the XOR ^ operator, who has the following properties:

A ^ B = B ^ A (commutative)
A ^ 0 = A
A ^ 1 = ~A
A ^ A = 0

So, you can see how it get’s applied here:

#include <stdio .h>
int main(void)
{
   unsigned int a, b;
   // ... populate somehow "a" and "b"...
   
   printf("a = %d - b = %d\n", a, b);

   a ^= b; // store in "a" the value of "a XOR b"
   b ^= a; // store in "b" the value of "a XOR b XOR b" = "a XOR 0" = "a"
   a ^= b; // store in "a" the velue of "a XOR b XOR a" = "b XOR 0" = "b"

   printf("a = %d - b = %d\n", a, b);
}

Neat.

Count bits set in parallel

Thu, 07 Jan 2010 00:00:00 +0000

This time it’s not something I make myself. Indeed, I still can’t “see” it 100%: I got it, but it’s a bit complex.

A cute little lady counting (bits? ;-) )

It’s a method to count the number of bits in a number in O(1), in just 5 lines of code. INHUMAN.

The “human” solutions

Of course, there are methods that look way more easy and, given that the size of a number in memory is “fixed”, the O(1) still stands. For example: 0. Based on the “evenness/oddness” of the number

unsigned int bits_counter_v0(unsigned int x) {
    unsigned int count = 0;
    while ( x != 0 ) {
        // If odd, add 1
        count += (x % 2 == 0) ? 0 : 1;
        x >>= 1;
    }
    
    return count;
}

1. Counting one bit at a time (always the least significant one)

unsigned int bits_counter_v1(unsigned int x) {
    unsigned int count = 0;
    while ( x != 0 ) {
        // If least-significant bit is 1, add 1
        count += (x & 1) ? 1 : 0;
        x >>= 1;
    }
    
    return count;
}

2. Counting 4 bit at a time with max 8 shifts, using an “hashmap” with precalculated results The fact that it can count the bits in “max 8 shifts” has the trade off of the memory used by the hashmap.

unsigned int bits_counter_v2(unsigned int x) {
    unsigned int count = 0;
    // "Hashmap" of the values for the least significant 4 bits
    unsigned int int_to_bits_count[16] = {
        0, // 0  00
        1, // 1  01
        1, // 2  10
        2, // 3  11
        1, // 4  100
        2, // 5  101
        2, // 6  110
        3, // 7  111
        1, // 8  1000
        2, // 9  1001
        2, // 10 1010
        3, // 11 1011
        2, // 12 1100
        3, // 13 1101
        3, // 14 1110
        4  // 15 1111
    };
    
    while ( x != 0 ) {
        // Add the bits count of the least significant 4 bits
        count += int_to_bits_count[ x & 15 ];
        x >>= 4;
    }
    
    return count;
}

Let’s see what some insane people made.

Find the non repeating char in O(n) time and O(1) space - v2

Fri, 18 Dec 2009 00:00:00 +0000

My colleague and friend Luca (@lucabox) described a better solution to the problem of "Finding the first non repearing char in a string in O(n) time and O(1) space". It uses smartly the space, making the solution nicer and slicker. Or we are just 2 geeks that need to give more attention to their girlfriends :P

Luca’s solution description

The logic of this solution is based on the usage of an array of unsigned chars. Every char (assumed to be lowecase) has an associated small byte (1 char = 8 bits), where the bits 0x1 and 0x2 (the 2 least significant) represents, respectively, “present once in the input string” and “present multiple times in the input string”. After the input is “scanned” once, and every letter is marked with the correspondent “presence bit” (once, multiple or none), it get’s scanned a second time to find the first char of the input which has the bit “present once” set to “1”.

Il VERO fattore WOW!!!

Wed, 31 Jan 2007 09:13:48 +0000

Pollycoke, che sta ormai acquistando una certa notorietà in tutta la comunità Italiana (ma non solo), ci parla di una proposta SCONVOLGENTE (in positivo) fatta dalla comunità degli sviluppatori del Kernel ai produttori di hardware:

[…] the Linux kernel community is offering all companies free Linux driver developmentAll that is needed is some kind of specification that describes how your device works, or the email address of an engineer that is willing to answer questions every once in a while. […] In return, you will receive a complete and working Linux driver that is added to the main Linux kernel source tree

XGL: OpenGL sempre più prepotentemente sui nostri Desktop

Sat, 11 Feb 2006 00:54:09 +0000

XGL: tutti ne stanno parlando ultimamente. Ci sono articoli in ogni dove su XGL ma… che é? Prendiamo da Wikipedia:

Xgl is an X server architecture, started by David Reveman, layered on top of OpenGL via glitz. Some say that it is seen as the future of the X.Org Server, but some disagree because it requires a 3D graphics card. Although most PCs are nowadays shipped with such a card, most vendors (most notably NVIDIA and ATI Technologies) don’t provide open source drivers for their cards, which do not work on all computer architectures supported by the X.Org Server.

Soon, Native GTK+ on MacOSX

Tue, 31 Jan 2006 23:58:22 +0000

Soon you may be able to execute Gnome/Gtk+ based programs ~~NATIVELLY~~ NATIVELY on Quartz without the X11 Emulation. Someone (thanks to exist) is working on the porting.

It may be the incipit of a new era for Open Source software on MacOSX. Take a look at this.

One of the most interesting characteristics of Gnome-oriented applications is the coherence between the HIG (Human Interface Guidelines) of Gnome and MacOSX.

Source: Melablog.it and StyleMac.com.

GTK+ howto from IBM DeveloperWorks

Thu, 12 Jan 2006 23:17:09 +0000

A collection of howto on Gtk+ on the rich DeveloperWorks website from IBM.

2 articles are available right now:

Source, OSSBlog.

Embedding Python in your C programs

Tue, 03 Jan 2006 20:28:30 +0000

The language of choice for large, high-performance applications in Linux is almost always C, or somewhat less often C++. Both are powerful languages that allow you to create high-performance natively compiled programs. However, they are not languages that lend themselves to runtime flexibility. Once a C/C++ application is compiled, its code is pretty much static. At times, that can be a real hindrance. For example, if you want to allow users of a program to create plugins easily that extend the application’s functionality, you have to deal with complex dynamic linking issues that can cause no end of headaches. Additionally, your users will have to know C/C++ in order to extend the application, which severely limits the number of people capable of writing extensions.

Fish: a new Unix Shell

Tue, 20 Dec 2005 15:03:28 +0000

fish is a user friendly command line shell for UNIX-like operating systems such as Linux.

Bash is a standard (de facto), as every *nix user now but… this is the beauty of the OpenSource: any other programmer can think “hey, I want to remake this in another way!” and, than, do!

Fish is a beautiful example.

For screenshots-addicted users (like me ;)), go here.

-EDIT- Thanks to Nemo for “errata-corrige”.

Play with Xcode build settings

Tue, 20 Dec 2005 00:09:19 +0000

In order to become an effective Xcode user, you need to understand two major Xcode concepts. The first is how Xcode projects are defined and organized. The second is how the Xcode build system takes the targets that are defined in your projects and turns them into products.

There is a lot of flexibility in the Xcode build system for customization, so you can choose to keep your settings simple or make them as complex as you like. But for most purposes, a basic understanding of how build settings and build configurations work will make this topic easy to master—once you have these concepts clear, you can choose the settings that work best for you.