First let’s install apache server :

# yum install httpd

Let's start the server manually after installation :


# /etc/init.d/httpd start

First time information on server start up :


Starting httpd: httpd: Could not reliably determine the server's fully qualified domain name,
using 127.0.0.1 for ServerName

Now let's configure the server name :


sudo nano /etc/httpd/conf/httpd.conf

Go to the end of the file you will find a section that starts with 'ServerName'
 and gives the example:
#ServerName www.example.com:80

Remove comment on the line and type your server name, the server name is your

domain name / ip address or the hostname
ServerName demo.com
Now reload the apache server :
sudo /etc/init.d/httpd reload

Now we should be shure that port 80 is opened , configure your iptables firewall setings :
iptables -I RH-Firewall-1-INPUT -p tcp --dport 80 -j ACCEPT

You can navigate to your server IP address or the host name and you will see the starting page.

Make sure that apache is booted on server start up :
sudo /sbin/chkconfig httpd on

Let's check if apache runs properly :
sudo /sbin/chkconfig --list httpd
httpd           0:off        1:off  2:on    3:on    4:on    5:on    6:off

PHP5 INSTALLATION

Now let’s install all available php libraries and php5 for our server :

sudo yum install php php-common gd-devel php-gd php-mcrypt php-pear php-pecl-memcache php-mhash
 php-mysql php-xml php-xmlrpc php-curl curl curl-devel php-simplexml php-devel

Now let's reload apache:
sudo /etc/init.d/httpd reload

And we are done !!!

MYSQL INSTALLATION

Let’s update our server first :

# sudo yum -y update

Install mysql with yum :
# sudo yum -y install mysql-server

Start mysql :
# sudo /etc/init.d/mysqld start

Create your first mysql user  [ while root is your user ] :
mysqladmin -u root password NEWPASSWORD
log in mysql with new password: 

mysql -u root -p


I believe you are the root and user that you created is a superuser with full access,
give this user all privileges to all tables when you are in mysql terminal :
 GRANT ALL PRIVILEGES ON *.* TO root@localhost IDENTIFIED BY 'NEWPASSWORD' WITH GRANT OPTION;

 FLUSH PRIVILEGES;
That's it , lamp installation completed.
Good luck

Here is the code solution to do it right way :

<?php

function chekIfExist($url)

{

if (@GetImageSize($url))

{

return true;

}else{

return false;

}
}
function encodeImg($imgurl)

{

$image = imagecreatefromjpeg($imgurl);
imagealphablending($image, false);
imagesavealpha($image, true);

// start buffering
ob_start();
imagepng($image);
$contents =  ob_get_contents();
ob_end_clean();
imagedestroy($image);
return “data:image/png;base64,”.base64_encode($contents);

}

$external_link = ‘http://i.ytimg.com/vi/5g9aVwRenVg/2.jpg’;

if(chekIfExist($external_link))

echo “<img src=’”.encodeImg($external_link).”‘ />”;

?>

I will try to explain why this method of developing is really cool for me and why it could be useful and fun to you too using curl library example.  Imagine yourself  writing the script that should connect 20 APIproviders using CURL library and to output the data. Someone who is not familiar with Inheritance manner of code writing will create 20 objects for different providers with the same code of curl execution.  So where is Inheritance involved in ? If you build this application with using Inheritance method, you should create Parent class for CURL execution, construct function to get instance of curl settings, function to run the curl and to set variables that will handle data that returns on response (protected variables), errors after execution are also stored in protected object variables.

Build the children class and initialize the parent class with curl settings on child class construct function . In child class you should only set the curl options and all the process will be executed in parent class, so you don’t need to type the curl init and curl exec again and again.In children class create functions that will return parent protected variables and here comes polymorphism you can use same child classes functions for different api and parent class will return different response from the api.

It was a rough tip of using inheritance and polymorphism, I will post simple example code later and your life as a coder probably would become painless.

Good luck.

Here is an experiment of posting comments with php curl library, this is the part of glurt seo tools. With a little imagination you may create a great auto commenting software for any blog cms and any website to promote your website on web or for another purposes. I created this script because I was lazy to enter the name, email address again and again. I’ve come with the curl and PHP solution to post comments on wordpress blogs that I am interested in by typing url only inside of form field on my localhost, clicking submit , and the comment is there, sent by curl with PHP.

1. POST DATA we will need

First, before creating the script I figured out which POST variables are being transferred by wordpress comment form, form action (where the comment submission process done).  I opened the wordpress post’s html source (in mozilla firefox right mouse click->view source code) I found something similar to :

<form action=”http://blog.php/wp-comments-post.php” method=”post” id=”commentform”>
<p>
<input type=”text” name=”author” id=”author” value=”" size=”22″ tabindex=”1″ />
<label for=”author”><small>Name
(required)    </small></label>
</p>
<p>
<input type=”text” name=”email” id=”email” value=”" size=”22″ tabindex=”2″ />
<label for=”email”><small>Mail (will not be published)
(required)    </small></label>
</p>
<p>
<input type=”text” name=”url” id=”url” value=”" size=”22″ tabindex=”3″ />
<label for=”url”><small>Website</small></label>
</p>
<!–<p><small><strong>XHTML:</strong> You can use these tags: &lt;a href=&quot;&quot; title=&quot;&quot;&gt; &lt;abbr title=&quot;&quot;&gt; &lt;acronym title=&quot;&quot;&gt; &lt;b&gt; &lt;blockquote cite=&quot;&quot;&gt; &lt;cite&gt; &lt;code&gt; &lt;del datetime=&quot;&quot;&gt; &lt;em&gt; &lt;i&gt; &lt;q cite=&quot;&quot;&gt; &lt;strike&gt; &lt;strong&gt; </small></p>–>
<p>
<textarea name=”comment” id=”comment” cols=”100%” rows=”10″ tabindex=”4″></textarea>
</p>
<p>
<input name=”submit” type=”submit” id=”submit” tabindex=”5″ value=”Submit Comment” />
<input type=”hidden” name=”comment_post_ID” value=”287″ />
</p>
</form>

The variables we will use for cron execution from form above are :

Form action url: http://blog.php/wp-comments-post.php  – wordpress uses “wp-comments-post.php” file as a file for comment storing into the database.

Author :  is the name of comment author, most of the wordpress blogs require it .

Email : Is a commenter email

Url : Is a url of your website

Submit : this variable is necessary for submitting the result in “wp-comments-post.php”.

comment_post_ID: is a hidden value, necessary for wp database that tells the script which post to bind comment to.

Author and email are required fields for cron operation, post id is also necessary because we should know where to post the comment.  comment_post_ID is also neccessary to tell the script in which post comment will appear.

2. Getting wordpress post id comment_post_ID from wordpress post

To get post id to use it for curl form submission we will need comment_post_ID from post form . We will crawl the html with curl and take comment_post_ID variable in numeric format using regular expressions:

<?php

// CURL function to get the page and to insert it inside php variable.
function get_web_page( $url )
{
$options = array(
CURLOPT_RETURNTRANSFER => true, // return web page
CURLOPT_HEADER => false, // don't return headers
CURLOPT_FOLLOWLOCATION => true, // follow redirects
CURLOPT_ENCODING => "", // handle all encodings
CURLOPT_USERAGENT => "spider", // who am i
CURLOPT_AUTOREFERER => true, // set referer on redirect
CURLOPT_CONNECTTIMEOUT => 120, // timeout on connect
CURLOPT_TIMEOUT => 120, // timeout on response
CURLOPT_MAXREDIRS => 10, // stop after 10 redirects
);

$ch = curl_init( $url );
curl_setopt_array( $ch, $options );
$content = curl_exec( $ch );
$err = curl_errno( $ch );
$errmsg = curl_error( $ch );
$header = curl_getinfo( $ch );
curl_close( $ch );

$header['errno'] = $err;
$header['errmsg'] = $errmsg;
$header['content'] = $content;
return $header;
}

function executeComment($name,$email,$url,$comment,$baseUrl,$postId)

{
$curlPost = ‘author=’.$name.’&email=’.$email.’&url=’.$url.’&comment=’ . urlencode($comment) . ‘&submit=Submit+Comment&comment_post_ID=’.$postId;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, ‘http://’.$baseUrl.’/wp-comments-post.php’);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $curlPost);
$data = curl_exec($ch);
curl_close($ch);

}

function getDomain($url)

{

$pt = explode(”/”,$url);
$burl = $pt[2];
$result = get_web_page( $url );

return $result;

}

// this is an url to post comment on …
$url = ‘http://www.branded07.com/2009/07/11/ie6-web-design-tricks/’;

// we need www.branded07.com domain name for future usage ,  we will use our getDomain() function

$domain = getDomain($url);

// now we need to crawl the page and to get post ID

// we crawling the post url

$result = get_web_page( $url );

// page content is in the $page variable
$page = $result['content'];

// getting the post ID with regular expressions

$matches = array();
preg_match( ‘!<input.*?name=”comment_post_ID”.*?value=”(.*?)”!’, $page, $matches );
// this is a comment id to post comment
$pid = $matches[1];

// execute comment posting with curl

$name = “glurt”;

$email = “admin@glurt.com”;

$url = “http://glurt.com”;

$comment = “This is the test comment”;

$baseUrl = $domain;

$postId = $pid;

executeComment($name,$email,$url,$comment,$baseUrl,$postId);

?>

Conclusion :
We figured out what variables uses wordpress blog to post comments, we used this data to create comments posting script that needs only one url of wordpress web blog.

//
// This is the class of which you want only one instance
//
class yourClassName {
…
//
// This is your classcontructor
//
function yourClassName() {
…
}
//
// This is your helperfunction for retrieving the instance
//
function &getInstance() {
static $instance;
if (!isSet($instance)) {
$instance = new singleton();
}
return $instance;
}
function someMemberFunction() {
…
}
…
}

The helperfunction getInstance is the global point for accessing your
instance. Within your application you can now use your class like this:
$instance =& yourClassName::getInstance();
$instance->someMeberFunction();
Notice the ampersand (&) used in the assignment of $instance, this sign
is very important because it makes sure you get the object itself and not a
copy of it. Just the same story goes for the ampersand preceding the name
of the member function getInstance() in the declaration of the class.
While looking on the web I found several implementations of the single-
ton pattern for PHP that are not working, because they do not make use
of the ampersand. So be careful with implementing this pattern and make
sure that you test your implementation.

2   Strategy pattern
Name: Strategy
Problem: You need several different stategies that solve the same problem
to be easily interchangeable with each other. For example, a website
with support for multiple languages and currencies.
Context: Any
Solution & Consequences: Solution:
• Create a super class (Strategy) that is used as a shared interface
for the concrete strategy classes.
• Define a subclass (ConcreteStragegy) for each strategy needed,
that overrides the member functions of the super class.
• Create a reference in your PHP application to one of the sub-
classes (the concrete strategy that you need) and use this refer-
ence throughout your program.
The consequence is that in the PHP-application you can freely change
the reference from one subclass to another (from one concrete strategy
to another) because they now have the same interface.
PHP does not support interfaces, so you are not forced to stick to the
interface of the super class. It is your own responsibility to check if
you stick to the interface.
UML diagram:

Implementation: In this example implementation we want to print a list
of names. We want two strategies: one for printing the list lexico-
graphically ascending, and one for printing the list lexicographically
descending.
Here is a sketch of the implementation:

//
// Superclass (the interface class)
//
class printListInterface {
function execute($namelist) {
}
}
//
// The subclass (concrete strategy) for printing the list ascending
//
class printListAscending extends printListInterface {
function execute($namelist) {
// Sort \$namelist in lex. ascending order and
// print the list
…
}
}
//
// The subclass (concrete strategy) for printing the list descending
//
class printListDescending extends printListInterface {
function execute($namelist) {
// Sort $namelist in lex. descending order and
// print the list
…
}
}
Now you can make a reference in you PHP application to the concrete
strategy of your choice:
$printList = new printListAscending();
and use the reference:
$names[0] = ’Ralf’;
$names[1] = ’Paul’;
$names[2] = ’Frank’;
$printList->execute($names);

3     Model View Controller pattern
Name: Model View Controller
Problem: You want to be able to change the appearance(UI) of your web
application from time to time, or you want to offer multiple UIs for
the same application in an easy manner.
Context: Changing or multiple UIs for the same application
Solution & Consequences: Devide your application into 3 parts:
The Model (Procesing): the model is a representation of the data
and the possible operations on it.
The View (Output): the view renders the contents of the model. It
is a view on the model.
The Controller (Input): the controller translates interactions with
the view into actions to be performed by the model.
Implementation: This is a sketch of an implementation of a MVC-pattern
applied to a web shop. In this example the user can look up a product,
or add a product to the system.
The Model Component:
This class is like a database wrapper or database adaptor
class ShoppingModel {
//
// Retrieve the product from the database
//
function getProduct($id) {
…
}
//
// Store a product in the database
//
function addProduct($id, $name, $description, $price) {
…
}
}

The View Component:
The view class is responsible for generating HTML(the view on the model)
class ShoppingView {
var $model;
//
// Class contructor that stores the model
//
function ShoppingView($model) {
$this->$model = $model;
}
//
// Print HTML-header
//
function printHeader {
…
}
//
// Print HTML-footer
//
function printFooter {
…
}
//
// Print HTML-representation of a product
//
function printProduct($id) {
$view->printHeader();
$product = $this->$model->getProduct($id);
// Give the HTML representation of the product item.
// By printing a some HTML tags and properties of the product
…
$view->printFooter();
}
//
// Print HTML-representation of a message
//
function printMessage($message) {
$this->printHeader();
print($message);
$this->printFooter();
}
}
Let us have a look at the controller component. I found some imple-
mentations of the MVC-pattern for PHP (like the MVC-pattern at [11])

that have a separate class for the controller part. That class is used in the
PHP-file the user requested. This suggests that the controller class is the
controller component of the MVC-pattern. This is not a nice way to apply
this pattern to PHP.
In this way the controller class is just a subset of the functionality of the
controller component. The controller class and PHP file together are the
controller component in the MVC-pattern. Because the functionality done
in the PHP file, also belongs to the controller, it is the part that interacts
with the user.
A better way of applying the MVC-pattern is to look at the PHP-file as
the controller component, so the controller component is the PHP-file itself:

Continuing the implementation example:
The Controller Component(index.php):
// initialize the model
$model = new ShoppingModel();
// initialize the view
$view = new ShoppingView($model);
// Check what action is defined in the URL
switch ($_GET[’action’]) {
// Show a product
case ’show_product’:
$view->printProduct($_GET[id]);
break;
// Add a product
case ’add_product’:
$model->addProduct($_GET[id],$_GET[name],$_GET[desc],$_GET[price]);
$view->printMessage(’Product added!’)
break;
default:
$view->printMessage(’No action found!’)
break;
}
So possible calls to this PHP-page:
• Show product with id 5:
index.php?action=show_product&id=5
• Add the candy bar to the products:
index.php?action=add_product&id=10&name=Candy%20bar&descr=…
These calls are normally made by the same (if you extend this controller)
or other controllers(read: PHP-pages) with the same model and view.
With this implementation we have a separation of the model, view and
the controller. As you can see now, it is rather easy to plug-in a new View
class resulting in a new UI for your web application.

4    SessionObject pattern
All the previous patterns are projections of existing pattern onto PHP. I
mean, they are general (and mostly Object Oriented) patterns that are
adapted to be used in PHP. The now following pattern is a new pattern
that I would like to introduce. It is a solution that I have used very often
in my history as a web programmer.
Name: SessionObject
Problem: You are programming a web application that makes use of ses-
sions and you want to remember the information about the session
(throughout the session) in an organised and structured way. E.g.
keep the shopping basket content available throughout the session in
a web shop.
Context: Web applications with sessions. Session information has to be
available throughout the session.
Solution & Consequences: Create a class definition that represents the
information that needs to be available throughout the session. At the
top of each PHP-page:
• Start or continue a session.
• Register a session variable(for holding the session object)
• Check if a session object exists, if not: create an instance of the
class(defined earlier) and assign it to the session variable.
Now you can always access the session information in an organised
way(via an object) and that object will be available during the whole
session.
Normally objects do not live very long in php, because they only exist
during the time of processing the PHP-page (mostly just a fraction of
a second). When you call a page, the objects are created and they
are used for the processing of the page. After the result has been sent
back to the user, all variables, including the objects, will be lost. With
this pattern you register an object as a session variable. That means
that, after the processing of the page, the object is stored in a textfile
together with the rest of the sessioninformation. At the time you that
you load the session again(in another pagerequest), the object will be
loaded again and will be available in your application.
Implementation: Let us have a look at an example of an implementation.
This is a stripped version of a ShoppingBasket object that I used in
web shops strore the products chosen / selected by the user. In this
example I make use of a well known ShoppingBasket pattern.

//
// This class stores the selected products
//
class ShoppingBasket {
var $productArray;
var $numberOfProducts;
…
//
// Adds a product to the productArray
//
function addProduct($id) {
// Add product with id=$id to the productArray
…
}
//
// Returns the array with the selected products
//
function getProductArray() {
return $productArray;
}
…
}
Your PHP-pages have to begin with this(because the function session start()
must be called before any output is written):
// If a session already exist: load session variables or create a new session if none exists.
session_start();
// Register the ShoppingBasket object as a sessionvariable
session_register(basket);
// If the basket-object does not exist, create one
if (!IsSet($basket)) {
$basket = new ShoppingBasket();
}
// Use the ShoppingBasket
$basket->addProduct(5);
$basket->addProduct(7);
$products = $basket->getProducArray();
If you have more than a few pages you could make a procedure (e.g.
my session start()) containing these lines. Then you just have to call my session start()
at the beginning of each page.
I tried to mix this pattern with the singleton pattern. My idea was to
make the ShoppingBasket-object a singleton, so you do not have to check

for the existence of an instance in the PHP-pages. But unfortunately this
does not work like that in PHP. This because of the fact that the static
instance variable in the loaded class (the session class) is different to the
static instance variable of our class definition in the PHP-file.
Problem and Pattern matching
In the beginning of this essay I stated some common problems. Afterwards
I introduced a few PHP-patterns. In this section I want to make a matching
of problems to a few important patterns.
Multiple presentations MVC pattern see 7.3
Navigation this is not a typically PHP problem, for navigational patterns
see [6] and [9]
Database operations Adaptor pattern (GoF) see [1] (convert the database
interface to an easy to use interface by making use of an adaptor class)
not discussed in this essay, but the Adaptor pattern is easy to project
on PHP.
Authentication and sessions SessionObject pattern see 7.4
These are some matchings that I find very usefull. This is not inteded
to be an exhausting list.
Conclusion
At first sight projecting known patterns to PHP looks quite easy. But if
you take a closer look and try to implement such patterns in PHP you will
probably figure out that there are some more problems to solve than you
thought of in the beginning. That is why there are a lot of PHP patterns
floating over the internet with poor quality.
These problems are mainly due to the fact that PHP is not a real object
oriented language and that the most patterns are object oriented. So we
can conclude that patterns depend on language expressiveness. In the fu-
ture it will be easier to map these(OO-) patterns to PHP because with the
introduction of newer versions the OO support in PHP will become more
mature.

Feald search engine introduced as a “Twitter media center” was beta launched two weeks ago. Feald is a promising  live search engine includes free twitter tools, youtube search and downloading features, flickr search and more.  The difference between feald live search and other industry giants like scoopler, kosmix and other popular live search engines is a mystical twitter tools that should increase twitter followers amounts. We interviewed the feald development group about Feald changes and updates. The live search will be more user friendly and they are going to change the layout.

Main feald features, that differs Feald from another live search websites  are :

• Wikipedia definitions on every live search
• Downloadable video search results ( Video downloaded in flash .flv format )
• Extended Live video search
• Free twitter tools without storing user passwords

We are waiting for the new features from Feald search engine, and we are sure they will surprise us with every bit of code added on board.

Source – Feald.com

The code is in front of you , you will need to get yahoo api developer key before, and to add it in request url :

<?php

$request = ‘http://local.yahooapis.com/MapsService/V1/mapImage?appid=YOUR_API_KEY&couuntry=germany&city=berlin&radius=’.$zoom.’&output=php’;

echo ‘<img src=”‘.$phpobj["Result"].’” alt=”" />’;

?>

let’s take a look at our request url, and here is the list of GET variables for proper API response :

• appid – is your application api key , you should get it on yahoo api request page.
• couuntry – is the country you are looking for
• city – is the city in mentioned country
• radius – the location radius in km.
• output – is the language used for the api response , in our case it is php.

$request = ‘http://local.yahooapis.com/MapsService/V1/mapImage?appid=YOUR_API_KEY&couuntry=israel&city=haifa&radius=0&output=php’;

It’s really simple and could be used as a great resourse for maps inside of application.

Have fun.

function TinyURL($u){

return file_get_contents(’http://tinyurl.com/api-create.php?url=’.$u);

}

Canonical plans to release Ubuntu 9.10, aka Karmic Koala, on Thursday. The open source operating system for both desktops and servers touches down around the same time as Windows 7. Code writers gave special attention to the core server product and kernel in this latest edition. They also asked the user community to list minor annoyances they had with the previous version so they could be tweaked and fixed.

Canonical, the commercial developer of the open source operating system Ubuntu, will release on Thursday Ubuntu 9.10 Server Edition and Ubuntu 9.10 Desktop Edition. The two latest releases, which go by the moniker “Karmic Koala,” come on the heals of last week’s release of Microsoft’s (Nasdaq: MSFT) Windows 7 operating system.

The latest Ubuntu releases could raise the ante in the competitive field of computer operating systems, where Microsoft, Apple (Nasdaq: AAPL) and open source offerings like Ubuntu vie for users.

Ubuntu 9.10 Server Edition introduces Ubuntu Enterprise Cloud (UEC) as a fully supported technology. Ubuntu 9.10 desktop features a redesigned interface with faster boot and login, a revamped audio framework and improved 3G broadband connectivity.

“This is a busy week for operating systems. But users get the advantage because it’s a great time for consumers to try out Ubuntu for free rather than paying for an upgrade to Windows 7,” Steve George, director of support and products for Canonical, told LinuxInsider.

Feigned Competition

Canonical is not planning to initiate a special media campaign against Windows 7, which was released last week. In fact, the fact that both new operating system releases are taking place at roughly the same time is purely accidental, according to George.

“Actually, we think Microsoft planned its release to coincide with ours,” quipped George.

The nomenclature for Canonical’s release timetable is based on the year and month of the planned release. So Ubuntu 9.10 stands for 2009, 10th month. This latest version comes with free security upgrades for 18 months, he explained.

Server Specifics

Code writers gave special attention to the core server product and kernel in this latest edition. For example, numerous kernel improvements support both Xen (guest) and KVM (host and guest) virtualization. Caching performance is also improved.

Developers added MySQL 5.1 and upgraded the directory stack and Single Sign On tools for improved directory integration. This version offers fully supported framework enhancing Web server options.

Also included is support for the USB 3.0 protocol to handle higher transfer rates when those devices become available. Server users will get additional system management support through the WBEM (Web-based enterprise management) protocols, which open up support of Ubuntu environment to the most popular system management tools currently deployed in enterprises.

Ubuntu’s own systems management tool, Landscape, now has a dedicated server for its hosted version that allows deployments to be managed entirely within the firewall and will fully support Ubuntu 9.10 Server Edition and Ubuntu Enterprise Cloud.

Desktop Delights

In their approach to growing this newest Ubuntu version, Canonical code writers made it a point to focus on details. The 100 Paper Cuts initiative organized with the Ubuntu community allowed users to nominate minor annoyances that impacted their enjoyment of the platform.

That feedback so far led to over 50 fixes that removed minor irritants, such as inconsistent naming or poorly organized application choices. Larger-scale user experience improvements include a refreshed Ubuntu Software Center. This gives users easier access to information about the software available and brings the world of open source applications closer to them.

Plus One More

Ubuntu 9.10 includes the integration of ‘Ubuntu One’ as a standard component of the desktop. This is an umbrella name for a suite of online services which were released in beta in May 2009.

Ubuntu One offers users an enhanced desktop experience with simplified backup, synchronization and sharing of files with an expanded set of features including Tomboy Notes and contacts synchronization.

Netbook and smartbook users will be able to use the Ubuntu 9.10 Netbook Remix (UNR) interface. UNR integrates the Empathy instant messaging program for text, voice, video and file transfers to make communication easier.

Effortless Experience

“Ubuntu 9.10 gives users more reasons than ever to seriously consider Linux at a time when many are thinking again about their operating system options. We are delivering a platform for users interested in an easy-to-use, great-looking, Web-friendly operating system,” said Jane Silber, COO at Canonical.

Deployment on popular notebook, desktop and netbook models continue to drive Ubuntu into the mainstream of computing choices, she said.

Opportune Time

The main significance for consumers to consider Ubuntu as an alternative to Windows 7 is the cost of upgrading, according to George. The new release will work with most current-generation hardware, so users will not have to worry about costly upgrades, he explained.

“We see three main reasons to consider Ubuntu as a Windows 7 alternative. One is it is easy to use. Two, it’s fun to work with a beautiful interface. Three, Ubuntu comes with all the applications consumers and business users need,” said George.

Consumers can install the latest Ubuntu release within Windows XP or Windows Vista to try out a fully functional version of the open source operating system, noted George. This way, the existing Windows environment remains intact on the user’s computer until a decision is made between migrating to Ubuntu or staying with Windows.

“We’ve seen a few phishing attempts today; if you’ve received a strange (direct message), and it takes you to a Twitter log-in page, don’t do it!” the Twitter spam warning says.

The direct messages say: “hi. this you on here? http://blogger.djh****.com,” Sophos reports in a blog post. The full URL is obscured to prevent people from unwittingly visiting the phishing site.

Clicking on the link takes a user to a page that looks like a legitimate Twitter log-in page. When the user types in the username and password, a fake version of Twitter’s “over capacity” message is displayed, with the image of the notorious “fail whale” held aloft by birds.

Scam message is sent automatically by phishing bot program, there are the couple of fake users registered under various usernames , the message is received through. You may also receive this kind of message from your followers, don’t unfollow them, send them a message and ask to change their twitter passwords.

If you have been duped by this phishing ruse, Glurt suggests that you immediately change your password at Twitter and any other sites where you used the same log-in credentials.