Public our docs

Object-Oriented PHP for Beginners

•05/27/2011 • Leave a Comment

For many PHP programmers, object-oriented programming is a frightening concept, full of complicated syntax and other roadblocks. As detailed in my book, Pro PHP and jQuery, you’ll learn the concepts behind object-oriented programming (OOP), a style of coding in which related actions are grouped into classes to aid in creating more-compact, effective code.

Understanding Object-Oriented Programming

Object-oriented programming is a style of coding that allows developers to group similar tasks into classes. This helps keep code following the tenet “don’t repeat yourself”

(DRY) and easy-to-maintain.

“Object-oriented programming is a style of coding that allows developers to group similar tasks into classes.”

One of the major benefits of DRY programming is that, if a piece of information changes in your program, usually only one change is required to update the code. One of the biggest nightmares for developers is maintaining code where data is declared over and over again, meaning any changes to the program become an infinitely more frustrating game of Where’s Waldo? as they hunt for duplicated data and functionality.

OOP is intimidating to a lot of developers because it introduces new syntax and, at a glance, appears to be far more complex than simple procedural, or inline, code. However, upon closer inspection, OOP is actually a very straightforward and ultimately simpler approach to programming.

Understanding Objects and Classes

Before you can get too deep into the finer points of OOP, a basic understanding of the differences between objects and classes is necessary. This section will go over the building blocks of classes, their different capabilities, and some of their uses.

Recognizing the Differences Between Objects and Classes

Photos by Instant Jefferson and John Wardell

“Developers start talking about objects and classes, and they appear to be interchangeable terms. This is not the case, however.”

Right off the bat, there’s confusion in OOP: seasoned developers start talking about objects and classes, and they appear to be interchangeable terms. This is not the case, however, though the difference can be tough to wrap your head around at first.

A class, for example, is like a blueprint for a house. It defines the shape of the house on paper, with relationships between the different parts of the house clearly defined and planned out, even though the house doesn’t exist.

An object, then, is like the actual house built according to that blueprint. The data stored in the object is like the wood, wires, and concrete that compose the house: without being assembled according to the blueprint, it’s just a pile of stuff. However, when it all comes together, it becomes an organized, useful house.

Classes form the structure of data and actions and use that information to build objects. More than one object can be built from the same class at the same time, each one independent of the others. Continuing with our construction analogy, it’s similar to the way an entire subdivision can be built from the same blueprint: 150 different houses that all look the same but have different
families and decorations inside.

Structuring Classes

The syntax to create a class is pretty straightforward: declare a class using the class keyword, followed by the name of the class and a set of curly braces ({}):

view plain copy to clipboard print ?

<?php
class MyClass
{
// Class properties and methods go here
}
?>

After creating the class, a new class can be instantiated and stored in a variable using the new keyword:

view plain copy to clipboard print ?

$obj = new MyClass;

To see the contents of the class, use var_dump():

view plain copy to clipboard print ?

var_dump($obj);

Try out this process by putting all the preceding code in a new file called test.php in [your local] testing folder:

view plain copy to clipboard print ?

<?php
class MyClass
{
// Class properties and methods go here
}
$obj = new MyClass;
var_dump($obj);
?>

Load the page in your browser at http://localhost/test.php and the following should display:

object(MyClass)#1 (0) { }

In its simplest form, you’ve just completed your first OOP script.

Defining Class Properties

To add data to a class, properties, or class-specific variables, are used. These work exactly like regular variables, except they’re bound to the object and therefore can only be accessed using the object.

To add a property to MyClass, add the following code to your script:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
}
$obj = new MyClass;
var_dump($obj);
?>

The keyword public determines the visibility of the property, which you’ll learn about a little later in this chapter. Next, the property is named using standard variable syntax, and a value is assigned (though class properties do not need an initial value).

To read this property and output it to the browser, reference the object from which to read and the property to be read:

view plain copy to clipboard print ?

echo $obj->prop1;

Because multiple instances of a class can exist, if the individual object is not referenced, the script would be unable to determine which object to read from. The use of the arrow (->) is an OOP construct that accesses the contained properties and methods of a given object.

Modify the script in test.php to read out the property rather than dumping the whole class by modifying the code as shown:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
}
$obj = new MyClass;
echo $obj->prop1; // Output the property
?>

Reloading your browser now outputs the following:

view plain copy to clipboard print ?

I’m a class property!

Defining Class Methods

Methods are class-specific functions. Individual actions that an object will be able to perform are defined within the class as methods.

For instance, to create methods that would set and get the value of the class property $prop1, add the following to your code:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
$obj = new MyClass;
echo $obj->prop1;
?>

Note — OOP allows objects to reference themselves using $this. When working within a method, use $this in the same way you would use the object name outside the class.

To use these methods, call them just like regular functions, but first, reference the object they belong to. Read the property from MyClass, change its value, and read it out again by making the modifications below:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
$obj = new MyClass;
echo $obj->getProperty(); // Get the property value
$obj->setProperty(“I’m a new property value!”); // Set a new one
echo $obj->getProperty(); // Read it out again to show the change
?>

Reload your browser, and you’ll see the following:

view plain copy to clipboard print ?

I’m a class property!
I’m a new property value!

“The power of OOP becomes apparent when using multiple instances of the
same class.”

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create two objects
$obj = new MyClass;
$obj2 = new MyClass;
// Get the value of $prop1 from both objects
echo $obj->getProperty();
echo $obj2->getProperty();
// Set new values for both objects
$obj->setProperty(“I’m a new property value!”);
$obj2->setProperty(“I belong to the second instance!”);
// Output both objects’ $prop1 value
echo $obj->getProperty();
echo $obj2->getProperty();
?>

When you load the results in your browser, they read as follows:

view plain copy to clipboard print ?

I’m a class property!
I’m a class property!
I’m a new property value!
I belong to the second instance!

As you can see, OOP keeps objects as separate entities, which makes for easy separation of different pieces of code into small, related bundles.

Magic Methods in OOP

To make the use of objects easier, PHP also provides a number of magic methods, or special methods that are called when certain common actions occur within objects. This allows developers to perform a number of useful tasks with relative ease.

Using Constructors and Destructors

When an object is instantiated, it’s often desirable to set a few things right off the bat. To handle this, PHP provides the magic method __construct(), which is called automatically whenever a new object is
created.

For the purpose of illustrating the concept of constructors, add a constructor to MyClass that will output a message whenever a new instance of the class is created:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Output a message at the end of the file
echo ”End of file. ”;
?>

Note — __CLASS__ returns the name of the class in which it is called; this is what is known as a magic constant. There are several available magic constants, which you can read more about in the PHP manual.

Reloading the file in your browser will produce the following result:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
I’m a class property!
End of file.

To call a function when the object is destroyed, the __destruct() magic method is available. This is useful for class cleanup (closing a database connection, for instance).

Output a message when the object is destroyed by defining the magic method
__destruct() in MyClass:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Output a message at the end of the file
echo ”End of file. ”;
?>

With a destructor defined, reloading the test file results in the following output:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
I’m a class property!
End of file.
The class ”MyClass” was destroyed.

“When the end of a file is reached, PHP automatically releases all resources.”

To explicitly trigger the destructor, you can destroy the object using the
function unset():

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo ”End of file. ”;
?>

Now the result changes to the following when loaded in your browser:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
I’m a class property!
The class ”MyClass” was destroyed.
End of file.

Converting to a String

To avoid an error if a script attempts to output MyClass as a string, another magic method is used called __toString().

Without __toString(), attempting to output the object as a string results in a fatal error. Attempt to use echo to output the object without a magic method in place:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create a new object
$obj = new MyClass;
// Output the object as a string
echo $obj;
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo ”End of file. ”;
?>

This results in the following:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
Catchable fatal error: Object of class MyClass could not be converted to string in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 40

To avoid this error, add a __toString() method:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function __toString()
{
echo ”Using the toString method: ”;
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
// Create a new object
$obj = new MyClass;
// Output the object as a string
echo $obj;
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo ”End of file. ”;
?>

In this case, attempting to convert the object to a string results in a call to the getProperty() method. Load the test script in your browser to see the result:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
Using the toString method: I’m a class property!
The class ”MyClass” was destroyed.
End of file.

Tip — In addition to the magic methods discussed in this section, several others are available. For a complete list of magic methods, see the PHP manual page.

Using Class Inheritance

Classes can inherit the methods and properties of another class using the extends keyword. For instance, to create a second class that extends MyClass and adds a method, you would add the following to your test file:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function __toString()
{
echo ”Using the toString method: ”;
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
class MyOtherClass extends MyClass
{
public function newMethod()
{
echo ”From a new method in ” . __CLASS__ . ”. ”;
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?>

Upon reloading the test file in your browser, the following is output:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
From a new method in MyOtherClass.
I’m a class property!
The class ”MyClass” was destroyed.

Overwriting Inherited Properties and Methods

To change the behavior of an existing property or method in the new class, you can simply overwrite it by declaring it again in the new class:

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function __toString()
{
echo ”Using the toString method: ”;
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
echo ”A new constructor in ” . __CLASS__ . ”. ”;
}
public function newMethod()
{
echo ”From a new method in ” . __CLASS__ . ”. ”;
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?>

This changes the output in the browser to:

view plain copy to clipboard print ?

A new constructor in MyOtherClass.
From a new method in MyOtherClass.
I’m a class property!
The class ”MyClass” was destroyed.

Preserving Original Method Functionality While Overwriting Methods

To add new functionality to an inherited method while keeping the original method intact, use the parent keyword with the scope resolution operator (::):

view plain copy to clipboard print ?

<?php
class MyClass
{
public $prop1 = ”I’m a class property!”;
public function __construct()
{
echo ’The class ”‘, __CLASS__, ’” was initiated! ’;
}
public function __destruct()
{
echo ’The class ”‘, __CLASS__, ’” was destroyed. ’;
}
public function __toString()
{
echo ”Using the toString method: ”;
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . ” ”;
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct(); // Call the parent class’s constructor
echo ”A new constructor in ” . __CLASS__ . ”. ”;
}
public function newMethod()
{
echo ”From a new method in ” . __CLASS__ . ”. ”;
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?>

This outputs the result of both the parent constructor and the new class’s constructor:

view plain copy to clipboard print ?

The class ”MyClass” was initiated!
A new constructor in MyOtherClass.
From a new method in MyOtherClass.
I’m a class property!
The class ”MyClass” was destroyed.

Assigning the Visibility of Properties and Methods

For added control over objects, methods and properties are assigned visibility. This controls how and from where properties and methods can be accessed. There are three visibility keywords: public, protected, and private. In addition to its visibility, a method or property can be declared as static, which allows them to be accessed without an instantiation of the class.

Reference: http://net.tutsplus.com/tutorials/php/object-oriented-php-for-beginners/

Posted in PHP

HOW TO SHARE SUBREPORT DATA WITH THE MAIN REPORT.

•05/12/2011 • Leave a Comment

The information in the article refers to
Crystal Reports and BusinessObjects Reports
Applies to
Shared variables
Passing data between subreport and main report
Synopsis
A report contains a subreport. Data from the subreport is required for calculations in the main report.

How can you share subreport data with the main report in version 7 (or higher) of the Crystal Reports Designer?
Solution
Shared variables, make it easier to pass values from a subreport to the main report. Using shared variables requires two formulas: one to store the value in a shared variable, the other to retrieve the value from the shared variable.

The most important thing to remember when using shared variables is that Crystal Reports must first evaluate the formula where the value is stored before evaluating the formula that retrieves the shared variable.

For example if you want to pass a grand total from the subreport to do a calculation in the main report, follow these steps:

1. In the subreport, create a formula similar to the one below:

//@SubFormula
//Stores the grand total of the
//{Orders.Order Amount} field
//in a currency variable called ‘myTotal’

WhilePrintingRecords;
Shared CurrencyVar myTotal := Sum ({Orders.Order Amount})

2. Place this formula in your subreport.

3. In the main report, create a formula that declares the same variable name:

//@MainFormula
//Returns the value that was stored
//in the shared currency variable called
//myTotal in the subreport

WhilePrintingRecords;
Shared CurrencyVar myTotal;
myTotal

4. Place @MainFormula in a main report section that is beneath the section containing the subreport.

NOTE:
For the shared variable to return the correct value in the main report, you must place @MainFormula in a main report section that is beneath the section containing the subreport. This ensures Crystal Reports evaluates the @SubFormula before @MainFormula.

One way to do this is to insert a section below the section containing the subreport, and place @MainFormula in this new sub-section:

? On the ‘Format’ menu, click ‘Section’.

? On the ‘Sections’ list, click the section containing the subreport.

? Click ‘Insert’ (at top of dialog box). This inserts an additional subsection.

? Click ‘OK’ to return to the report, and insert @MainFormula into this new sub-section.

The next time you preview the report, @MainFormula displays the value from the subreport. In this particular example, that value was the grand total of the {Orders.Order Amount} field.

5. Once you have verified that @MainFormula is returning the correct value from the subreport, you can include this formula in other main report formulas, such as:

//@NewFormula
//includes data from subreport

{@MainFormula} + Sum ({Customer.Last Year’s Sales})

? Place this formula in the same section as @MainFormula, or in a section further down on the report.

You have now successfully shared data from a subreport with the main report.

NOTE:
This is not possible with On Demand Subreports in Crystal Reports since the report will not be processed until after clicking report.
http://www.datamanagementgroup.com/Resources/TrainersTalk/trainerstalk_howto_share_subreport_data_with_main_report.asp

Posted in Crystal Report

Reva Aims to Alleviate ‘Range Anxiety’

•12/31/2010 • Leave a Comment

Apparently if you won’t go to electrics, electric car companies are taking pains to come to you.

First, we had Tesla’s vice president of business development, Diarmuid O’Connell, talking about “remote techs” servicing Tesla models in areas around the country without showrooms or repair stations. Now comes word that Indian electric car company Reva will be unveiling plans for emergency remote recharging at the Frankfurt Auto Show in six days’ time.

The two models featuring the REVive refueling option — which allows Reva drivers to call or text the company for an on-site recharge — are the 4-seat, family-oriented NXR hatchback and the sporty 2-seat NXG (pictured).

Both models aim to lure drivers with “range anxiety” (i.e. the fear of running out of charge midtrip) by assuring them that a charge is always available, though details of how, exactly, the company will deliver on that promise won’t be revealed until Sept. 16.

While Reva — a joint venture between Maini Group of India and AEV LLC of California — sells or test-markets cars in more than 24 countries and claims to have the largest fleet of EVs on the road with more than 3,000 vehicles deployed, there are no specific plans (that we’ve heard) to send the cars stateside. Given the backlash against EVs in general and small cars in particular that we’ve been reading recently in our own comments sections, that may be a smart choice.

Reference www.msn.com

Posted in Cars

Audi, Electric

•12/24/2010 • Leave a Comment

Don’t tell Audi of America President Johan de Nysschen, but someone at the company went and made an electric vehicle — and a pretty good-looking one, at that.

Of course, we kid, we kid; the man’s not fundamentally opposed to electrics — just certain aspects of the way the technology is being promoted. And, with the e-Tron’s R8-inspired design in Audi’s stable (proving true these rumors), he himself has plenty of reasons to make converts out of electric naysayers.

According to the AutoWeek article, the company is behind electrics for various reasons — immediately available torque in a sports car such as this one, for one thing, as well as the same reducing-oil-dependency and cleaner-emissions arguments you hear ad nauseam — but is also upfront about the drawbacks of how electrics exist in their current iteration. The Catch-22 of EVs is that performance and range increase only with larger, heavier batteries, while the larger and heavier the batteries become, the less efficient (as in, less fun to drive, more power drained to move the vehicle) the cars become. But these are issues everyone is trying to tackle in the electric arena, and if we’re going to have to live with drawbacks, we’d rather they exist in a car that looks like the e-Tron.

Reference www.msn.com

Posted in Cars

Gilding the Lily: Another Supercar Reveal

•12/17/2010 • Leave a Comment

First we heard the shouts about the McLaren MP4-12C, and the Mercedes SLS AMG made its own splash less than a day later. Apparently, Lamborghini has had enough of not being in the limelight. Ahead of its Frankfurt debut, the Italian supercar stalwart has revealed its own shots (or had them revealed despite their efforts — still unclear) of the new Reventon Roadster.

The scoop on the new drop-top (following the coupe’s debut two years after the 2007 Frankfurt show): Only 20 of the machines will be made next year, at a cost of $1.67 million each; that buys you, at the very least, the same massive 6.7-liter V12 engine found under the hood of the Murcielago.

Funny aside: About two years ago I got a desperate call from the Web editor of Popular Science; she said, essentially, that one of her car writers assigned to the Reventon press reveal had to duck out, and could she put me on a plane to Italy that afternoon in order to test-drive the new Lambo the next day? Sadly, I was on deadline for another project, and had to decline (despite every instinct telling me I should drop the conflicting assignment). I’ve regretted it ever since. The moral of the story is: Never say no to someone offering you a free trip to Italy to drive the newest supercar from Lamborghini.

Reference www.msn.com

Posted in Cars

The World’s Most Efficient Car?

•12/10/2010 • Leave a Comment

It’s funny hearing the boasts coming from the Frankfurt Motor Show. Whereas in years past the arms race seemed centered on speed and power — fastest time to 60 mph or most muscular top speed — carmakers (unsurprisingly) seem to be shouting from the hilltops about fuel efficiency and miles per gallon.

The latest town crier is VW, with its diesel-powered L1 concept hybrid, and it certainly has the efficiency paperwork: Total weight is kept to a staggeringly light 838 pounds thanks to lightweight components such as a carbon fiber-reinforced body, aluminum brakes and ceramic bearings. And the minuscule tank holds a mere 1.7 gallons of fuel — which, it should be mentioned, will get the car 306 miles farther down the road, according to some reports of its purported 180 mpg capability.

The tiny, aerodynamic L1 — which goes into limited production next year and will have a full run in 2013 — is the result of a Volkswagen research project that began way back in 1998. And, as anyone who’s read Exhaust Notes regularly could predict, we applaud its efforts toward real gains in fuel efficiency and clever engineering. We are, however, a little nostalgic for some old-school, gas-bill-be-damned, pin-you-to-your seat performance numbers.

Reference www.msn.com

Posted in Cars

The Prancing Horse Rides Away the Winner

•12/03/2010 • Leave a Comment

Honestly, everyone should have seen this coming. Just look at it: This car was simply too stunning to be anything but the winner, and now AutoWeek, at least, has confirmed it by naming the Ferrari 458 Italia the Best in Show at Frankfurt. And while cream-of-the-crop contenders such as the Maserati GranCabrio, Mercedes-Benz SLS, Aston Martin Rapide, Bentley Mulsanne, Rolls-Royce Ghost, Lamborghini Reventon Roadster and Audi R8 Spider were all in the running, each, in the end, had to bow down to the swooping, sexy and somewhat menacing V8-powered monster with the 562 horses.

Other awards went to: The BMW Vision EfficientDynamics (Best Concept), the Porsche 911 Turbo (Most Fun, and again beating out Maserati’s GranCabrio … poor Maserati) and, for Most Significant, Renault’s entire four-model lineup of production electric vehicles.

Reference www.msn.com

Posted in Cars

Ask, Ye Shall Receive

•11/26/2010 • Leave a Comment

Hey, so, remember a couple of days ago, when we were whinging about carmakers abandoning over-the-top feats of performance for under-the-EPA-mandated fuel-efficiency numbers? Well, the Brabus EV12 “one of 10″ is here to make it all better.

How does a SV12 R Biturbo 800 12-cylinder displacement engine putting out 800 horses and pushing an insane top speed of 230 mph sound? Sounds like performance to us, and it’s exactly what the “Black Baron” has under the hood, and the numbers it puts out.

The murdered-out all-black look is fitting with the aggressive lines (based on the 2010 Mercedes E-Class W 212), though we can’t say we’re big fans of the rear wheel covers, whether they aid with the aerodynamics or not. But a little visual discordance is a small price to pay for that 6.3-liter V12 and an interior enveloped in black leather and carbon-fiber components. That is, however, the only small price, as it will put you back $875,000 to park this beast in your garage, and the “one of 10″ moniker is a literal indication of its production run: Only 10 will be made.

Reference www.msn.com

Posted in Cars

Open Source Cars: Corporate Sharing is Caring

•11/19/2010 • Leave a Comment

All the green sheet metal on display at this year’s Frankfurt Motor Show proves most manufacturers are at least beginning to think of tackling the pesky end of the petroleum problem. Back in March, a company called EDAG showed its own solution to the energy and climate debacle at the Geneva Motor Show: the Light Car – Open Source. If you’ve spent any time in the software realm, odds are you know open source generally means a free platform for developers to expand upon. In EDAG’s case, the company’s car is just that: a joint project of several innovative companies all focused on the next step in automobile evolution.

While the Light Car – Open Source boasts a full array of lightweight materials, an innovative drivetrain and interesting lighting, EDAG isn’t the first group to partner up for the good of motoring. Nearly every manufacturer has formed partnerships in the past. Familiar names like Chrysler, General Motors, Hyundai, Ford and Nissan have all jumped into bed with fellow carmakers at least once in their history to produce everything from engines and transmissions to full-on vehicles — with mixed results.

Rumors have been buzzing around the Internet for months now about a supposed collaboration between Toyota and Subaru. Code-named the 086A, the car should be an inexpensive front-engine, rear-wheel-drive car with more than a little pep in its step. While recent financial woes have caused the project to be an on-again, off-again affair, both companies now say the car is inching closer to reality. If and when we do see the car in the flesh, expect to see similar iterations on both Subaru and Toyota lots.

Chrysler is renowned for its occasionally successful mash-ups with companies from around the globe. The Pentastar logo did a little badge swapping with Mitsubishi back in the ’80s, wherein Mitsubishi Starions were sold under the Chrysler and Dodge Conquest name here in the States. Fast forward a few decades, and America’s ailing automaker recently struck a deal with Nissan to produce the Japanese company’s Titan pickup truck. Unfortunately for both parties, Chrysler’s recent stint in bankruptcy court means we won’t be seeing any Nissan products with Hemis under the hood any time soon.

With less and less consumer cash swirling around the global marketplace, it wouldn’t surprise us to see more open-source-type collaborations between rivals soon. While the thought of a Ford-engined, Chevrolet-transmissioned, Chrysler-bodied vehicle may sound like sacrilege to some, it may be the only way for manufacturers to cut costs and tackle fuel-saving innovations in one throw.

Reference www.msn.com

Posted in Cars

A Grand Achievement

•11/12/2010 • Leave a Comment

For those who missed it, earlier this month PopMechanics did a bang-up piece on the attempt to push the land speed record up to 1,000 mph. The story focuses mostly on the British team Bloodhound Supersonic Car (SSC) and project director Richard Noble, though credit is given to the other teams around the world that are trying to break the mark: the North American Eagle team, retrofitting a land-based adaptation of an F-104 Starfighter military jet; the late billionaire adventurer Steve Fossett’s crew, which is looking for a new owner after finishing work on Craig Breedlove’s 1997 LSR car; and Australian Rosco McGlashan’s Aussie Invader 5R rocket-powered car.

The glory that would result from actually achieving this mind-blowing goal does not come cheap; Noble’s Bloodhound team needs an estimated $16.3 million to construct and test the car in the next few years. The team, smartly, is trying to defray costs by appealing to the UK government about the project’s educational benefits. Noble notes that the engineering feats that create land-speed records are far more transparent than, say, defense projects or Formula One racing. The article mentions the possible correlation between large-scale engineering and science projects and the number of Ph.D.s awarded during the projects’ time frame — something called the Apollo effect, which saw the number of U.S. Ph.D.s awarded jump from 12,000 to 30,000 during the Apollo program years, and drop off when the program ended.

In any case, it’s a fascinating read. It’s sort of like how we can go to the moon, but know very little about the bottom of our oceans. After all, we’re land-based creatures, and yet we leapfrogged to moon exploration and the bottom of the ocean — thanks, Discovery Earth! — without, perhaps, truly pushing the limits of what we can do out in the desert. Noble and the Bloodhound team, among a few others, are trying to change that.

Reference www.msn.com

Posted in Cars

Understanding Object-Oriented Programming

Understanding Objects and Classes

Recognizing the Differences Between Objects and Classes

Structuring Classes

Defining Class Properties

Defining Class Methods

Magic Methods in OOP

Using Constructors and Destructors

Converting to a String

Using Class Inheritance

Overwriting Inherited Properties and Methods

Preserving Original Method Functionality While Overwriting Methods

Assigning the Visibility of Properties and Methods

Categories

Hot posts

Children in Cambodia

Computer shops

Entertaiments

Hotel in Cambodia

Jobs in Cambodia

New Cars

Newspapers

Order web

Scholarship

Technology

University(Cambodia)

University(International)

Menu

Visitor

Follow “Public our docs”