Recently they ask to me to write about the site Web Hosting Pal.This site can help you to find the best web hosting for your requirements. Immediately I visited the website which I chose to promote and I thought what I can write.
My first impression wasn’t good because the page look is a “little old” in my opinion!
At once I looked the “beginners guide” section and I observed the guide is still under construction, so I couldn’t have any help for my eventually need! I hope they will complete it soon, because it could be an useful thing for surfers.
About the “top ten web hosting” page, I think is complete and it shows the right information to your best choice.
Moreover, you can find for every top ten item an exhaustive review of the hosting services and of the hosting quality.
Actually I don’t need to change my hosting service, but if you are looking for a new web host, I suggest you read Web Hosting Pal reviews, you might find useful information.

To obtain this, we make something similar to a c++ class: a struct with associated functions. The functions add characters to the string in the struct, and allocate more memory space when the string is full.

This is usefull when we are working with string with an unknow length (e.g. we are reading a file).

The struct containing the string is the following:

// Struct containing the growing string
typedef struct
{
	// string
	char * text;
	// string length (with zero terminator)
	int length;
	// string capacity
	int capacity;
} growing_string;

The text variable is where the string is allocated, length is the current string lenght and capacity is the memory allocated for the string.

To better understand the difference between length and capacity, look at the next image:

Capacity is the total space allocated for the string, while length is the actual number of character of the string, including the \0 terminator (the special character that close the string). If we add enough characters and the length is greater than the capacity, we need to allocate more memory for the string.

To create the string use the following method:

// Create a new growing string. Return 0 if the operation was done
int new_growing_string(growing_string * str);

This method allocate the memory space for the string in this way:

// alloc string space
str->text = (char *) malloc(sizeof(char) * DEFAULT_INITIAL_SIZE);

DEFAULT_INITIAL_SIZE is a #define with the size that the string will occupy when it’s created. Another #define is DEFAULT_GROW, that indicates the number of characters to add to the string when the capacity is full.

The method that adds characters to the string is the following:

// Add a char to the string. Return 0 if the operation was done
int add_char(growing_string * str, char c);

This method automatically reallocate the memory space for the string when is needed, and adds the character at the end of the string:

int add_char(growing_string * str, char c)
{
	// if the string capacity is reached
	if (str->length >= str->capacity)
	{
		//  increments the string dimension
	}
	// add the character at the end
	str->text[str->length - 1] = (int)c;
	str->text[str->length++] = ‘\0′;
	return 0;
}

If the length is smaller than the capacity, then the character will be added to the end of the string. Otherwise, this code will be executed:

//  increments the string dimension
char * backup = str->text;
int i;
// create the space for the new string
char * tmp = (char *) malloc(sizeof(char) * str->length + DEFAULT_GROW);
if (tmp == NULL)
	return 1;
str->text = tmp;
str->capacity = str->length + DEFAULT_GROW;
// copy the old string
for (i = 0; i length; i++)
{
	str->text[i] = backup[i];
}
// free the memory of the old string
free(backup);

We save the pointer to the old string, assign a larger memory space for the new string, copy the old string into the new space and free the space assigned to the old string.

Other methods of the “class” are:

// frees the space allocated for the string
void delete_growing_string(growing_string * str)
// add to the growing string the string text
int add_string(growing_string * str, char * text)

Following, a code sample that adds to a growing string all ASCII char from 32th to 127th:

int main()
{
	growing_string str;
	new_growing_string(&str);
	for (i = 32; i < 128; i++)
	{
		add_char(&str, (char)i);
	}
	printf("%s", str.text);
	delete_growing_string(&str);
	return (0);
}

In the source code you will find the files growing_string.h, growing_string.c and main.c with an example on how to use the code.

Download Growing String. Downloads: 153

public class Main {

  public static void main(String[] args) {
    System.out.print(Quiz.GetMagicNumber());
  }

}

Quiz.java

public class Quiz {

  static int magicNumber = 3;

  public static int GetMagicNumber()
  {
    return magicNumber;
  }
}

What we need to add in Quiz class to print 5 instead of 3?

foo.h

class Foo
{
	public:
		Foo();

		void fooo();
	private:
		int i;
		char c;
		short s;
	protected:
		char b;
		char e;

		char getFoo();
}

foo.cpp

#include "foo.h"

Foo::Foo()
{
	for (int i = 0; ; ) { }
}

void Foo::fooo()
{
while(true)
{
	c = 'f';
}
}

char getFoo()
{;
	return c + 2;
}

To prepare the source code to the localization, we must sorround all strings that we want to localize with the macro “_()”, for example:

...
wxMessageBox( _("localized string") );
...
wxMessageBox( wxT("not localized string") );

When all strings to translate are sorrounded with the macro, we can start the translation process launching poEdit: when we run the program for the first time, it will ask us general information about the team, the author of the translation, the language and other boredoms.

When the program has been started go to “File”, “New Catalog”

Compile the “Project info” tab as in picture, go to the “Paths” tab and add the source code path in the “Base path” text box and in the paths list below.
Click “Ok” and save your “.po” file in the project directory.
Now you can see a summary windows that shows all strings that you can to translate:

If you get an error, don’t worry! Go on “Catalog” -> “Update from sources” and all should go right.

Now go to “View” -> “Display quotes” and start the translation! In the left bottom textbox you can insert the the translation of the string, inside the quotes.
When you finish the translation you can save, and you’ll find in the project directory the files “default.po” and “default.mo”. The file “.mo” is the real localization file, but if you want to change the translation use the “.po” file, so don’t delete it.

Instead of continually, manually change the upload limit according to our needs, I use a little script that I wrote, that automatically set the bandwidth limits from the number of downloads in the queue. To use this script we must have the amulecmd utility installed (from source code or from distro packages).

The script in his defaults settings sets the upload limit to 2KB/s if there aren’t file in the downlaod queue; if there are three files or less, the upload limit is setted to 10KB/s; in the other cases (more of three files downloaded), the upload is setted to 30KB/s.
The beginning of the script contains well commented parameters to change the script behaviour.

#!/bin/sh

#password to connect to the amule daemon
PASSWORD="abc"
#command to execute to connect to the daemon
AMULE_COMMAND="amulecmd"
#upload limit when there is no file in the download queue
IDLE_BW_UP=2
#min number of files in download queue to set the upload limit
#to the "normal" value
MIN_DW_LIMIT=2
#upload limit when the number of file in download queue is >= 1
#and  MIN_DW_LIMIT
NORMAL_BW_UP=30

UP_LIMIT="set bwlimit up "
DW_LIMIT="set bwlimit down "
COMMAND="$AMULE_COMMAND -P$PASSWORD -c"

if [ -z "$(pgrep amuled)" ]; then
    #echo “amule closed”
    exit
fi

setUploadBw()
{
    CURR_BW_UP=`expr substr “$($COMMAND “get bwlimits” | grep “Up”)” 24 2`
    if [ "$CURR_BW_UP" -ne "$1" ]; then
        $COMMAND “$UP_LIMIT $1″ > /dev/null
        $COMMAND “$DW_LIMIT 0″ > /dev/null
        echo “$0: Upload bandwidth limit is now $1 kB/s”
    fi
}
NDOWN=$($COMMAND “show dl” | grep -c “>”)

if [ "$NDOWN" -le 0 ];then
    setUploadBw $IDLE_BW_UP
else
    if [ "$NDOWN" -le "$MIN_DW_LIMIT" ]; then
        setUploadBw $MIN_BW_UP
    else
        setUploadBw $NORMAL_BW_UP
    fi
fi

To use the script, paste it to a file named “setamulebandwidth”, modify the parameters you need, and save it to /usr/bin. After that, set the execution rights to the script:

#chmod a+x /usr/bin/setamulebandwidth


Of course we want to execute thes script automatically at least every 5 minutes (personally, I prefer to run it every minute), and to do that we can use the cron.
Type from your administrative account (add sudo at the start of the command if you are using Ubuntu):

# sudo crontab -e
and add the following line
*/5 * * * * /usr/bin/setamulebandwidth

Where the */5 means that the script will executed every 5 minutes.
Save the file.

Now your aMule will change the upload limit dinamically from the number of downloads in queue!

Usbautostart is a Windows utility that performs autoplay for usb mass storage device. Windows avoid the autoplay on the removable medias for security reasons, but with this program you can bypass this limit and you can choose to launch a program in the usb pen when you plug it.
The program will also close all applications running from the device when you try to “safety remove” it.

Screenshots:

Usb peripheral detection (the red icon on the left is Mozup, the program started from the usb pen):

Usb removal:

The project is hosted on sourceforge, and it’s released under GPL license, so it’s completely free and open source!

Download Usb Autostart

How much legs there are in the pullman?

After a lot of work, I released the new version (2.0) of the MySQLDump class, already introduced by this article.
MySQLDump is a class that allows to do a complete MySQL database backup with php pages.

After the inandrea’s good work there wasn’t too much space for improvements, but I think that these addition can be usefull: now it’s possible to export structures and/or data not only for the selected database but also for a single table.

The following example will explain how to export the structure and the data for the table mytable in the db mydb (the interface to the class is slightly changed from the previous version).

//Include the library
@include_once('lib_dump.php');
//Db connection
$connection = @mysql_connect('127.0.0.1','username','password');
//Create the MySQLDump class instance
//1° parameter: db name
//2° parameter: the exported file that will contain the dump
//3° parameter: create zipped file (true = zipped, false = normal)
//4° parameter: data encode (true = hexadecimal, false = plain text)
$dumper = new MySQLDump('mydb','dumpfile.sql',false,false);
//Structure export of the table 'mytable'
$dumper->getTableStructure('mytable');
//Data export of the table 'mytable'
$dumper->getTableData('mytable');

In this way we will obtain the complete dump of the tumble mytable in the file dumpfile.sql (with the term dump we refers to a sql instruction that can recreate the table and the data). Of course, if for some reasons we don’t need both structure and data, we can always create the dump only for the table structure or for the data.
Instead, if we want to do the complete backup of the database, we must use these instructions:

@include_once('lib_dump.php');
$connection = @mysql_connect('127.0.0.1','username','password');
$dumper = new MySQLDump('mydb','dumpfile.sql',false,false);
$dumper->doDump();

Or, to obtain the structure and the data separately:

@include_once('lib_dump.php');
$connection = @mysql_connect('127.0.0.1','username','password');
$dumper = new MySQLDump('mydb','dumpfile.sql',false,false);
$dumper->getDatabaseStructure();
$dumper->getDatabaseData();

I hope that this class can be usefull to you, and I invite you to visit the specific section of my site (http://www.creativefactory.it/lab/) where you can find the complete documentation generated with phpdoc.