Index of /ubuntu/pool/intrepid/i386

	Name	Last modified	Size	Description
	Parent Directory		-
	camllight_0.77rc1-3_i386.deb	31-Oct-2008 09:07	1.8M
	lineo_0.3-4_i386.deb	31-Oct-2008 09:07	4.4M
	php5-dbase_5.2_i386.deb	31-Oct-2008 09:07	19K

Apache/2.2.3 (Debian) Server at boisson.homeip.net Port 80

Analyze Your Email Usage with Mail Trends

Managing the daily onslaught of incoming email with filing systems, keyboard shortcuts, and batch processing will only get you so far. When a flurry of new email snows you in within an hour of every inbox sweep, it's time to dig in and get to the source of your email traffic. You've accumulated a sizable email archive over the years, and a new breed of analysis tool can extract meaningful statistics from that data to help you conquer email overload. Who sent you the most email messages last year? What hour of the day do you receive the most new messages? Which of all the mailing lists you're on are the most active? A new command line tool called Mail Trends works with Gmail over IMAP and can give you all that information and more.

Let's take a look at what Mail Trends tells you and how to run it on your Gmail account.

What you'll need

To start analyzing your email usage with Mail Trends, you'll need:

• A Gmail account (Google Apps Gmail accounts work too) with IMAP access enabled.
• 
  
• The Python software. (Windows users, download and install it from here; Mac/Linux folks, you've already got it installed. I tested Mail Trends using Python 2.5 without problems.)
• 
  

What you'll get

After you run Mail Trends from the command line with Python, you'll get a regular web page full of interesting information about your email usage. Mail Trends logs into your Gmail account, grabs the "message headers" (sender, recipient, subject, date) from your Gmail "All Mail" folder, and generates charts and lists with statistics.

See an example of Mail Trends charts based on a set of email from Enron employees.

My Mail Trends results reveal a few too many email addresses to post in full, but here's my daily email traffic chart, which shows I receive the most email around 10-11AM each day:

Here's what the month of March 2008 looked like on my personal Gmail account. Notice the lower activity on weekends. (Not surprising.)

When I ran Mail Trends on my Lifehacker email account, I wasn't surprised to find out that Adam is my most frequent sender and recipient. However, people listed a few lines down on my Top Sender and Top Recipient list did surprise me. Who you email and how often can give you interesting insight into your communication habits.

What's the point?

While it may seem like self-indulgent data-wanking, Mail Trends and tools like it can help you make informed decisions about how you handle email. For instance, you may find out that the person you send the most email to is your co-worker two cubicles down—and decide to meet in person on a regular to discuss more things offline. If that mailing list you lost interest in months ago is generating a lot of inbox traffic, you could unsubscribe. If you want to process your email in batches, at certain times of day, you could use Mail Trends' time of day chart to figure out what hour brings the most email to your inbox on average, and schedule your processing time around it.

Setting up Mail Trends

Before we start with Mail Trends, know that this is a command line operation using the Python scripting language. Judging from the comments on the project homepage, some users have run into kinks setting it up (though I got it down with just a couple of tries.) Comfort with the command line and a little past experience with Python will make using Mail Trends easier. If that all doesn't sound like your cup of tea, check out the lower section on easier-to-setup alternatives to Mail Trends.

Still with me? Ok, assuming you've already got Python installed on your machine, here's how to get Mail Trends going. (Note: these instructions assume you know how to navigate directories from the command line. See also Mail Trend's Getting Started page.)

1. Download and extract Mail Trends to a convenient directory on your computer. Using your command line, cd into that directory.
2. Download Cheetah, a template package Mail Trends needs to work. Install it by changing to the Cheetah directory and using the following command:
   python setup.py install
   (Mac users: you may have to prefix that command with sudo.
   Windows users: download the compiled version of Cheetah's NameMapper here. Save to the Cheetah directory—by default, C:\Python25\Lib\site-packages\Cheetah and remove the version from the filename so it's just _namemapper.pyd.)
3. Now, cd into the mail-trends directory, and execute the Mail Trends command. See the Getting Started page for a rundown of the options. I used the following command:
   python main.py —server=imap.gmail.com —use_ssl —username=example@gmail.com —me=example@gmail.com —skip_labels
   Make sure you substitute example@gmail.com with your email address. (Note: Our publishing system turns double dashes into em dashes; so make sure you have two dashes before the server, use, username, me, and skip_labels parameters.)
4. If all goes well, Mail Trends will start up and prompt you for your Gmail password. Enter it, and watch the program go. Mail Trends speed will depend on how fast your machine and network connection is and how many messages you've got in your account. The first time I tried Mail Trends it hung up at about 24,000 messages. When I restarted it, it completed successfully—on both Mac and Windows, and both a vanilla Gmail account and Google Apps account.

Note that you can tell Mail Trends what addresses you send mail from (using the me= parameter, and also exclude mail based on criteria (like --filter_out=to:tips@lifehacker.com.) Play with the program options to come up with the best recipe for your Gmail setup.

Once Mail Trends completes processing, simply open the mail-trends/out/index.html file in your favorite web browser to check out your charts and lists.

Other email analysis tools

Previously mentioned Outlook plugin Xobni is still in invite-only beta, but it looks like one of the best up and coming email analysis tools for Outlook users. Check out the video below for a Xobni demo.

The Seek Thunderbird extension adds "faceted search" to the 'bird. While it doesn't generate usage reports a la Mail Trends, it does list frequency numbers based on date and recipient as you search. Here's a video demo of Seek:

Have you given Mail Trends or other similar tools a run on your email archive? Find out anything interesting? Tell us about it in the comments.

Gina Trapani, the editor of Lifehacker, is cutting off email overload at the source. Her weekly feature, Geek to Live, appears every Monday on Lifehacker. Subscribe to the Geek to Live feed to get new installments in your newsreader.

MMARated Radio was rolling with the big dogs today as we welcomed Donald Trump Jr. (left) to the program to talk, what else, Affliction.

Some of the topics we touched on included:

* His role with Affliction

* Why did the Trumps decided to get involved in MMA?

* Why not build their own promotion?

* His take on the inaugural show

* An update on the Tito Ortiz situation

* Was he surprised at how much Ortiz demanded?

* Will Affliction look to secure a network television deal (potentially with NBC)?

* The thought process behind Affliction's large payroll

* What we can expect from "Day of Reckoning" on October 11th

Minimal Wordpress Theme

Delete Files Older Than x Days on Linux

The find utility on linux allows you to pass in a bunch of interesting arguments, including one to execute another command on each file. We'll use this in order to figure out what files are older than a certain number of days, and then use the rm command to delete them.

Command Syntax

find /path/to/files* -mtime +5 -exec rm {} \;

Note that there are spaces between rm, {}, and \;

Explanation

• The first argument is the path to the files. This can be a path, a directory, or a wildcard as in the example above. I would recommend using the full path, and make sure that you run the command without the exec rm to make sure you are getting the right results.
• The second argument, -mtime, is used to specify the number of days old that the file is. If you enter +5, it will find files older than 5 days.
• The third argument, -exec, allows you to pass in a command such as rm. The {} \; at the end is required to end the command.

This should work on Ubuntu, Suse, Redhat, or pretty much any version of linux.

GNU’s wget command line program for downloading is very popular, and not without reason. While you can use it simply to retrieve a single file from a server, it is much more powerful than that and offers many more features.

One of the more advanced features in wget is the mirror feature. This allows you to create a complete local copy of a website, including any stylesheets, supporting images and other support files. All the (internal) links will be followed and downloaded as well (and their resources), until you have a complete copy of the site on your local machine.

In its most basic form, you use the mirror functionality like so:

$ wget -m http://www.example.com/

There are several issues you might have with this approach, however.

First of all, it’s not very useful for local browsing, as the links in the pages themselves still point to the real URLs and not your local downloads. What that means is that, if, say, you downloaded http://www.example.com/, the link on that page to http://www.example.com/page2.html would still point to example.com’s server and so would be a right pain if you’re trying to browse your local copy of the site while being offline for some reason.

To fix this, you can use the -k option in conjunction with the mirror option:

$ wget -mk http://www.example.com/

Now, that link I talked about earlier will point to the relative page2.html. The same happens with all images, stylesheets and resources, so you should be able to now get an authentic offline browsing experience.

There’s one other major issue I haven’t covered here yet - bandwidth. Disregarding the bandwidth you’ll be using on your connection to pull down a whole site, you’re going to be putting some strain on the remote server. You should think about being kind and reduce the load on them (and you) especially if the site is small and bandwidth comes at a premium. Play nice.

One of the ways in which you can do this is to deliberately slow down the download by placing a delay between requests to the server.

$ wget -mk -w 20 http://www.example.com/

This places a delay of 20 seconds between requests. Replace that number, and optionally you can add a suffix of m for minutes, h for hours, and d for … yes, days, if you want to slow down the mirror even further.

Now if you want to make a backup of something, or download your favourite website for viewing when you’re offline, you can do so with wget’s mirror feature. To delve even further into this, check out wget’s man page (man wget) where there are further options, such as random delays, setting a custom user agent, sending cookies to the site and lots more.

RarCrack Opens Protected Archives Without Passwords

Adjust Volume of Individual Applications with PulseAudio

Index of /Tests/Tutorial

File	Rev.	Age	Author	Last log entry
Parent Directory
Step1/
Step2/
Step3/
Step4/
Step5/
Step6/
Step7/

POTATOES

An old man lived alone in the country. He wanted to dig his potato garden but it was very hard work as the ground was hard. His only son Fred, who used to help him, was in prison. The old man wrote a letter to his son and described his predicament.

Dear Fred,
I am feeling pretty bad because it looks like I won't be able to plant my potato garden this year. I'm just getting too old to be digging up a garden plot. If you were here, all my troubles would be over I know you would dig the plot for me.
Love,
Dad

A few days later he received a letter from his son.

Dear Dad,
For heaven's sake, don't dig up that garden! That's where I buried the BODIES!
Love,
Fred

At 4am the next morning, FBI agents and local police arrived and dug up the entire area without finding any bodies. They apologized to the old man and left. That same day the old man received another letter from his son.

Dear Dad,
Go ahead and plant the potatoes now. That's the best I could do under the circumstances.
Love,
Fred

Karen Reid

Lecturer in Department of Computer Science at the University of Toronto.

TA Training

Courses Taught

Fall 2002

• csc150 Accelerated Introduction to Computer Science
• csc209 Software Tools and Systems Programming

Research

The general area of my research is in resource management for clusters of computers. I have been looking at how to more efficiently transfer large data sets from external storage servers onto the local disks of the cluster for use during computation.

"Overlapping Data Transfer With Application Execution on Clusters", Karen Reid and Michael Stumm appeared in the Workshop on Cluster Based Computing at ICS 2000. (postscript, pdf )

Address

E-Mail: reid@cs.utoronto.ca (Current students should use the course specific email address.)

Office: BA 4240
Dept Phone: (416) 978-6025
Fax: (416) 978-1931
Office Phone: (416) 978-7797

Jonathon Edington

Walmart Growth Video

March 20th, 2008 toby |

Trac on Ubuntu ¶

These instructions were written for a fresh install of Ubuntu. This documentation suggests performing custom install when installing Ubuntu to create a base system without an X server or other graphical niceties. These instructions, however, should work reasonably well if you already have Ubuntu installed or you have performed a full install.

Breezy users: See comments below for some of the problems encountered.

Dapper users: should work fine with the following instructions.

Note: For an alternative Ubuntu experience, using apache and configuring for multiple projects, see TracUbuntuMultipleProjects

Also see: https://help.ubuntu.com/community/UbuntuTracHowto

Installation ¶

1. Install Software Packages ¶

To install Trac on your system, install the trac and libapache2-svn packages:

sudo apt-get install trac apache2 libapache2-svn

2. Create the Trac Environments Directory ¶

You'll need a directory for Trac's environments to live that should be writable by the default Apache user:

sudo mkdir /var/lib/trac
sudo chown www-data:www-data /var/lib/trac

If you put your environment somewhere else, make sure to note that and use that location in the appropriate places in the next step.

3. Setup Apache2 ¶

Next, create a new Apache-2 virtualhost by saving the following as /etc/apache2/sites-available/trac :

<VirtualHost *>
        ServerAdmin webmaster@localhost
        ServerName trac.example.com
        DocumentRoot /usr/share/trac/cgi-bin/
        <Directory /usr/share/trac/cgi-bin/>
                Options Indexes FollowSymLinks MultiViews ExecCGI
                AllowOverride All
                Order allow,deny
                allow from all
        </Directory>
        Alias /trac "/usr/share/trac/htdocs"

        <Location /trac.cgi>
            SetEnv TRAC_ENV "/var/lib/trac/YourProjectNameHere"
        </Location>

        DirectoryIndex trac.cgi
        ErrorLog /var/log/apache2/error.trac.log
        CustomLog /var/log/apache2/access.trac.log combined
</VirtualHost>

Note: If you get errors later that pertain to environment look at SetEnv TRAC_ENV. You can also use SetEnv TRAC_ENV_PARENT_DIR "/var/lib/trac" to host multiple projects.

You also need to uncomment the AddHandler line in /etc/apache2/apache2.conf so that the Trac CGI program will be executed:

# To use CGI scripts outside /cgi-bin/:
#
AddHandler cgi-script .cgi

Now, disable the default virtualhost, enable the Trac virtualhost, and restart Apache2:

sudo a2dissite default
sudo a2ensite trac
sudo  /etc/init.d/apache2 reload 

If you are going to want to login, you're going to need authentication. I added the following to my virtual host file to get this to work:

        <Location "/trac.cgi/login">
            AuthType Basic
            AuthName "Trac"
            AuthUserFile /etc/apache2/dav_svn.passwd
            Require valid-user
        </Location>

This will share the password with your subversion install. You'll also need to grant each user rights using trac-admin.

Alternately, you can use htpasswd to create an htpasswd file, and point AuthUserFile? at that location.

4. Creating Environments ¶

I installed my Subversion repository at /var/lib/svn/YourProjectNameHere. So I did a quick starting config of subversion with the following commands:

sudo mkdir /var/lib/svn
sudo mkdir /var/lib/svn/YourProjectNameHere
sudo mkdir /tmp/YourProjectNameHere
sudo mkdir /tmp/YourProjectNameHere/branches
sudo mkdir /tmp/YourProjectNameHere/tags
sudo mkdir /tmp/YourProjectNameHere/trunk
sudo svnadmin create /var/lib/svn/YourProjectNameHere
sudo svn import /tmp/YourProjectNameHere file:///var/lib/svn/YourProjectNameHere -m "initial import"
sudo rm -rf /tmp/YourProjectNameHere

Some permissions changes and an apache restart are now needed:

sudo chown -R www-data /var/lib/svn/YourProjectNameHere
sudo chown -R www-data /usr/share/trac
sudo apache2 -k restart

Test by web-browsing to http://servername/svn/YourProjectNameHere

If you see a simple web page which says Revision 1: / and lists branches, tags, and trunk, your Subversion install is up and running!

Here's what to do if you see 404 Not Found

Check you Subversion installation, specifically /etc/apache2/mods-available/dav_svn.conf and make sure you really have a valid configuration. Still having problems see Ubuntu SVN documentation

Now let's finish the Trac install (but don't go on to Trac install until you have the above working properly).

I put my trac environment at /var/lib/trac/YourProjectNameHere. Of course you could use any other path or name - something a little more descriptive of your project would probably be a good idea. First I ran these commands:

sudo mkdir /var/lib/trac
sudo trac-admin /var/lib/trac/YourProjectNameHere initenv
sudo chown -R www-data /var/lib/trac/YourProjectNameHere

The "trac-admin" command shown above prompted me to enter:

• the project name (YourProjectNameHere)
• the path to svn repository (/var/lib/svn/YourProjectNameHere)
• the path to the Trac templates directory (/usr/share/trac/templates)

... then it prints out a bunch of stuff. If there are no errors you should now be able to surf to your Trac site at http://servername/trac.cgi

At the time I did my install, there was one glitch in the Ubuntu Universe Trac installer. It doesn't install the neo_cgi.so file needed in the python2.4 directory space. So when I surfed to my Trac site, I got the error ImportError: No module named neo_cgi. I was able to fix this by symlinking the python2.3 version like so:

sudo ln -s /usr/lib/python2.3/site-packages/neo_cgi.so /usr/lib/python2.4/site-packages/neo_cgi.so

Voila! Your Trac system & website should be up and running.

 http://reddit.com/user/earobinson/liked.rss

ac S -style ock n avaScript

Apple’s Mac OS X operating system is renowned for its fluid graphical effects. One impressive feature is the dock’s ‘fish-eye’ effect, whereby icons expand and contract as the mouse moves over them. Achieving this effect in JavaScript is difficult, but the MacStyleDock function allows this feature to be implemented easily. An example is shown below (a larger demonstration is available on a separate page).

Compatible browsers

The code has been tested and works in the following browsers:

• Firefox 1.5 on Mac OS X
• Firefox 2 on Ubuntu Linux
• Firefox 2 on Windows (slightly jerky due to event handlers being given a higher priority than intervals)
• Internet Explorer 6
• Internet Explorer 7
• Konqueror 3.5 on Ubuntu Linux
• Opera 9 on Windows
• Safari 2 on Mac OS X

Implementing the Mac-style Dock

File	Size	Description
MacStyleDock.js	6285 bytes	Full version with comments
MacStyleDock.compressed.js	2632 bytes	Compressed version

Download one of the files listed above and upload it to your website. Link to it from your page with code such as:

<script type="text/javascript" src="MacStyleDock.js"></script>

The code for the dock is added to the document tree under an existing node, so create an element to contain with code such as:

<div id="dock"></div>

The dock can then be created as a new JavaScript object. Note that the dock’s document tree node must already exist when the constructor is called. This can be done either by including the JavaScript code below the node in the document source, or by calling the constructor when the document has loaded — one way to do this is by using the OnloadScheduler.

The constructor takes five paramaters:

node

The node at which to create the Mac-style dock.

imageDetails

An array each of whose elements are object with three properties:

name

the basename of the image

sizes

an array of pizel sizes available

extension

the image extension

onclick

the function to call when the image is clicked

Requested file names consist of the concatenation of the name property, one of the values of the size property, and the extension property.

minimumSize

The minimum size of icons in the dock.

maximumSize

The maximum size of icons in the dock.

range

The range of expansion, measured in icons. This need not be an integer.

For example:

<script type="text/javascript" >
  var dock = new MacStyleDock(
      document.getElementById('dock'),
      [
        {
          name:      'mac-icon-0-',
          extension: '.jpg',
          sizes:     [32,64],
          onclick:   function(){
                       alert('You clicked on the first icon');
                     }
        },
        {
          name:      'mac-icon-1-',
          extension: '.jpg',
          sizes:     [32,64],
          onclick:   function(){
                       alert('You clicked on the second icon');
                     }
        }
      ],
      32,
      64,
      2.5);
</script>

Multiple icon sizes should be supplied for operating systems such as Windows that scale images poorly. The function will scale down the next larger image from the size it requires.

Further reading

If you’re looking for a JavaScript book, one of the best is the 1000-page JavaScript: The Definitive Guide by David Flanagan, published by O’Reilly and now in its fifth edition. It covers all aspects of JavaScript and details the most common browser compatibility issues that you may encounter:

• JavaScript: The Definitive Guide at Amazon.com
• JavaScript: The Definitive Guide at Amazon.co.uk (for British readers)

• Safalra’s Website
• Web Design
• JavaScript
• A Mac OS X-style Dock In JavaScript

The telecom company that carries most of Pakistan’s traffic, PCCW, has found it necessary to shut Pakistan off from the Internet while they filter out the malicious routes that a Pakistani ISP, PieNet, announced earlier today. Evidently PieNet took this step to enforce a decree from the Pakistani government that ISP’s must block access to YouTube because it was a source of blasphemous content.

I cannot let the irony pass with out commenting. A religious state, Pakistan, identifies a content provider, YouTube, as the source of blasphemous, seditious content and orders, King Canute style, that the Internet tides be stopped. A zealous ISP ignorantly decides the best way to comply with the decree is to re-route all of YouTube’s IP addresses to whatever site they thought was more appropriate. The first repercussion was that YouTube disappeared from the Internet for almost an hour. I suspect the second repercussion was that Pakistan’s Internet access crawled to a halt as all of a sudden they were handling IP requests for one of the busiest sites in the world. As of this writing YouTube has announced more granular routes so that at least in the US they supercede the routes announced by PieNet. The rest of the world is still struggling. So, while working on a fix that will filter out the spurious route announcements, PCCW has found it necessary to shut down Pakistan’s Internet access. The leadership of Pakistan just created a massive Denial of Service on their own country.

I could say: “be careful what you wish for” to those elements that object to free and open access to information and expression of ideas. But to put it in terms they might understand better: Do not anger the Internet gods or you will suffer their wrath!

Update:  This blog points out that the “blasphemous content” claim may be a red herring. There may be more political motivations behind it.

 http://www.flickr.com/photos/carlzimmer/sets/72157601351535771/detail/

"Linux Gazette...making Linux just a little more fun!"

Contents

1. Introduction

2. Overview of Client-Server Communications

3. Implementing a Simple Server and Client

3.1 Server - establishing a listening socket

3.2 Client - connecting to the server

3.3 Server - Accepting the client's connection attempt

3.4 Client and Server - sending and receiving data

4 Compiling and Testing Our Client and Server

4.1 File list

4.2 Compile and test

5. Conclusion

1. Introduction

Sockets are a mechanism for exchanging data between processes. These processes can either be on the same machine, or on different machines connected via a network. Once a socket connection is established, data can be sent in both directions until one of the endpoints closes the connection.

I needed to use sockets for a project I was working on, so I developed and refined a few C++ classes to encapsulate the raw socket API calls. Generally, the application requesting the data is called the client, and the application servicing the request is called the server. I created two primary classes, ClientSocket and ServerSocket, that the client and server could use to exchange data.

The goal of this article is to teach you how to use the ClientSocket and ServerSocket classes in your own applications. We will first briefly discuss client-server communications, and then we will develop a simple example server and client that utilize these two classes.

2. Overview of Client-Server Communications

Before we go jumping into code, we should briefly go over the set of steps in a typical client-server connection. The following table outlines these steps:

That's basically it. First, the server creates a listening socket, and waits for connection attempts from clients. The client creates a socket on its side, and attempts to connect with the server. The server then accepts the connection, and data exchange can begin. Once all data has been passed through the socket connection, either endpoint can close the connection.

3. Implementing a Simple Server and Client

Now its time to dig into the code. In the following section we will create both a client and a server that perform all of the steps outlined above in the overview. We will implement these operations in the order they typically happen - i.e. first we'll create the server portion that listens to the socket, next we'll create the client portion that connects to the server, and so on. All of the code in this section can be found in simple_server_main.cpp and simple_client_main.cpp.

3.1 Server - establishing a listening socket

The first thing we need to do is create a simple server that listens for incoming requests from clients. Here is the code required to establish a server socket:

#include "ServerSocket.h"
#include "SocketException.h"
#include <string>

int main ( int argc, int argv[] )
{
  try
    {
      // Create the server socket
      ServerSocket server ( 30000 );

      // rest of code -
      // accept connection, handle request, etc...

    }
  catch ( SocketException& e )
    {
      std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
    }

  return 0;
}

That's all there is to it. The constructor for the ServerSocket class calls the necessary socket APIs to set up the listener socket. It hides the details from you, so all you have to do is create an instance of this class to begin listening on a local port.

Notice the try/catch block. The ServerSocket and ClientSocket classes use the exception-handling feature of C++. If a class method fails for any reason, it throws an exception of type SocketException, which is defined in SocketException.h. Not handling this exception results in program termination, so it is best to handle it. You can get the text of the error by calling SocketException's description() method as shown above.

3.2 Client - connecting to the server

The second step in a typical client-server connection is the client's responsibility - to attempt to connect to the server. This code is similar to the server code you just saw:

#include "ClientSocket.h"
#include "SocketException.h"
#include <iostream>
#include <string>

int main ( int argc, int argv[] )
{
  try
    {
      // Create the client socket
      ClientSocket client_socket ( "localhost", 30000 );

      // rest of code -
      // send request, retrieve reply, etc...

    }
  catch ( SocketException& e )
    {
      std::cout << "Exception was caught:" << e.description() << "\n";
    }

  return 0;
}

By simply creating an instance of the ClientSocket class, you create a linux socket, and connect it to the host and port you pass to the constructor. Like the ServerSocket class, if the constructor fails for any reason, an exception is thrown.

3.3 Server - accepting the client's connection attempt

The next step of the client-server connection occurs within the server. It is the responsibility of the server to accept the client's connection attempt, which opens up a channel of communication between the two socket endpoints.

We have to add this functionality to our simple server. Here is the updated version:

#include "ServerSocket.h"
#include "SocketException.h"
#include <string>

int main ( int argc, int argv[] )
{
  try
    {
      // Create the socket
      ServerSocket server ( 30000 );

      while ( true )
	{
	  ServerSocket new_sock;
	  server.accept ( new_sock );

	  // rest of code -
	  // read request, send reply, etc...

	}
    }
  catch ( SocketException& e )
    {
      std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
    }

  return 0;
}

Accepting a connection just requires a call to the accept method. This method accepts the connection attempt, and fills new_sock with the socket information about the connection. We'll see how new_sock is used in the next section.

3.4 Client and Server - sending and receiving data

Now that the server has accepted the client's connection request, it is time to send data back and forth over the socket connection.

An advanced feature of C++ is the ability to overload operators - or simply, to make an operator perform a certain operation. In the ClientSocket and ServerSocket classes I overloaded the << and >> operators, so that when used, they wrote data to and read data from the socket. Here is the updated version of the simple server:

#include "ServerSocket.h"
#include "SocketException.h"
#include <string>

int main ( int argc, int argv[] )
{
  try
    {
      // Create the socket
      ServerSocket server ( 30000 );

      while ( true )
	{

	  ServerSocket new_sock;
	  server.accept ( new_sock );

	  try
	    {
	      while ( true )
		{
		  std::string data;
		  new_sock >> data;
		  new_sock << data;
		}
	    }
	  catch ( SocketException& ) {}

	}
    }
  catch ( SocketException& e )
    {
      std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
    }

  return 0;
}

The new_sock variable contains all of our socket information, so we use it to exchange data with the client. The line "new_sock >> data;" should be read as "read data from new_sock, and place that data in our string variable 'data'." Similarly, the next line sends the data in 'data' back through the socket to the client.

If you're paying attention, you'll notice that what we've created here is an echo server. Every piece of data that gets sent from the client to the server gets sent back to the client as is. We can write the client so that it sends a piece of data, and then prints out the server's response:

#include "ClientSocket.h"
#include "SocketException.h"
#include <iostream>
#include <string>

int main ( int argc, int argv[] )
{
  try
    {

      ClientSocket client_socket ( "localhost", 30000 );

      std::string reply;
      try
	{
	  client_socket << "Test message.";
	  client_socket >> reply;
	}
      catch ( SocketException& ) {}

      std::cout << "We received this response from the server:\n\"" << reply << "\"\n";;

    }
  catch ( SocketException& e )
    {
      std::cout << "Exception was caught:" << e.description() << "\n";
    }

  return 0;
}

We send the string "Test Message." to the server, read the response from the server, and print out the response to std output.

4. Compiling and Testing Our Client And Server

Now that we've gone over the basic usage of the ClientSocket and ServerSocket classes, we can build the whole project and test it.

4.1 File list

The following files make up our example:

Miscellaneous:

Makefile - the Makefile for this project

Socket.h, Socket.cpp - the Socket class, which implements the raw socket API calls.

SocketException.h - the SocketException class

Server:

simple_server_main.cpp - main file

ServerSocket.h, ServerSocket.cpp - the ServerSocket class

Client:

simple_client_main.cpp - main file

ClientSocket.h, ClientSocket.cpp - the ClientSocket class

4.2 Compile and Test

Compiling is simple. First save all of the project files into one subdirectory, then type the following at your command prompt:

prompt$ cd directory_you_just_created
prompt$ make

This will compile all of the files in the project, and create the simple_server and simple_client output files. To test these two output files, run the server in one command prompt, and then run the client in another command prompt:

first prompt:
prompt$ ./simple_server
running....



second prompt:
prompt$ ./simple_client
We received this response from the server:
"Test message."
prompt$

The client will send data to the server, read the response, and print out the response to std output as shown above. You can run the client as many times as you want - the server will respond to each request.

5. Conclusion

Sockets are a simple and efficient way to send data between processes. In this article we've gone over socket communications, and developed an example server and client. You should now be able to add socket communications to your applications!

Rob Tougher

Copyright © 2002, Rob Tougher.
Copying license http://www.linuxgazette.net/copying.html
Published in Issue 74 of Linux Gazette, January 2002

h
 

Are You a Cool "First Day" G1G1 Donor Too?

Posted on November 28, 2007 by Wayan Vota in Sales Talk: G1G1, Countries: USA, Laptops: XO-1

Sport a First Day Donor badge!

Are you this OLPC G1G1 cool? Did you just get a "first day" donor email from One Laptop per Child that says:

Thanks to your early action, your XO laptop is scheduled to be delivered between December 14 and December 24. Our "first day" donors are our highest priority and we are making every effort to deliver your XO laptop(s) as soon as possible. We will send you an update upon shipment.

If you did, give a shout out in the comments below with your order date. Let's see who is going to be the first kids on their block to get an OLPC XO laptop.

More G1G1 information

CANADA UPDATE: If you are a Canadian G1G1 participant but didn't get a FDD email, a commenter suggests you try calling OLPC G1G1 toll free at 1-877-705-2786 to confirm that your online PayPal payment has been received. A quick call to OLPC's donation line can get you a confirmation number and assurance of December 14-24 delivery.

FRAPPER MAP UPDATE: Thanks to Joe we now have a OLPC Community Frapper map

USA XO SHIPPING UPDATE If you are a G1G1 particpant in the USA, here's your shipping schedule. Sorry Canada.

The edges can be represented in Prolog as facts:

edge(1,2).
edge(1,4).
edge(1,3).
edge(2,3).
edge(2,5).
edge(3,4).
edge(3,5).
edge(4,5).

To represent the fact that the edges are bi-directional we could either add eight more 'edge' clauses (edge(2,1),etc.) or we could try a rule like:

 (*)      edge(X,Y) :- edge(Y,X).

This is not a good idea, however. To see why it is not a good idea, try the following goal.

?- edge(5,1).

Notice that the rule (*) will be tried over and over in an infinite loop, so the goal will not terminate. Try it! A better way to handle this is to use a rule such as the following.

connected(X,Y) :- edge(X,Y) ; edge(Y,X).

Note the use of disjunction ';' in this rule. This rule could have been written as two rules:

connected(X,Y) :- edge(X,Y).
connected(X,Y) :- edge(Y,X).

We wish to develop a Prolog definition which generates paths between any two nodes of the graph. More specifically, we require the following (kind of) behavior for the predicate 'paths'.

?- path(1,5,P).
P = [1,2,5] ;
P = [1,2,3,5] ;
P = [1,2,3,4,5] ;
P = [1,4,5] ;
P = [1,4,3,5] ;
P = [1,4,3,2,5] ;
P = [1,3,5] ;
P = [1,3,4,5] ;
P = [1,3,2,5] ;
no

The paths are represented by the list of nodes through which one must travel to get from node 1 to node 5. Here is a definition for paths:

path(A,B,Path) :-
       travel(A,B,[A],Q), 
       reverse(Q,Path).

travel(A,B,P,[B|P]) :- 
       connected(A,B).
travel(A,B,Visited,Path) :-
       connected(A,C),           
       C \== B,
       \+member(C,Visited),
       travel(C,B,[C|Visited],Path).  

Getting them installed in Ubuntu is a breeze, thanks to a script I found.
To install the Vista ClearType fonts in Ubuntu, you need to install cabextract first. Cabextract is a utility found in the universe repository, so before you run the following command, make sure you have universe enabled in your repository list. Once this is done, install cabextract using:
$sudo apt-get install cabextract

Then, once that is done, use this script to install the Vista fonts. Create a file called “vista-fonts-installer.sh” in your home (~) directory.
Then open up a text editor and copy and paste the script into that file.
Do a chmod a+x ~/vista-fonts-installer.sh to make the file/script executable.
Then run the script using:
$ ~/vista-fonts-installer.sh

The script downloads the Powerpoint Viewer installer from microsoft.com, and then extracts the Vista cleartype fonts using cabextract. These fonts are then installed in the ~/.fonts directory.

Please remember that the ClearType Vista fonts are not free as in they are not GPL-ed or made available under a re-distributable license. Since you are downloading the fonts from the MS website, and since you might already have a Windows XP/Vista license, this is not a crime, but consider yourself warned against the perils of supporting closed systems

Update::

1. Looks like the use of these fonts are restricted to only Microsoft Windows/Vista operating systems according to the terms of the license. I am sorry, but you’ll be installing them at your own risk.
2. Also, please make sure you use the bash shell, or change the first line of the code to #!/bin/bash
3. In retrospect, this was a bad post - I think we’re better off not using stuff folks don’t want us to use - let’s use the better, freer, easier to install fonts.

Calibri

From Wikipedia, the free encyclopedia

Jump to: navigation, search

Typeface	Calibri
Category	Sans-serif
Designer(s)	Lucas de Groot
Foundry	Microsoft
Sample

An example of Calibri Regular, Bold and Italic

Calibri is a humanist sans-serif typeface family, best known as the new default typeface for the Microsoft Office 2007 suite of applications. It replaces the previous defaults Times New Roman (for Microsoft Word) and Arial (for PowerPoint, Excel and Outlook).

Calibri is one of six new western (Latin, Greek and Cyrillic) ClearType Collection typefaces that come with Microsoft Windows Vista and is the first sans-serif type to be designated the default face for the word processing application Microsoft Office Word. Earlier releases of Microsoft Word have consistently used Times New Roman as the default typeface.

Calibri was designed by Lucas de Groot for Microsoft to take advantage of Microsoft's ClearType rendering technology. The typeface won an award in the Type System category at the Type Directors Club's Type Design Competition in 2005. It includes characters from Latin, Latin extended, Greek, and Cyrillic scripts.

In a survey conducted by researchers at Wichita State University, Calibri was the most popular font for e-mail, instant messaging and PowerPoint presentations. It also ranked highly for use in website text. The survey asked participants to rate images of sample text in various fonts.[1]

Installation instructions for Ubuntu Edgy Eft/Feisty Fawn/Gutsy Gibbon users

Open /etc/apt/sources.list and add:

 deb http://hendrik.kaju.pri.ee/ubuntu edgy screenlets
 deb http://hendrik.kaju.pri.ee/ubuntu feisty screenlets
 deb http://hendrik.kaju.pri.ee/ubuntu gutsy screenlets

depending on your version of Ubuntu. Then run this in a terminal:

 wget http://hendrik.kaju.pri.ee/ubuntu/hendrikkaju.gpg -O- | sudo apt-key add - && sudo apt-get update

and install package 'screenlets' with:

 sudo apt-get install screenlets

[edit] What are the requirements/dependancies for running the screenlets?

First of all you need python (tested with 2.4 and 2.5). Further you need pygtk (at least version 2.10), pycairo, python-xdg and the package python-gnome2-desktop. The latter is unfortunately needed for the wnck/rsvg bindings (hopefully this will change sometime).

Note

Debian Repository

Note: An official package for SSHMenu has recently been added to Debian Unstable and Testing thanks to the efforts of Debian maintainer Kevin Coyner. If you're running either of those distributions then simply install SSHMenu from your standard repository rather than the one listed here.

SSHMenu is available pre-packaged for Debian and Ubuntu (etc) Linux systems, as two .deb packages:

sshmenu

The core code with no GNOME dependencies (runs as a standalone application in its own window)

sshmenu-gnome

The GNOME-specific additions to the core (including the panel applet)

If you like doing things the hard way, you can go and grab the latest .deb files directly from here.

Or you can add this entry to your /etc/apt/sources.list:

  deb http://sshmenu.sourceforge.net/debian stable contrib

Import our repository key:

  gpg --keyserver subkeys.pgp.net --recv-keys 4CC00851

  gpg --export --armor 4CC00851 | sudo apt-key add -

And then install the relevant package and dependencies with these commands:

  sudo apt-get update

  sudo apt-get install sshmenu-gnome

Using Synaptic

If you use Synaptic to manage your packages, you can add the repository as follows. On the Settings menu, select Repositories. Then press the Add button followed by the Custom button. Fill in the box labelled 'APT Line' as shown below and press the Add Channel button. Use the Close button to return to Synaptic and then press the Reload button on the toolbar to download package listings.

Ubuntu Case Studies

Here are just a few of the ways Ubuntu is being used in businesses and schools around the world. We'd also love to hear how you are using Ubuntu in your workplace, at home, or in your school or college.

Ubuntu supports technology-enabled teaching at The Johns Hopkins University

Cost-effective, easy-to-use and reliable, Ubuntu proved to be the open source platform of choice on which to build a support system for technology-enabled classrooms at The Johns Hopkins University.

Read the full story or download the PDF.

Locatrix Deploys Mobile Applications on Ubuntu

Stability and managability helps Locatrix deploy mobile applications to thousands of new users each week.

Read the full story. 

Ubuntu provides a secure and easily accessible system for German Pilots

Enhanced security, outstanding support and maintenance times - Ubuntu was the optimal choice for Contact Air GmbH.

Read the full story or download the PDF.

Ubuntu enables advanced computer research into killer diseases

Delivering training coursers to researchers in developing countries - Ubuntu was the first choice for The Wellcome Trust Sangar Institute.

Read the full story or download the PDF.

Ubuntu delivers significant cost-savings for specialist sports school

Stability, reduced maintenance times and significant cost savings - Ubuntu proved an outstanding choice for Skegness Grammar School.

Read the full story or download the PDF.

Ubuntu proved the optimal choice for a non-profit radio station

Simplicity in switching, ease-of-use, great client/server side management and outstanding reliabilty - Ubuntu proved the best choice for KRUU-FM radio station.

Read the full story or download the PDF.

Index of /~sak/courses/ics/sml-programs

 Name                    Last modified      Size  Description
 Parent Directory                             -   
 arith-seq.sml           07-Mar-2004 21:19  739   
 bintree.dat             04-Apr-2004 22:08  448   
 bintree.sml             04-Apr-2004 22:07  2.7K  
 comb-with-fact-1.sml    03-Feb-2004 20:16  183   
 comb-with-fact-2.sml    03-Feb-2004 21:45  263   
 comb-with-fact-3.sml    03-Feb-2004 21:47  263   
 comb.sml                28-Jan-2004 22:19  243   
 days.sml                25-Mar-2004 12:30  118   
 euclidean-composites..> 15-Feb-2004 16:14  1.5K  
 fact.sml                03-Feb-2004 20:11  115   
 fastpower.sml           04-Feb-2004 23:31  333   
 fibonacci.sml           26-Feb-2004 12:12  705   
 gcd.sml                 14-Jan-2007 17:08   70   
 higher-order.sml        14-Mar-2004 12:26  1.2K  
 imperative/             12-May-2004 11:36    -   
 intsqrt.sml             15-Feb-2004 15:57  1.0K  
 lists.sml               11-Mar-2004 11:37  531   
 matrix-mult.sml         04-Nov-2005 23:26  2.7K  
 perfect.sml             29-Jan-2004 01:30  1.5K  
 perfect2.sml            08-Feb-2004 22:53  591   
 perfect3.sml            08-Feb-2004 18:29  626   
 polynomial.sml          21-Mar-2004 19:51  399   
 power1.sml              26-Jan-2004 14:48  130   
 primes2.sml             03-Mar-2004 23:55  609   
 primes3.sml             03-Mar-2004 23:55  895   
 propLogic/              30-Apr-2004 09:12    -   
 queens.sml              06-Apr-2004 15:28  2.2K  
 queues/                 30-Apr-2004 18:11    -   
 rationals/              30-Apr-2004 18:09    -   
 resistors.sml           31-Mar-2004 17:24  584   
 reverse-integer.sml     20-Mar-2004 14:29  470   
 shapes.sml              25-Mar-2004 12:17  521   
 sieve.sml               15-Feb-2004 15:10  708   
 sort/                   22-Apr-2004 13:46    -   
 transpose.sml           25-Mar-2004 18:49  811   

• Oct 30: Jon Kleinberg (Cornell)
• Nov 27: Sanjeev Arora (Princeton)
• Dec 11: Robert Kahn (CNRI)
• Jan 8: Lydia Kavraki (Rice)
• Jan 22: Carla Ellis (Duke)
• Feb 5: Rick Rashid (Microsoft)
• Feb 12: Luis Von Ahn (CMU)
• Mar 4: Sebastian Thrun (Stanford)

/*
 * Charles Swiger (cs4w@andrew)
 * 15-347 HW1, Problem 4
 *
 * This implements a timer to measure the running time of an arbitrary
 * function.
 */

#include "etime.h"
#include "ftime.h"


/* This function returns a reasonable estimate of delta, the clock period of a
 * machine.  It works by waiting for one tick to pass and returns that time.
 */

double
compute_delta() {
    int i,n;
    double start, time;

    init_etime();

/* We'll start somewhere within a tick and loop until the time changes. */
    start = time = get_etime();
    for (i = 0; time == start; i++) {
        time = get_etime();
    }
    
    return (time - start);
}


/* This function uses the doubling method described in the homework assignment
 * to compute the running time of an arbitrary function to within a specified
 * accuracy.
 */

double
ftime(test_funct P, double E) {
    int i,n;
    double start, time, tprime, delta, pprime;

    delta = compute_delta();
    n = 1;
    tprime = 0;
    init_etime();

    while (tprime < (delta * (1 - E) / E)) {
        start = get_etime();
        for (i = 0; i < n; i++) {
            P();
        }
        time = get_etime();
        tprime = time - start;
        n *= 2;
    }

    n /= 2;                     /* we doubled n one time too many */
    pprime = tprime / n;
    
/*  printf("\nn = %d, tprime = %f, ftime = %f\n", n, tprime, pprime); */
    return pprime;
}

/* function timer */

typedef void (*test_funct)(void); 
double ftime(test_funct P, double E);

#define MAX_ETIME 86400   

void init_etime(void);
double get_etime(void);

void init_etime_real(void);
double get_etime_real(void);

/*
 * etime.c - timer package that uses the Unix interval timer
 *           to measure elapsed time in seconds.
 */
#include <stdio.h>
#include <sys/time.h>
#include "etime.h"

/* static variable that holds the initial value of the interval timer */
struct itimerval first_u; /* user time */
struct itimerval first_r; /* real time */

/* 
 * elapsed user time routines 
 */

/* init the timer */
void init_etime(void)
{
    first_u.it_interval.tv_sec = 0;
    first_u.it_interval.tv_usec = 0;
    first_u.it_value.tv_sec = MAX_ETIME;
    first_u.it_value.tv_usec = 0;
    setitimer(ITIMER_VIRTUAL, &first_u, NULL);
}

/* return elapsed seconds since call to init_etime */
double get_etime(void) {
    struct itimerval curr;

    getitimer(ITIMER_VIRTUAL, &curr);
    return (double) ((first_u.it_value.tv_sec - curr.it_value.tv_sec) +
		     (first_u.it_value.tv_usec - curr.it_value.tv_usec)*1e-6);
}

/* 
 * elapsed real time routines 
 */

/* init the timer */
void init_etime_real(void)
{
    first_r.it_interval.tv_sec = 0;
    first_r.it_interval.tv_usec = 0;
    first_r.it_value.tv_sec = MAX_ETIME;
    first_r.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL, &first_r, NULL);
}

/* return elapsed seconds since call to init_etime_real */
double get_etime_real(void) {
    struct itimerval curr;

    getitimer(ITIMER_REAL, &curr);
    return (double) ((first_r.it_value.tv_sec - curr.it_value.tv_sec) +
		     (first_r.it_value.tv_usec - curr.it_value.tv_usec)*1e-6);
}

New Kernel Hacking HOWTO/Subsystems/Exceptions and Interrupts Handling

1 Get IBM Lotus Symphony

Download the software from http://symphony.lotus.com/software/lotus/symphony/home.jspa.

Note: You have to register first.

2 Installation

There is currently a bug, which prevents the installation if you have desktop effects enabled (Compiz/Beryl).
So be sure that you have disabled the desktop effects before you proceed.

chmod +x IBM_Lotus_Symphony_Linux.bin
./IBM_Lotus_Symphony_Linux.bin
cd IBM_Lotus_Symphony_Linux/
sudo ./setup.bin

Next the installation wizard will pop up:

The following window contains the license agreement:

Choose a location for the installation - I recommend to use the default:

Now the software is ready to be installed:

The software is being installed:

When the install is complete, choose Exit and open later:

3 Bugfix

After the installation finished, you'll see that the lotus folder in your home directory belongs to root. So you have to change the ownership:

cd /home/%yourusername%/
sudo chown -R %yourusername%:%yourusername% lotus/

4 Use

Currently the software is very slow (depending on your hardware). It is accessible via the Applications menu in the gnome panel:

5 Deinstall

If you want to uninstall the software, simlpy run the uninstaller:

cd /opt/ibm/lotus/Symphony/_uninst/
sudo ./uninstaller.bin

6 Links

• IBM Lotus Symphony: http://symphony.lotus.com/software/lotus/symphony/home.jspa
• Ubuntu: http://www.ubuntu.com

Stopping when one alternative is clearly better than all the others, and Focusing the search on the place where the most progress can likely be made toward stopping.

The B* probability based search algorithm has been implemented on the chess machine Hitech. En route we have developed effective techniques for:

Producing viable optimistic estimates to guide the search,

Producing cheap probability distribution estimates to measure goodness,

Dealing with independence of alternative moves, and

Dealing with the Graph History Interaction problem.

Postscript

IV. Method

Adding the Repositories

Below are the instructions to add the Medibuntu repository to your system's list of APT repositories.

Add Medibuntu to your sources.list, as well as its GPG key to your keyring. Make sure to use the correct sources.list that corresponds to your current distribution.

• Ubuntu 6.06 "Dapper Drake":

  sudo wget http://www.medibuntu.org/sources.list.d/dapper.list -O /etc/apt/sources.list.d/medibuntu.list
  wget -q http://packages.medibuntu.org/medibuntu-key.gpg -O- | sudo apt-key add - && sudo apt-get update
  

• Ubuntu 6.10 "Edgy Eft":

  sudo wget http://www.medibuntu.org/sources.list.d/edgy.list -O /etc/apt/sources.list.d/medibuntu.list
  wget -q http://packages.medibuntu.org/medibuntu-key.gpg -O- | sudo apt-key add - && sudo apt-get update
  

• Ubuntu 7.04 "Feisty Fawn":

  sudo wget http://www.medibuntu.org/sources.list.d/feisty.list -O /etc/apt/sources.list.d/medibuntu.list
  wget -q http://packages.medibuntu.org/medibuntu-key.gpg -O- | sudo apt-key add - && sudo apt-get update
  

What is Weather wallpaper?

Weather wallpaper is a program which connects to NOAA each hour to get the current weather at the specified location and creates and sets a wallpaper with the data retrieved.

Installation

If you use Debian, Ubuntu, or another distro which uses deb packages, you can download the deb (weather-wallpaper-0.2.0.deb) and simply double-click on it to launch the installer, or you can add my repository to your sources.list file, so that your distro can inform you of new releases.

If you choose for the second method, open the file /etc/apt/sources.list with your favorite editor as root and add this line:

deb http://mundogeek.net/repo feisty all

If you use Archlinux, you can find the PKGBUILD at the ArchLinux User-community Repository.

If you use Gentoo, you can find the ebuild at Gentoo's Bugzilla.

If you use other distribution, download the tar.gz: weather-wallpaper-0.2.0.tar.gz, uncompress it, and execute the command make install with root privileges.

Yes, we do. You do need to install some additional software. Check out the Tribler readme.txt in the source code available from this server and our SourceForge page.

Alternatively, you can try our Ubuntu package, by adding our Ubuntu repository to the Synaptic Package Manager, as follows:

1. Start the package manager from the System / Administration menu
2. Open the Repositories menu from the Settings menu
3. Click on the Third-Party Software tab
4. Click on the Add+ button
5. Type deb http://ubuntu.tribler.org/ feisty main
6. Click the Add Source+ button
7. Close the Repositories menu
8. Click the Reload button to retrieve the package info from the Tribler repository
9. Click Search and search for "tribler"
10. Mark Tribler for installation by clicking
11. Ignore the warning about authentication, it is harmless
12. Install Tribler by clicking the "Apply" button at the top

You can now start Tribler from the Applications / Internet menu.

Howto: Access GetDeb.net packages through Apt-get/Synaptic

Grandr: Panel Applet that allow you to select screen resolution and orientation

Feed2JS

Cut and Paste JavaScript

Below is the code you need to copy and paste to your own web page to include this RSS feed. The NOSCRIPT tag provides a link to a HTML display of the feed for users who may not have JavaScript enabled.

cut and paste javascript:

17.4 Theoretical foundations for greedy methods

There is a beautiful theory about greedy algorithms, which we sketch in this section. This theory is useful in determining when the greedy method yields optimal solutions. It involves combinatorial structures known as "matroids." Although this theory does not cover all cases for which a greedy method applies (for example, it does not cover the activity-selection problem of Section 17.1 or the Huffman coding problem of Section 17.3), it does cover many cases of practical interest. Furthermore, this theory is being rapidly developed and extended to cover many more applications; see the notes at the end of this chapter for references.

17.4.1 Matroids

A matroid is an ordered pair satisfying the following conditions.

1. S is a finite nonempty set.

2. is a nonempty family of subsets of S, called the independent subsets of S, such that if and A B, then . We say that is hereditary if it satisfies this property. Note that the empty set is necessarily a member of .

3. If , and |A| < |B|, then there is some element x B - A such that . We say that M satisfies the exchange property.

The word "matroid" is due to Hassler Whitney. He was studying matric matroids, in which the elements of S are the rows of a given matrix and a set of rows is independent if they are linearly independent in the usual sense. It is easy to show that this structure defines a matroid (see Exercise 17.4-2).

As another illustration of matroids, consider the graphic matroid defined in terms of a given undirected graph G = ( V, E) as follows.

The set S_G is defined to be E, the set of edges of G.

If A is a subset of E, then if and only if A is acyclic. That is, a set of edges is independent if and only if it forms a forest.

The graphic matroid M_G is closely related to the minimum-spanning-tree problem, which is covered in detail in Chapter 24.

Theorem 17.5

If G is an undirected graph, then is a matroid.

Proof Clearly, S_G = E is a finite set. Furthermore, is hereditary, since a subset of a forest is a forest. Putting it another way, removing edges from an acyclic set of edges cannot create cycles.

Thus, it remains to show that M_G satisfies the exchange property. Suppose that A and B are forests of G and that |B| > |A|. That is, A and B are acyclic sets of edges, and B contains more edges than A does.

It follows from Theorem 5.2 that a forest having k edges contains exactly |V|-k trees. (To prove this another way, begin with |V| trees and no edges. Then, each edge that is added to the forest reduces the number of trees by one.) Thus, forest A contains |V| - |A| trees, and forest B contains |V| - |B| trees.

Since forest B has fewer trees than forest A does, forest B must contain some tree T whose vertices are in two different trees in forest A. Moreover, since T is connected, it must contain an edge (u, v) such that vertices u and v are in different trees in forest A. Since the edge (u, v) connects vertices in two different trees in forest A, the edge (u, v) can be added to forest A without creating a cycle. Therefore, M_G satisfies the exchange property, completing the proof that M_G is a matroid.

Given a matroid , we call an element x A an extension of if x can be added to A while preserving independence; that is, x is an extension of A if . As an example, consider a graphic matroid M_G. If A is an independent set of edges, then edge e is an extension of A if and only if e is not in A and the addition of x to A does not create a cycle.

If A is an independent subset in a matroid M, we say that A is maximal if it has no extensions. That is, A is maximal if it is not contained in any larger independent subset of M. The following property is often useful.

Theorem 17.6

All maximal independent subsets in a matroid have the same size.

Proof Suppose to the contrary that A is a maximal independent subset of M and there exists another larger maximal independent subset B of M. Then, the exchange property implies that A is extendable to a larger independent set A {x} for some x B - A, contradicting the assumption that A is maximal.

As an illustration of this theorem, consider a graphic matroid M_G for a connected, undirected graph G. Every maximal independent subset of M_G must be a free tree with exactly |V| - 1 edges that connects all the vertices of G. Such a tree is called a spanning tree of G.

We say that a matroid is weighted if there is an associated weight function w that assigns a strictly positive weight w(x) to each element x S. The weight function w extends to subsets of S by summation:

for any A S. For example, if we let w(e) denote the length of an edge e in a graphic matroid M_G, then w(A) is the total length of the edges in edge set A.

17.4.2 Greedy algorithms on a weighted matroid

Many problems for which a greedy approach provides optimal solutions can be formulated in terms of finding a maximum-weight independent subset in a weighted matroid. That is, we are given a weighted matroid , and we wish to find an independent set such that w(A) is maximized. We call such a subset that is independent and has maximum possible weight an optimal subset of the matroid. Because the weight w(x) of any element x S is positive, an optimal subset is always a maximal independent subset--it always helps to make A as large as possible.

For example, in the minimum-spanning-tree problem, we are given a connected undirected graph G = (V, E) and a length function w such that w (e) is the (positive) length of edge e. (We use the term "length" here to refer to the original edge weights for the graph, reserving the term "weight" to refer to the weights in the associated matroid.) We are asked to find a subset of the edges that connects all of the vertices together and has minimum total length. To view this as a problem of finding an optimal subset of a matroid, consider the weighted matroid M_G with weight function w', where w'(e) = w₀ - w(e) and w₀ is larger than the maximum length of any edge. In this weighted matroid, all weights are positive and an optimal subset is a spanning tree of minimum total length in the original graph. More specifically, each maximal independent subset A corresponds to a spanning tree, and since

w'(A) = (|V| - 1)w0 - w(A)

for any maximal independent subset A, the independent subset that maximizes w'(A) must minimize w(A). Thus, any algorithm that can find an optimal subset A in an arbitrary matroid can solve the minimum-spanning-tree problem.

Chapter 24 gives algorithms for the minimum-spanning-tree problem, but here we give a greedy algorithm that works for any weighted matroid. The algorithm takes as input a weighted matroid with an an associated positive weight function w, and it returns an optimal subset A. In our pseudocode, we denote the components of M by S[M] and and the weight function by w. The algorithm is greedy because it considers each element x S in turn in order of nonincreasing weight and immediately adds it to the set A being accumulated if A {x} is independent.

The elements of S are considered in turn, in order of nonincreasing weight. If the element x being considered can be added to A while maintaining A's independence, it is. Otherwise, x is discarded. Since the empty set is independent by the definition of a matroid, and since x is only added to A if A {x} is independent, the subset A is always independent, by induction. Therefore, GREEDY always returns an independent subset A. We shall see in a moment that A is a subset of maximum possible weight, so that A is an optimal subset.

The running time of GREEDY is easy to analyze. Let n denote |S|. The sorting phase of GREEDY takes time O(n lg n). Line 4 is executed exactly n times, once for each element of S. Each execution of line 4 requires a check on whether or not the set A {x} is independent. If each such check takes time O(f(n)), the entire algorithm runs in time O(n lg n + nf(n)).

We now prove that GREEDY returns an optima1 subset.

Lemma 17.7

Suppose that is a weighted matroid with weight function w and that S is sorted into nonincreasing order by weight. Let x be the first element of S such that {x} is independent, if any such x exists. If x exists, then there exists an optimal subset A of S that contains x.

Proof If no such x exists, then the only independent subset is the empty set and we're done. Otherwise, let B be any nonempty optimal subset. Assume that x B; otherwise, we let A = B and we're done.

No element of B has weight greater than w(x). To see this, observe that y B implies that {y} is independent, since and I is hereditary. Our choice of x therefore ensures that w(x) w(y) for any y B.

Construct the set A as follows. Begin with A = {x}. By the choice of x, A is independent. Using the exchange property, repeatedly find a new element of B that can be added to A until |A| = |B| while preserving the independence of A. Then, A = B - {y} {x} for some y B, and so

w(A) = w(B) - w(y) + w(x)

 w(B) .

Because B is optimal, A must also be optimal, and because x A, the lemma is proven.

We next show that if an element is not an option initially, then it cannot be an option later.

Lemma 17.8

Let be any matroid. If x is an element of S such that x is not an extension of , then x is not an extension of any independent subset A of S.

Proof The proof is by contradiction. Assume that x is an extension of A but not of . Since x is an extension of A, we have that A {x} is independent. Since is hereditary, {x} must be independent, which contradicts the assumption that x is not an extension of .

Lemma 17.8 says that any element that cannot be used immediately can never be used. Therefore, GREEDY cannot make an error by passing over any initial elements in S that are not an extension of , since they can never be used.

Lemma 17.9

Let x be the first element of S chosen by GREEDY for the weighted matroid . The remaining problem of finding a maximum-weight independent subset containing x reduces to finding a maximum-weight independent subset of the weighted matroid , where

the weight function for M' is the weight function for M, restricted to S'. (We call M' the contraction of M by the element x.)

Proof If A is any maximum-weight independent subset of M containing x, then A' = A - {x} is an independent subset of M'. Conversely, any independent subset A' of M' yields an independent subset A = A' {x} of M. Since we have in both cases that w(A) = w(A') + w(x), a maximum-weight solution in M containing x yields a maximum-weight solution in M', and vice versa.

Theorem 17.10

If is a weighted matroid with weight function w, then the call GREEDY(M, w) returns an optimal subset.

Proof By Lemma 17.8, any elements that are passed over initially because they are not extensions of can be forgotten about, since they can never be useful. Once the first element x is selected, Lemma 17.7 implies that GREEDY does not err by adding x to A, since there exists an optimal subset containing x. Finally, Lemma 17.9 implies that the remaining problem is one of finding an optimal subset in the matroid M' that is the contraction of M by x. After the procedure GREEDY sets A to{x}, all of its remaining steps can be interpreted as acting in the matroid , because B is independent in M' if and only if B {x} is independent in M, for all sets . Thus, the subsequent operation of GREEDY will find a maximum-weight independent subset for M', and the overall operation of GREEDY will find a maximum-weight independent subset for M.

What is Pyro?

Flickr Add-on

Exposé-alike

Window Picker

Pyro is a new kind of desktop environment for Linux built on Mozilla Firefox. Its goal is to enable true integration between the Web and modern desktop computing.

By merging the Web with the desktop, Pyro offers the first big step toward a new future for the Web and the applications built for it.

In Pyro, Web content is no longer confined to the browser's window. Instead, trusted Web sites and extensions are given access to the full range of interactivity and control enjoyed by native applications today.

Imagine...

• Rich Web pages running side-by-side with native applications
• Single programming environment for the whole desktop
• Desktop-wide mashups, killer Web integration
• Novel desktop effects

Pyro enables a desktop that tracks the latest in Web technology, and helps mold