All the download servers are crawling along at the moment except for the following server which is not listed on the website.

http://mirrors.rit.edu/ubuntu-releases/

http://mirrors.rit.edu/ubuntu-releases/8.04/

Ubutnu downloads at full speed from this server.. it only took me 7 minutes to download.

Enjoy!

Google the song in Google Video; who cares what the homebrew video is, just go looking for good audio.
Pull the movie up in Firefox; when the movie finishes buffering, do :

ls -lh /tmp/Flash*

.. and copy the newest file somewhere else, say yer desktop. Now you have a copy of the video.

We just want the audio, so using ffmpeg (sudo apt-get install ffmpeg if you don’t have it), do:

ffmpeg -i [Flash File] [song name] .mp3

And that’s it; one MP3. Use your favourite id3 tool to add tags, and enjoy!

Tree based search algorithms
Tree search algorithms are the heart of searching techniques. The basic principle is that a node is taken from a data structure, its successors examined and added to the data structure. By manipulating the data structure, the tree is explored in different orders for instance level by level (breadth-first search) or reaching a leaf node first and backtracking (depth-first search).

Definitions

• State - a representation of a physical configuration.
• Node - a data structure part of a search tree. A node has the following properties: father, sons, depth and path cost.

States don’t have father, sons, depth and path cost.

Types of problems

• Deterministic accessible - simple states problem.
• Deterministic inaccessible - multiple states problem.
• Non deterministic inaccessible - contingency problem (maybe) - sensors must be used during the execution process. The solution is a tree or a policy. Many times alternates between search and execution.
• Unknown search space - exploration problem (online).

Selecting a search space
The real world is extremely complex. The search space must be abstracted from the solution process.

Abstracting we have:

• Abstract state - the set of real states.
• Abstract operator - combination of real actions.
• Abstract solution - set of real paths that represents a solution in the real world.

Each abstract action must be easier than the action in the real problem.

A simple algorithm

function GeneralSearch(problem, strategy)

  return a solution or failure

Initialise the search tree using the initial state of the problem

loop do

  if there are no candidates for expansion then

    return failure

Choose a leaf node for expansion according to strategy

if the node contains a goal state then

  return the corresponding solution

else

  expand the node and add the resulting nodes to the tree

end

Algorithm implementation

function GeneralSearch(problem, QueueingFunction)

nodes <- MakeQueue(MakeNode(InitialState[problem]))

loop do

  if nodes is empty then

    return failure

  node <- RemoveFront(nodes) a leaf node for expansion according
to strategy

  if GoalTest[problem] applied to State(node) succeeds then

    return node

  nodes <- QueueingFunction(nodes, Expand(node,
Operators[problem]))

end

Search strategies
A search strategy is a choice made between the methods used to expand the nodes. Each method has its proper order of expansion.

Strategies are evaluated according to following parameters:

• Time complexity - the number of generated or expanded nodes.
• Space complexity - maximum number of nodes presented in the memory.
• Optimality - the solution found has the minimum cost?

Complexities in time and space are measured in terms of:

• b - maximum ramification factor of the search tree.
• d - depth of the solution that has the minimum cost.
• m - maximum depth of the search space (can be ∞) infinite.

The two strategies presented in this post (breadth and depth first search) are considered uninformed strategies because they only use the information available in the problem definition.

Breadth first search
The breadth first search expands the less deep node.

The data structured used to implement this search algorithm is a queue.

Breadth first search properties
Is complete? Yes, if (b is finite).
Time: 1 + b² + b³ + … + b^d = O(b^d). e.g.: exponential in d
Space: O(b^d) (maintains all the nodes in memory)
Optimal? Yes, if cost per step is 1; in general is not optimal.

Space is the big problem for can generate nodes at a rate of 1 MB / sec. 24 hours = 86 GB.

Depth first search
The depth first search expands the deepest node.

The data structure used to implement this search algorithm is a stack.

An important note about the depth first search is that it can execute infinite cycles so it’s mandatory to check the states already visited to avoid such infinite cycles.

Depth first search properties
Is complete? No. It is imperfect in spaces of infinite depth or in cyclic paths. Is complete only in a finite search space.
Time: O(bm). Is very bad if m is a lot greater than d. If solutions are dense can be fastest than the breadth first search.
Space: O(bm) e.g.: linear in space
Optimal? No.

Working problem: vacation in Romania
In this post let’s explore a simple states problem as shown in the following picture:

Suppose we are going on holiday in Romania. More specifically we are in the city called Arad. We want to go to Bucharest the capital city of Romania and our flight takes off tomorrow.

Breaking down our problem, we have:

• Objective - go to Bucharest.
• Search space - several cities to get to Bucharest.
• Operator - drive through the cities.

In this case a solution is a sequence of cities so that the last city is Bucharest. A valid path could be: Arad, Sibiu, Fagaras, Bucharest.

e.g.: Arad -> Zerind represents a complex set of possible paths, returns, pauses for resting, etc.
To guarantee the realisability, any real state in “Arad” must take us to some real state in “Zerind”.

The problem’s formulation can be:

• Initial state - Arad
• Operator (or successor function S(x)) - eg.: Arad -> Zerind, Arad -> Sibiu, etc.
• Goal test - can be explicit or implicit as x = Bucharest or NoDirty(x).
• Path cost (additive) - can be the sum of distances, used operators etc.

The solution is a sequence of operators that takes from the initial state to the goal state.

Implementing the breadth and depth first search in C#
The following methods use two classes implemented by Scott Mitchell [1]. The classes are: Node and EdgeToNeighbor.

I just added a new property called PathParent in the node class.

public static void BreadthFirstSearch(Node start, Node end)

{

  Queue<Node> queue = new Queue<Node>();

  queue.Enqueue(start);

  while(queue.Count != 0)

  {

    Node u = queue.Dequeue();

    // Check if node is the end

    if(u == end)

    {

      Console.Write(“Path found.”);

      break;

    }

    else

    {

      u.Data = “Visited”;

      // Expands u’s neighbours in the queue

      foreach(EdgeToNeighbour edge in u.Neighbours)

      {

        if(edge.Neighbour.Data == null)

        {

          edge.Neighbour.Data = “Visited”;

          if(edge.Neighbour != end)

          {

            edge.Neighbour.PathParent = u;

            PrintPath(edge.Neighbour);

          }

          else

          {

            edge.Neighbour.PathParent = u;

            PrintPath(edge.Neighbour);

            return;

          }

          Console.WriteLine();

        }

        /* shows the repeated nodes

        else

        {

          Console.Write(edge.Neighbour.Key);

        } */

        queue.Enqueue(edge.Neighbour);

      }

    }

  }

}

public static void DepthFirstSearch(Node start, Node end)

{

  Stack<Node> stack = new Stack<Node>();

  stack.Push(start);

  while(stack.Count != 0)

  {

    Node u = stack.Pop();

    // Check if node is the end

    if(u == end)

    {

      Console.WriteLine(“Path found”);

      break;

    }

    else

    {

      u.Data = “Visited”;

      // Store n’s neighbours in the stack

      foreach(EdgeToNeighbour edge in u.Neighbours)

      {

        if(edge.Neighbour.Data == null)

        {

          edge.Neighbour.Data = “Visited”;

          if(edge.Neighbour != end)

          {

            edge.Neighbour.PathParent = u;

            PrintPath(edge.Neighbour);

          }

          else

          {

            edge.Neighbour.PathParent = u;

            PrintPath(edge.Neighbour);

            return;

          }

          Console.WriteLine();

          stack.Push(edge.Neighbour);

        }

        /* shows the repeated nodes

        else

        {

          Console.Write(edge.Neighbour.Key);

        } */

      }

    }

  }

}

Summary
The formulation of a problem requires abstraction to avoid irrelevant details of the real world so that a search space can be defined and explored.

Later, I’ll dive in more details and explain how to use the breadth and depth search methods. We’ll execute a test case using the Romania map shown in the picture above, print the traveled paths in the screen, calculate the shortest path possible between two cities using Dijkstra’s algorithm and print such a path in the screen.

Before that I recommend the reading of the excellent revision about data structures written by Scott Mitchell [1]. Although I only use the facts exposed in part 5 of Scott’s article: From Trees to Graphs, it’s worth to read starting in part 1.

For now, look and think about the breadth and depth first search implementation in C#.

References
[1] Mitchell, Scott. An Extensive Examination of Data Structures. 2004. Available at <http://msdn2.microsoft.com/en-us/library/aa289152(VS.71).aspx>.

[2] Artificial Intelligence Depot. Blind search. Available at <http://ai-depot.com/Tutorial/PathFinding-Blind.html>.

Basically, I’ve got two modes of work: loose/open, and focused/closed. When I’m in “open” mode, my instant messenger status is set to available, I’m surfing, writing, checking email, coding, listening to music with lyrics—getting things done, but in a multitasking way, open to interruptions and tangents.

When I’m in focused/closed mode, I shut down IM, stop checking email, close any windows I’m not using, switch to my ambient music playlist, set a timer, and plow through whatever I’ve got to get done. Typically I go into closed mode when I’m on deadline, or feel like too much time has passed since I checked off something really important on my list.

If you can forgive that shamelessly self-referential act of quoting myself, tell me: what different modes of work are you in during the day? How and when do you move between them? Give it up in the comments.

Miraculously, a parking place appeared.

Paddy looked up again and said, “Never mind, I found one.”

1. First, you’ll need to have a .iso image available for burning. This could be located on your desktop, home folder or I’ve even burned an image using this method over on NFS connection. You’ll also need a blank CD or DVD in the drive.
2. Once you’ve selected your disk image you can right-click the .iso file and select “Write to disk…” (two clicks)
3. This will open a dialog box letting you verify the disk type, size and burn speed. If all is correct (which it normally is) you can click Burn. Sit back and relax. Your disk will be finished in just a few minutes. (one click)

Done. When finished it’ll ask if you’d like to Eject, Burn Another Copy or if you’re just Done. So very easy.

I find this method much faster and a little more intuitive than the other cd / dvd burning applications. Not to say they aren’t great apps, but if you’re just burning a simple disk image this should be a bit faster. I’ve also had far fewer coasters using this method than I have with the others.

Below are a few basic command for those of you new to the command line:

ls - list contents of a directory
sudo - "super-user do" (grants administrator rights)
cd - change directory
aptitude - APT package management system (update, install, remove, search)
clear - clear screen
chmod - change file access permissions
chown - change file and group ownership
cp - copy
mv - move
rm - remove
cat - concatenate files (dump to screen)
nano - basic text editor
vi - advanced text editor
fdisk - partition table manipulator
df - disk free (remaining / used disk space)
users - users currently logged in
useradd - add a user
usermod - modify existing user
uname - show system data (try uname -a)
mount - mount a file system, cd or removable drive
umount - un-mount a file system, cd or removable drive
top - show current running processes
touch - create new, empty, file
reboot - reboot your system
shutdown - shutdown your system
passwd - change user password
ping - ping a network device or location (ping google.com)
more - show output one screen at a time
exit - logout of the terminal
eject - eject a cdrom or removable device

A neckband that translates thought into speech by picking up nerve signals has been used to demonstrate a “voiceless” phone call for the first time.

With careful training a person can send nerve signals to their vocal cords without making a sound. These signals are picked up by the neckband and relayed wirelessly to a computer that converts them into words spoken by a computerised voice.

A video (right) shows the system being used to place the first public voiceless phone call on stage at a recent conference held by microchip manufacturer Texas Instruments. Michael Callahan, co-founder of Ambient Corporation, which developed the neckband, demonstrates the device, called the Audeo.

Users needn’t worry about that the system voicing their inner thoughts though. Callahan says producing signals for the Audeo to decipher requires “a level above thinking”. Users must think specifically about voicing words for them to be picked up by the equipment.

The Audeo has previously been used to let people control wheelchairs using their thoughts. Watch a video demonstrating thought control of wheelchairs

“I can still talk verbally at the same time,” Callahan told New Scientist. “We can differentiate between when you want to talk silently, and when you want to talk out loud.” That could be useful in certain situations, he says, for example when making a private call while out in public.

The system demonstrated at the TI conference can recognise only a limited set of about 150 words and phrases, says Callahan, who likens this to the early days of speech recognition software.

At the end of the year Ambient plans to release an improved version, without a vocabulary limit. Instead of recognising whole words or phrases, it should identify the individual phonemes that make up complete words.

This version will be slower, because users will need to build up what they want to say one phoneme at a time, but it will let them say whatever they want. The phoneme-based system will be aimed at people who have lost the ability to speak due to neurological diseases like ALS – also known as motor neurone disease.

Kinda. It’s not really the Universe’s birthday, but now we do know to high accuracy just how old it is.

How?

NASA’s WMAP is the Wilkinson Microwave Anisotropy Probe (which is a mouthful, and why we just call it WMAP). It was designed to map the Universe with exquisite precision, detecting microwaves coming from the most distant source there is: the cooling fireball of the Big Bang itself.

New results just released from WMAP have nailed down lots of cool stuff — literally — about the Universe.

I am about to explain the early Universe to you. I’ll be brief, but if you want to skip to the results, then go ahead.

Here’s the quick version: the Big Bang was hot. The Universe itself expanded outward from a single point — actually, it’s space itself that expands, not the objects in it — and like any expanding gas it cooled. After about a microsecond, it had cooled enough for protons and neutrons to form. Three minutes later (yes, just three minutes) it had cooled enough for protons and neutrons to stick together. Hydrogen, helium, and just a dash of lithium were created, and these would be the only elements for some time (hundreds of millions of years, in fact). The Universe was a thick soup of matter and energy.

It kept expanding and cooling. At this point, it was opaque to light. A photon couldn’t travel an inch without smacking into an electron and then getting sent off in some other random direction. However, after a few hundred thousand years, an amazing thing happened: neutral hydrogen could form. Before this point, the Universe was still too hot; as soon as an electron bonded with a proton, some ultraviolet photon would come along and whack it off. But at that golden moment the cosmos had cooled off enough that a lasting atomic relationship was in the offing. Neutral hydrogen was born. At that moment — astronomers call it recombination, which is a misnomer, since it was the first time electrons and protons could combine — the Universe became transparent; without all those pesky electrons floating around, photons found themselves free to travel long distances.

It’s those photons WMAP sees. After 13.7 billion years, the expansion of the Universe has cooled the light, stretched its wavelength from ultraviolet to microwave. Another way to think about it is that the temperature associated with each photon went from thousands of Kelvins down to just a few, less than 3, in fact. That’s -270 Celsius, and -454 Fahrenheit.

Brrrr.

That light emitted just after recombination tells us a vast amount about the Universe at that time. By carefully mapping the exact wavelength of the light and the direction from where it came, we can tell the density and temperature of the matter at that time. Incredibly we can also tell how much dark energy there was, and even the geometry of the Universe: whether it is flat, open, or closed.

All this, from the dying glow of the Big Bang itself.

WMAP Results

A lot of this information was determined a while back, just a couple of years after WMAP launched. But now they have released the Five Year Data, a comprehensive analysis of what all that data means. Here’s a quick rundown:

1) The age of the Universe is 13.73 billion years, plus or minus 120 million years. Some people might say it doesn’t look a day over 6000 years. They’re wrong.

2) The image above shows the temperature difference between different parts of the sky. Red is hotter, blue is cooler. However, the difference is incredibly small: the entire temperature range from cold to hot is only 0.0002 degrees Celsius. The average temperature is 2.725 Kelvin, so you’re seeing temperatures from 2.7248 to 2.7252 Kelvins.

3) The age of the Universe when recombination occurred was 375,938 years, +/- about 3100 years. Wow.

4) The Universe is flat.

5) The energy budget of the Universe is the total amount of energy and matter in the whole cosmos added up. Together with some other observations, WMAP has been able to determine just how much of that budget is occupied by dark energy, dark matter, and normal matter. What they got was: the Universe is 72.1% dark energy, 23.3% dark matter, and 4.62% normal matter. You read that right: everything you can see, taste, hear, touch, just sense in any way… is less than 5% of the whole Universe.

We occupy a razor thin slice of reality.

There are other important things that have come from the WMAP data, and if you’re interested, you can read all about them on the WMAP site and in the professional journal papers.

But if you only want to peruse the results I’ve highlighted here, that’s fine too. But remember this, and remember it well: you are living in a unique time. For the first time in all of human history, we can look up at the sky, and when it looks back down on us it reveals its secrets. We are the very first humans to be able to do this… and we have the entire future of the Universe ahead of us.

While this seems like a bit of a non-subject, or even a mundane one, I still feel it should be discussed. First off, there are over thirty five different package distribution systems available out there. Thirty five! Just like the excess of Linux distributions, that’s just too many. I’m not saying we should suddenly end choice in the Linux world. I’m all for choice. But I’m also a realist. You can’t expect Linux to succeed in the world if there isn’t standardisation at least in this area.

It seems every Linux distro has its own way of configuring network access. For example:

Fedora: /etc/sysconfig/networking/devices/ifcfg-eth0
Archlinux: /etc/rc.conf
Ubuntu: /etc/network/interfaces

And that’s just the tip of the iceberg. I won’t even go into all the nuttiness that exists out there. Sure, there’s some standardisation across all the distributions, but it’s so little as to be difficult to spot. That shouldn’t be the case, ever. Because of that, each distribution, or distribution group has to have their own custom built version of a given application for their own version of Linux.

I feel sorry for the application developers who want to supply binary packages, and need to build sometimes dosens of packages for all the different distros and their various incompatible versions. Of course in real life they seldom do - so the poor user is faced with having to try and compile the application from source if a binary package does not exist for their distro.

Even the package systems are too diversified. As I said before, choice is good, but not on the core system, and packages are part of the core system. Sure, choice is important and choice is good. I very strongly support choice. But I’m a realist and reality says that sometimes choice can also be your own worst enemy. You can standardise the core of Linux, yet still leave users with all the choice they could ever want. And if we don’t start standardising at least the important things, Microsoft is going to beat us over the head. One of their biggest clubs against us is that we’ve got such a wide range of diversity, while they have a standardised one stop shop.

Really, seriously. Think about it. Who needs fifteen different ways to do network configuration? Or how about hardware detection? Why do we need some 100 different systems for hardware detection? Everyone should get together, pool their resources, and come up with one, two, maybe even three really, really good hardware detection systems and then have everyone use them. Or how about the directory file tree? I absolutely hate it when each distribution has its own unique way to do the directory structure for system and user files. Everyone pick one thing that works, and run with it. Don’t create a thousand unique ways to do things.

People shouldn’t be forced to do something ten different ways across ten different distributions. If you think it drives some of us nuts, imagine what it does in the corporate world. If Linux is ever going to become properly mainstream, some of our choice has to be surrendered. Why do you think Microsoft succeeded so well in the market?

All conspiracy theories aside, they provided end users with a consolidated, single platform which was universal and provided a one stop shop for corporations where other previous operating systems didn’t, preferring to each stick to their own unique and proprietary OS’s, formats, file systems, and more. People loved how Microsoft was consistent and compatible no matter where you went and which version you had. (Yes, they actually believed in cross program and cross OS compatibility at one time) But it wasn’t the home user that ended up making Microsoft so big. Microsoft targeted the corporate workplace. Apple went after the home and school market. You can see who won that war.

So if Linux ever wants to truly become mainstream, some level of standardisation needs to occur. Incompatibilities between distributions, the multiplicity in the ways applications need to be compiled to work on each distribution, and the variance of features across different versions is going to do more harm than good for us in the long term. I’m not saying we need to throw out all we’ve worked so hard for. But sometimes we have to give up a little to gain a lot. Isn’t sacrificing a little choice in the underlying system to gain the victory in the world market better than keeping the tangled mess we have now and ultimately loosing the war?

If we don’t standardise at least the core of every Linux distro, we’re going to find ourselves in a rather nasty place in the near future. Now before you pick up your guns and start shooting (figuratively I hope) at me or each other, let’s stop for a moment. All pride and egos aside, our enemy is not each other. Our enemy is a Redmond, Washington company who would like nothing more than to see choice wiped out of existence. If for no other reason, isn’t that enough to make you want to lay down the sword with your fellow Linux geek and try working together towards Linux standardisation? Or do you actually enjoy the idea of eventually having no choice in what you do on your computer? Think about it. If we don’t start working together and standardising things, that’s all we’ll have. One big bloated monster of an OS, a monopoly hellbent on telling you what you can and can’t do, and more headaches than all the aspirin in the world can cure. So let’s get moving.