Today I’d like to talk about one nice trick that I learned few days ago.

When working with large software systems, memory management becomes an imperative. In C, you can easily allocate a large chunk of memory and allocate structure right on that buffer. This is by far more difficult in C++, because compiler has to call consturctor.

Apparently, you can, in a way, directly call object’s constructor . I.e. you can allocate an object, on specified memory region, without actually allocating this region.

This is how you do it.

char* s = new char[1024];

SomeClass* p = new (s) SomeClass;

First new operator just allocates 1024 bytes. This is good old allocation as we know it. Note the special syntax of the second new operator. It allocates the new object on memory specified in brackets. Basically, this calls SomeClass’s constructor using s as storage.

One thing that I don’t know how to do is how to call destructor on the object – i.e. how to delete an object in place.

Related posts:

1. Direct IO in Python
2. One sane voice in the crowd
3. Recursively deleting symbolic link and what it points to

At first, I thought less reads entire input first. This would make standard input stream free to process key presses from the user. So I decided to check this out. I created a 1Gb long text file and ran less on it. I expected less to take some time to show file contents, but it showed first lines of the file instantly. Also, it didn’t consume 1Gb of RAM as I expected.

The conclusion is obvious. less does not read entire input buffer before letting user to interact with itself. Then how?

Here’s what less does. It separates input file stream from user input stream. Both inputs initially come via standard input stream, so less separates between them. First it duplicates the standard input stream. This allocates a new file descriptor. Then it closes old file descriptor, freeing file descriptor 0 for use. Then it opens /dev/tty. When opening a file, Linux uses next available file descriptor. File descriptor used as standard input is 0, so when less opens /dev/tty again, file descriptor of the newly opened file has value 0.

Eventually, it ends up with the new input coming via standard input stream file descriptor (0), and old input still available via file descriptor that it duplicated in the beginning. It reads the input file from the duplicated file descriptor, and uses curses on standard input stream.

You may be wondering what is /dev/tty and what it has to do with standard input streams. This is really fascinating stuff.

As you know, in Linux, everything is a file. So is terminal. Linux uses device files to represent various system devices. /dev/tty is a file that represents terminal of the current process. When process reads from /dev/tty it becomes its input. When program writes to /dev/tty it becomes its standard output or standard error stream.

So, when less reopens /dev/tty, it actually recreates standard input. Older descriptor, one that has been duplicated, can no longer accept new input, but less still can use it to read what it has been written into it already.

Related posts:

1. Creating new application on top of SSH
2. sed – the missing manual
3. Direct IO in Python

One problem that you should take care of when tackling this problem, is that symbolic link can point to a symbolic link. Then symbolic link should also point to symbolic link. And once again, and again and again…

So what can we do about it? First, lets start with lstat() system all. It will tell us is the file we’re interested in, is actually a symbolic link. To be more precise, st_mode field in struct stat will have flag S_IFLNK if specified file is a symbolic link. Note that it should be lstat() and not stat() – the later will return information about file the link points to and not about the link.

Next step is to call readlink(). This system call returns name of the file pointed to by specified symbolic link.

Finally, you should repeat the process recursively, for the pointed to file. Here is the code that does it:

int recursive_deleter(const char* filename)
{
  struct stat st;
  char buffer[1024];

  if (lstat(filename, &st)) {
    perror("stat");
    return -1;
  }     

  if (st.st_mode & S_IFLNK == S_IFLNK) {
    memset(buffer, 0, sizeof(buffer));
    if (readlink(filename, buffer, sizeof(buffer)) < 0) {
      perror("readlink");
      return -1;
    }           

    printf("File %s is a symbolic link to %s\n", filename, buffer);

    if (recursive_deleter(buffer))
      return 0;
  }     

  printf("Deleting %s\n", filename);

  if (unlink(filename)) {
    perror("unlink");
    return -1;
  }     

  return 0;
}

Have fun!

Related posts:

1. Hex dump functions
2. Direct IO in Python
3. How less processes its input

When its not enough, you can always upgrade to open() and close() from os module. Opening man page on open() (the system call – open(2)) reveals all those O_something options that you can pass to os.open(). But not all of them can be used in Python. For example, if you open a file with O_DIRECT and then try to write to it, you will end up with some strange error message.

>>> import os
>>> f = os.open('file', os.O_CREAT | os.O_TRUNC | os.O_DIRECT | os.O_RDWR)
>>> s = ' ' * 1024
>>> os.write(f, s)
Traceback (most recent call last):
  File "", line 1, in
OSError: [Errno 22] Invalid argument
>>>

Invalid argument?. What invalid argument? Hey there’s nothing wrong with those arguments…

Reading open(2) man page further reveals that working with O_DIRECT requires that all buffers used for I/O should be aligned to 512 byte boundary. But how can you have a memory buffer aligned to 512 bytes in Python?

Apparently, there’s a way. Python comes with a module called mmap. mmap() is a system call that allows one to map portion of file into memory. All writes to memory mapped file, go directly to file despite it looks like you’re working with plain memory buffer. Same with reads.

There’s one interesting thing about mmap. It works with granularity of one memory page – 4kb that is. So every memory mapped buffer is naturally memory aligned to 4kb, thus to 512 byte boundary too. But hey, shouldn’t mmap map files?

Well, apparently mmap can be used for memory allocations. I.e. specifying -1 as file descriptor does just that – allocates RAM, as much as you tell it. So, this is what we do:

>>> import os
>>> import mmap
>>>
>>> f = os.open('file', os.O_CREAT | os.O_DIRECT | os.O_TRUNC | os.O_RDWR)
>>> m = mmap.mmap(-1, 1024 * 1024)
>>> s = ' ' * 1024 * 1024
>>>
>>> m.write(s)
>>> os.write(f, m)
1048576
>>> os.close(f)
>>>

Note that mmap memory buffer object behaves like a file. I.e. you can write into the buffer and read from it – like I do in line 8. More on it in official documentation.

Have fun!

Related posts:

1. What’s is direct I/O anyway?
2. Call a constructor or allocate an object in-place
3. Recursively deleting symbolic link and what it points to

Anyway, here’s something else that I learned during one of the interviews.

I was asked to implement insertion into a linked list in C. Each list node has a number (num). Numbers in the list should be sorted in ascending order – node with lowest number should be first. Here is my naive implementation.

void list_insert(int num)
{
        list_node_t *n, *tmp, *prev;

        n = allocate_node();
        n->num = num;

        if (!head) {
                head = n;
                n->next = NULL;
        } else {
                tmp = head;
                prev = NULL;
                while (tmp) {
                        if (tmp->num >= n->num) {
                                if (prev == NULL) {
                                        head->next = n;
                                        n->next = NULL;
                                } else {
                                        n->next = tmp;
                                        prev->next = n;
                                }

                                break;
                        }

                        prev = tmp;
                        tmp = tmp->next;
                }

                if (!tmp) {
                        n->next = NULL;
                        prev->next = n;
                }
        }
}

Yeah, well it is pretty long, but that’s how you do it, right? You have to make sure that the list is not empty (line 8 ) – if it is empty, then new node should be placed at the head of the list. Then we have to find right place for the new node and insert it into its position (lines 14-29). Finally, if we didn’t find a good position for the new node, we should put the node at the end of the list (lines 31-34).

When I showed this to the examiner he asked me to rethink the routine. In particular he didn’t like number of if statements. After an hour of discussing various optimizations, this is what we came up with.

void list_insert(int num)
{
        list_node_t **tmp, *n;

        n = allocate_node();
        n->num = num;

        tmp = &head;
        while (*tmp) {
                if ((*tmp)->num >= n->num)
                        break;
                tmp = &(*tmp)->next;
        }

/*
        (*tmp) = n;
       n->next = (*tmp)->next;
*/

/*
        The code in the comment above is broken. Thanks to jagan
        for pointing this out. Here's the right code.
*/
        n->next = *tmp;
        *tmp = n;
}

There are several things that make this version better.

First of all, instead of having a pointer to current node (tmp) and previous node (prev), we have one pointer that corresponds to pointer to previous node. This way we can always get to the current node via next field in the previous node. Thus we don’t need two pointers anymore.

Also, this version uses pointer to pointer to node to traverse through the list. We don’t insert the node in the while loop anymore. Purpose of the while loop is to find right place for the new node. This spares if statement that tests if the list is empty and if statement in the loop.

Finally, once tmp points to the right place, we insert the node.

Second version runs faster too. I did a small program that tests both versions and it appears that the later version is something like 5% faster.

Related posts:

1. pthread mutex vs pthread spinlock
2. Todo list

In case you don’t know, this is the program behind large portion of the Linux command line. It is the program that actually makes majority of work turning Linux command line into such a magnificent tool it is.

As for use frequency, on my computer the only program that beats it is perhaps a web browser. I use it more often than mail client, text processor or just any other program.

Now, one thing that entertains me is that there is absolutely no hype around bash. I mean, you probably know that next version of Firefox coming tomorrow (I am writing this on June 9th, 2009). But do you know when next version of bash is coming? Do you even know what is the version of bash that you currently use? Well, you are not alone – I have no clue either

One thing that concerns me is that bash almost didn’t change for the last ten years. I mean the only new feature that, to my knowledge, it didn’t support ten years ago is bash_completion – that is the advanced version of plain completion that it does to files. I could be wrong about this of course, but one thing is certain. Whatever the changes are, they are unnoticeable.

So, I thought that I’d compile a list of features that I would like to see in the upcoming version of bash. Now really, if only one of them would become a reality, I’d chew my pair of orange Crocs (I do have a pair of orange Crocs), put it on video and post it on youtube. Alright, I won’t do that. But it would still be very nice to see these happening.

The list:

1 – History sharing

I often open multiple shells. It would be really nice to be able to synchronize history between them. Right now, it seems that bash writes history file when it shuts down. If you open another session after history has been saved, you can access commands that you’ve typed in in the previous session. Otherwise, the history between two sessions is completely independent. Not good.

2 – Completion of directory and file names based on their usage

I think that 90% of cd‘s that I do are all destined to the same directory. Why on earth I see the list of possible destination for cd in alphabetical order every time I press TAB?

3 – Completion of make targets

I know this has already been implemented. But I am wondering why it isn’t part of bash_completion package on Ubuntu. OpenSuSE is no better – it does completion only to some yast stuff.

4 – Show a browseable and searchable list of files when hitting TAB key twice

I guess you all know that. Single TAB key completes a word if it can make a single match. Double TAB shows a list of choices for completion. In case the list is too long, it builds a long list and pipes it through more.

What I would like to see is a browseable and searchable list. One that I can browse with arrow keys. I also would like to be able to enter portion of the file name and in that case bash should filter out everything that doesn’t match the criteria I’ve entered.

5 – Completion of scp, on remote host

I guess it happened to all of us. Copying file to a remote computer with scp, is always difficult because you actually have to remember the path on remote computer. Wouldn’t it be great if bash could complete remote paths as well?

Now, I know this is very difficult to implement. Basically you have to spawn ssh with ls command, wait for it to complete and parse the results. Oh and there is a password thing. You gotta take care of password prompt that ssh may produce. Have no idea how to solve this issue. I do see a couple of options, but all of them are far from being ideal.

6 – Fix typos

This one is simple. As long as I don’t hit the TAB key, no need to fix anything. Once I hit the TAB key, shell should check if the command I’ve entered makes sense and if not try to fix it. Good example of what could make sense are file names. vi <filename> probably means that you want to edit a file. If the file does not exist and yet there’s another file with almost identical name, fix it. Same with cd. You don’t cd into directories that don’t exist. So once shell detects an attempt to do so and the user asks for help (by pressing the TAB key), shell can fix the typo and make the user smile.

This is it. I hope to see any of these happening one day. In the meantime, enjoy the list and by all means leave comments with your ideas of bash enhancements.

Related posts:

1. One sane voice in the crowd
2. Creating new application on top of SSH
3. Is desktop Linux too fragmented to succeed?

Before considering the code below, please note that spinlocks are totally useless on uni-processor computers. This is due to a nature of spinlocks, which I will describe in future posts.

Also, it is not the intent of this article to show that spinlocks better than mutexes in all circumstances. Spinlocks perform better than mutexes in this particular setup, on multi-processor computer. It does not mean that spinlocks are good for you. Apply your own judgment when considering using materials presented in this article for your needs.

In this article I would like to demonstrate you how spinlocks are more efficient than mutexes. I’ll demonstrate a program that does the following.

It builds a list of integers and then starts two threads, each removing entries from the list. Since both threads work with the same list at the same time, list has to be protected with synchronization mechanism of some kind.

Depending on whether the program has been compiled with USE_SPINLOCK or not, it will use a spinlock or a mutex to protect the list. In any case, it will display number of seconds that has passed from the moment threads has been started, until they finish.

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include <sys/time.h>

#include <list>

#define LOOPS 10000000

using namespace std;

list<int> the_list;

#ifdef USE_SPINLOCK
pthread_spinlock_t spinlock;
#else
pthread_mutex_t mutex;
#endif

pid_t gettid() { return syscall( __NR_gettid ); }

void *consumer(void *ptr)
{
    int i;

    printf("Consumer TID %lu\n", (unsigned long)gettid());

    while (1)
    {
#ifdef USE_SPINLOCK
        pthread_spin_lock(&spinlock);
#else
        pthread_mutex_lock(&mutex);
#endif

        if (the_list.empty())
        {
#ifdef USE_SPINLOCK
            pthread_spin_unlock(&spinlock);
#else
            pthread_mutex_unlock(&mutex);
#endif
            break;
        }

        i = the_list.front();
        the_list.pop_front();

#ifdef USE_SPINLOCK
        pthread_spin_unlock(&spinlock);
#else
        pthread_mutex_unlock(&mutex);
#endif
    }

    return NULL;
}

int main()
{
    int i;
    pthread_t thr1, thr2;
    struct timeval tv1, tv2;

#ifdef USE_SPINLOCK
    pthread_spin_init(&spinlock, 0);
#else
    pthread_mutex_init(&mutex, NULL);
#endif

    // Creating the list content...
    for (i = 0; i < LOOPS; i++)
        the_list.push_back(i);

    // Measuring time before starting the threads...
    gettimeofday(&tv1, NULL);

    pthread_create(&thr1, NULL, consumer, NULL);
    pthread_create(&thr2, NULL, consumer, NULL);

    pthread_join(thr1, NULL);
    pthread_join(thr2, NULL);

    // Measuring time after threads finished...
    gettimeofday(&tv2, NULL);

    if (tv1.tv_usec > tv2.tv_usec)
    {
        tv2.tv_sec--;
        tv2.tv_usec += 1000000;
    }

    printf("Result - %ld.%ld\n", tv2.tv_sec - tv1.tv_sec,
        tv2.tv_usec - tv1.tv_usec);

#ifdef USE_SPINLOCK
    pthread_spin_destroy(&spinlock);
#else
    pthread_mutex_destroy(&mutex);
#endif

    return 0;
}

Lets see how this little program works in greater detail. main() starts with initialization of a mutex or a spinlock, in lines 67-71. Next it initializes the list. Number of entries it will push into the list depends on LOOPS definition from line 10. Finally, in lines 77-81 it measures current time and spawns two threads. Then it waits for both threads to finish their job.

The thread, between lines 24 and 56, runs in a loop and pops entries from the list. Once the list is empty, thread exits. Each iteration of the loop it locks the mutex/spinlock and then unlocks it (lines 32-36 and 51-55).

Once both threads are over, main() will measure the time again and print difference between two measurements. This difference is how we measure effectiveness. The less time it took to run, the better.

Lets run the code and see how it performs, first with mutex and then with spinlock.

~/lab/mutex-vs-spinlock --> g++ -Wall -pthread main.cc
~/lab/mutex-vs-spinlock --> ./a.out
Consumer TID 19602
Consumer TID 19603
Result - 7.99794
~/lab/mutex-vs-spinlock --> g++ -DUSE_SPINLOCK -Wall -pthread main.cc
~/lab/mutex-vs-spinlock --> ./a.out
Consumer TID 19610
Consumer TID 19611
Result - 2.587424
~/lab/mutex-vs-spinlock -->

As we can see, the picture is clear. We can see that using spinlock, it took 2.5 seconds to complete the test. However when used mutex, it took almost 8 seconds to complete. This is 3 times more time.

This proves that the spinlock is more effective in term of CPU consumption and speed.

Related posts:

1. pthread spinlocks
2. Do you need a mutex to protect an int?
3. Multithreaded simple data type access and atomic variables

The article argues that the fragmentation is what keeping Linux Desktop from beating Mac OS and even Windows. It is because the effort to create Linux desktop is scattered across multiple distribution, it cannot become a serious player in desktop solutions.

Toward its end, the article gives optimistic prospects. There are some efforts to bring Linux desktop community to common ground, unanswered though.

This is so wrong

The truth is that are some points in the article that made my eyebrows go up. You see, having single desktop Linux distribution is impossible. This is against the nature of Linux and how its being distributed.

To get it moving you have to talk big distributors into this. But for big distributors, their desktop solution is one way or another their selling point. RedHat compete with Novell through Fedora and OpenSuSE. Moreover, they don’t want common ground. They want to compete.

Small distributions want their piece of the big cake too. Asking them to provide the same desktop solution would be as asking them to close their business – if they wanted to be a part of joined effort to make the world better place and Linux better desktop OS, people behind the distro could simply join someone else’s project.

Actually, this entire idea seems to be taken from socialism. We take something from everyone and create something that everyone would use. Sounds great, but this creates so called moral hazards. This strips away the will of competition. And competition is the driving force behind many of the technological marvels that we see today in general and in Linux in particular.

The only way to improve Linux’s position in desktop market is

to invest money into development of better Linux desktop.

Actually the author of the article was addressing the same issue, but from different angle. Linux desktop needs money. It needs more graphical designers, more QA engineers and more software engineers.

It straggles to become a serious desktop operating system because no one did usability testing. Because no one hired best UI designers, as Apple did. Because no one had hired enough QA engineers to make sure that all the software indeed works.

One way to overcome this problem is indeed by combining the effort. The problem is that Fedora isn’t there to beat Windows in desktop OS market. Fedora is a beta version of RedHat’s server systems. Same can be said about OpenSuSE, Ubuntu and most of the Linux distros.

Obviously money can be spent on nothing useful. Hundred engineers will not do in one month what ten engineers do in ten month. However, financing creates opportunity. And opportunity is exactly what Linux desktop needs.

Related posts:

1. Ubuntu 9.04 with Wubi – Failure
2. What kept me from sticking to Ubuntu as a desktop solution
3. 6 things that I miss in bash

Wubi is a program that installs Ubuntu Linux on top of installed Windows. I already had a Windows installation on my laptop, that I didn’t want to destroy. This is why I’ve chosen Wubi. It places root file-system in a file on Windows partition. Because of this feature, you don’t even need a partition to install Ubuntu.

What got me into this

What got me into Linux desktop frenzy this time, is Vista’s slowness. We all know various virtues of Microsoft’s operating systems. But installing Linux desktop instead… Silly me. It took me just four hours to figure out that I am better with slowness. Four hours I usually don’t have.

I am full of respect to developers of Linux. I work with Linux and develop for it for many years and I think this is a great server platform, unmatched by any other OS. But, Linux desktop is unfortunately isn’t too mature to be a serious match for Windows as a Desktop OS.

Knowing this from my previous attempts to install Linux desktop, I tried a less destructive option out of all. That is, Wubi doesn’t change your existing Windows installation. It install Ubuntu Linux as if it was another Windows program.

Installing Wubi

Problems started with Wubi itself. I live in Israel and although I use English version of Vista, Wubi installation has decided that I am better with Hebrew. Entire installation procedure was in Hebrew.

Next, despite I explicitly told Wubi that I want English version of Ubuntu, it installed Hebrew version. I checked on Wubi’s web-site and it appeared someone reported this particular bug just few days before. And it already had a solution – developers presented a new revision of Wubi which wasn’t yet publicly available, but solved the problem. The installation interface language remained Hebrew, but at least it installed English version of Ubuntu.

Now in case you wonder why I had to reinstall entire operating system just because of interface language, I’ll explain you. You see, I am not very familiar with Ubuntu’s graphical interface and I didn’t know how to configure wireless network. Hebrew interface made it even more complicated for me, so I decided to get things right form the start and not to begin tackling problems on unfamiliar ground.

On the other hand, because I didn’t have internet access, I could not just install English support it as I would do otherwise.

Now to Ubuntu

My next task, after installing the Linux itself, was to configure wireless network. The installation program did detect both wired and wireless card. However, the network interfaces configuration program didn’t show the wireless interface – only the wired. Luckily, simply pressing Add solved the problem. New dialog, popped up, asking me what is my SSID.

I am lucky to have some background in wireless networking, otherwise I would not know what SSID is. In case you’re wondering, this is the name of your wireless network. Anyway, it appeared that I’ve forgotten name of my wireless network and I had to use my cell. phone (which luckily supports wi-fi) to find the name. Not to mention I’ve absolutely forgotten that I’ve used WPA2-PSK security for my network. I had to choose it manually too, but before that I had to investigate it with my cell. phone.

I must say that Ubuntu could ship a program that scans for wireless networks, but it just wasn’t there.

On the bright side, once I entered right values for SSID and encryption, it got connected immediately.

The breaking point

The next thing I planned to do was mounting my Windows partitions. Somehow mounting my C: drive wasn’t that difficult. The desktop was empty. I right clicked on it, created a new directory and then double clicked on it. It opened gnome file explorer. Then I pressed the computer button and here they were, my CD-ROM and C: drive. Clicking on C: drive, created a C: drive icon on the desktop and I could safely delete the directory I created, knowing that I can always open gnome explorer by clicking on C: drive icon.

Now I know that there are several ways of opening gnome explorer, but I just couldn’t find them.

Anyway, note that I have two partitions and gnome explorer only showed me one of them. It appeared to me that something is wrong with D: drive and I should try to mount it. I went to Add/Remove programs and added a program called Disk Management. It seemed logical to me that I need some program that manipulates disks, so I searched for disk and found that Disk Management program. However, once I started it, it reported that I don’t have disks at all.

This was the breaking point. Playing around with Ubuntu was fun, but I had to stop and go back to the world of productivity – where at least sometimes things work.

Conclusion

Linux is a great operating system and like I mentioned I feel lots of respect to developers of Ubuntu and Linux for the job they are doing. This is especially true because I owe my income to Linux, for the last decade. Linux has given me a profession and I am grateful for that. However it seems that, regrettably, Ubuntu, one of the the undoubtful leaders among Linux distributions, is still too immature as a Desktop solution. Too many things are not obvious. Too many things just don’t work out of the box. Yes I could find a solution for everything, but I am just too busy person to search solutions for everything.

Related posts:

1. Is desktop Linux too fragmented to succeed?
2. What kept me from sticking to Ubuntu as a desktop solution
3. Few thoughts about Ubuntu servers and CentOS

Few weeks ago I was looking for a way to programatically send myself SMS on certain occasions. I was (and still) developing a system that would check for certain conditions on a server and alert me when something is wrong.

Eventually, I came up with a Python script, 40 lines long Note that you have to pay for the messages, but thats just few pennies. I bet there’s a way to plug into ICQ’s protocol and send SMS for free, but I don’t think you can do this with only 40 lines of code.

Here is the idea. There are firms on the internet, that provide service called SMS gateway. These firms has special devices plugged into GSM network on one end and has some programmable interface on the other end.

Here’s what you do. You open an account with such a firm. Then you either pay for one message or buy some credits and then spend them by sending messages.

SMS gateway I used called world-text. Please, by all means I have nothing to do with these guys. I found them on the internet, just as you would.

There are couple of nice things about this particular company, although I bet if you spend some time researching you will find a better and probably cheaper one.

I don’t think there’s a standard for SMS gateways. Each company does something of its own. World-text provide web based gateway and this is what makes it so easy to use with Python.

Python code that I’ve written, simply sends properly formatted HTTP request to their web interface. Here’s the code.

#!/usr/bin/python

import sys
import time
import glob
import httplib
import urllib

recepients = []

recepients.append("-------------")

world_text_username = "your@email.com"
world_text_password = "your password"

def usage():
    print "alertme.py <message to send>"
    sys.exit(0)

def send_sms(msg):
    global recepients, world_text_username, world_text_password

    print "Asked to send sms: %s" % msg

    for r in recepients:
        params = ""
        params = params + "username=" + world_text_username
        params = params + "&password=" + world_text_password
        params = params + "&" + urllib.urlencode({'message': msg})
        params = params + "&sourceaddr=SMSAlert"
        params = params + "&mobile=" + r
        headers = {"Content-Type": "application/x-www-form-urlencoded"}
        conn = httplib.HTTPConnection("sms.world-text.com:1081")
        conn.request("POST", "/sendsms", params, headers)
        conn.close();

if len(sys.argv) != 2:
    usage()

send_sms(sys.argv[1])

To use the script, just append your phone number, including country and regional code to the recepients list – make sure to delete the “———-” from it. Next change world_text_username and world_text_password to something meaningful and you are ready to bombard yourself with SMS messages

In case you have further questions, email me at alex@alexonlinux.com.

Have fun!

Related posts:

1. Direct IO in Python
2. Python’s optparse for human beings