Today I'm excited to share the project a small team of amazing people and I have been working on for the past two years; HipHop for PHP. With HipHop we've reduced the CPU usage on our Web servers on average by about fifty percent, depending on the page. Less CPU means fewer servers, which means less overhead. This project has had a tremendous impact on Facebook. We feel the Web at large can benefit from HipHop, so we are releasing it as open source this evening in hope that it brings a new focus toward scaling large complex websites with PHP. While HipHop has shown us incredible results, it's certainly not complete and you should be comfortable with beta software before trying it out.

HipHop for PHP isn't technically a compiler itself. Rather it is a source code transformer. HipHop programmatically transforms your PHP source code into highly optimized C++ and then uses g++ to compile it. HipHop executes the source code in a semantically equivalent manner and sacrifices some rarely used features — such as eval() — in exchange for improved performance. HipHop includes a code transformer, a reimplementation of PHP's runtime system, and a rewrite of many common PHP Extensions to take advantage of these performance optimizations.

Scaling PHP as a Scripting Language
PHP's roots are those of a scripting language, like Perl, Python, and Ruby, all of which have major benefits in terms of programmer productivity and the ability to iterate quickly on products. This is compared to more traditional compiled languages like C++ and interpreted languages like Java. On the other hand, scripting languages are known to generally be less efficient when it comes to CPU and memory usage. Because of this, it's been challenging to scale Facebook to over 400 billion PHP-based page views every month.

One common way to address these inefficiencies is to rewrite the more complex parts of your PHP application directly in C++ as PHP Extensions. This largely transforms PHP into a glue language between your front end HTML and application logic in C++. From a technical perspective this works well, but drastically reduces the number of engineers who are able to work on your entire application. Learning C++ is only the first step to writing PHP Extensions, the second is understanding the Zend APIs. Given that our engineering team is relatively small — there are over one million users to every engineer — we can't afford to make parts of our codebase less accessible than others.

Scaling Facebook is particularly challenging because almost every page view is a logged-in user with a customized experience. When you view your home page we need to look up all of your friends, query their most relevant updates (from a custom service we've built called Multifeed), filter the results based on your privacy settings, then fill out the stories with comments, photos, likes, and all the rich data that people love about Facebook. All of this in just under a second. HipHop allows us to write the logic that does the final page assembly in PHP and iterate it quickly while relying on custom back-end services in C++, Erlang, Java, or Python to service the News Feed, search, Chat, and other core parts of the site.

Since 2007 we've thought about a few different ways to solve these problems and have even tried implementing a few of them. The common suggestion is to just rewrite Facebook in another language, but given the complexity and speed of development of the site this would take some time to accomplish. We've rewritten aspects of the Zend Engine — PHP's internals — and contributed those patches back into the PHP project, but ultimately haven't seen the sort of performance increases that are needed. HipHop's benefits are nearly transparent to our development speed.

Hacking Up HipHop
One night at a Hackathon a few years ago (see Prime Time Hack), I started my first piece of code transforming PHP into C++. The languages are fairly similar syntactically and C++ drastically outperforms PHP when it comes to both CPU and memory usage. Even PHP itself is written in C. We knew that it was impossible to successfully rewrite an entire codebase of this size by hand, but wondered what would happen if we built a system to do it programmatically.

Finding new ways to improve PHP performance isn't a new concept. At run time the Zend Engine turns your PHP source into opcodes which are then run through the Zend Virtual Machine. Open source projects such as APC and eAccelerator cache this output and are used by the majority of PHP powered websites. There's also Zend Server, a commercial product which makes PHP faster via opcode optimization and caching. Instead, we were thinking about transforming PHP source directly into C++ which can then be turned into native machine code. Even compiling PHP isn't a new idea, open source projects like Roadsend and phc compile PHP to C, Quercus compiles PHP to Java, and Phalanger compiles PHP to .Net.

Needless to say, it took longer than that single Hackathon. Eight months later, I had enough code to demonstrate it is indeed possible to run faster with compiled code. We quickly added Iain Proctor and Minghui Yang to the team to speed up the pace of the project. We spent the next ten months finishing up all the coding and the following six months testing on production servers. We are proud to say that at this point, we are serving over 90% of our Web traffic using HipHop, all only six months after deployment.

How HipHop Works
The main challenge of the project was bridging the gap between PHP and C++. PHP is a scripting language with dynamic, weak typing. C++ is a compiled language with static typing. While PHP allows you to write magical dynamic features, most PHP is relatively straightforward. It's more likely that you see if (...) {...} else {..} than it is to see function foo($x) { include $x; }. This is where we gain in performance. Whenever possible our generated code uses static binding for functions and variables. We also use type inference to pick the most specific type possible for our variables and thus save memory.

The transformation process includes three main steps:

Static analysis where we collect information on who declares what and dependencies,
Type inference where we choose the most specific type between C++ scalars, String, Array, classes, Object, and Variant, and
Code generation which for the most part is a direct correspondence from PHP statements and expressions to C++ statements and expressions.

We have also developed HPHPi, which is an experimental interpreter designed for development. When using HPHPi you don't need to compile your PHP source code before running it. It's helped us catch bugs in HipHop itself and provides engineers a way to use HipHop without changing how they write PHP.

Overall HipHop allows us to keep the best aspects of PHP while taking advantage of the performance benefits of C++. In total, we have written over 300,000 lines of code and more than 5,000 unit tests. All of this will be released this evening on GitHub under the open source PHP license.

Learn More this Evening
This evening we're hosting a small group of developers to dive deeper into HipHop for PHP and will be streaming this tech talk live. Check back here around 7:30pm Pacific time if you'd like to watch.

As I'm sure there will be plenty of questions, starting this evening take a look at the HipHop wiki or join the HipHop developer mailing list. You'll also find us at FOSDEM, SCALE, PHP UK, ConFoo, TEK X, and OSCON over the next few months talking about HipHop for PHP. We're very excited to evolve HipHop into a thriving open source project along with all of you.

Referance By : http://developers.facebook.com/news.php?story=358&blog=1

Session sharing in web clusters

If you have multiple webservers all serving the same site, sessions should be shared among those servers, and not reside on each server's individual disk. Because once a user gets load-balanced to a different server, the session cannot be found, effectively logging the user out.

A common way around this is to use custom session handlers. Writing a class that overrules default behavior and stores sessions in a MySQL database.

Sessions in Database

All webservers connect to the same database and so, as soon as www01 registers a session (insert in a sessions table), www02 can read it. All servers can now see all sessions: problem solved?

Yes, and no. This sure is functional and tackles the shareability issue. But databases seem to be the biggest bottlenecks of web clusters these days. They are the hardest to scale, and so in high traffic environments you don't want to (ab)use them for session management if you don't have to. We have to tackle the 'performance' issue.

Database memory

Memory is about 30 times faster than disk storage. So storing our sessions in memory somehow, could deliver great performance.

MySQL query caching

One form of using database memory is the standard MySQL query caching. But MySQL query caching isn't very effective because it invalidates all cache related a table, if only one record in that table is changed.

Of course the session table is changed all the time, so the session cache is purged all the time, rendering it quite useless for our purposes.

Heap tables / Memory tables.

We're really closing in to our goal now. Storing the sessions in a heap/memory table (a table that lives in your database server's RAM) speeds up things greatly. Many demanding sites have opted for this solution.

In my eyes however, it's still not optimal. Because it still requires a lot of additional queries that your database server(s) shouldn't necessarily have to process.

One other possible solution is using Memcache. And you will find it's easier to setup and has a smaller footprint than most alternatives. For one thing, because you will not have to code custom session handler classes in PHP. Memcache session support comes native.

Sessions in Memcache

PHP allows you to overrule the default session handler in two ways:

1. session_set_save_handler(). By programming your own session handlers, allowing you to virtually use any type of storage, as long as you can read/write to it from PHP. This example uses a MySQL database. We could also use this method to connect to Memcache.
2. session.save_handler. By specifying one of the default handlers in the php.ini file using the session.save_handler & session.save_path directives.

Option 1 allows greater flexibiliy. And it even allows you to create a combined database/memcache mechanism. Resulting in a fallback-on-database in case memcache goes offline and loses all of it's sessions (effictively logging out all users).

Option 2 is very easy to implement, doesn't require changing your existing code, and is the one I'm going to show you today.
session.save_handler

Assuming that you have one webserver, and installed the Memache server on that same machine, the hostname will be 127.0.0.1. If you have it on a different server, you will know what IP to substitute it with.

session.save_handler = memcache
session.save_path = "tcp://127.0.0.1:11211"

Done! Huh? what just happened?

Well, because we enabled Memcache session handler support, all work is done for us. PHP will now know not to use the default files handler so save session files in /var/lib/php5 but uses memcache running at 127.0.0.1 instead.

Don't forget to restart your webserver to activate your changes to the php.ini

/etc/init.d/apache2 restart

Referance Site http://kevin.vanzonneveld.net/

Thanks And Regards

function ValidateCreditCardNumber($cc_num)
{
$pattern = "/^3[47]\d{13}$/";//American Express
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^([30|36|38]{2})([0-9]{12})$/";//Diner's Club
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^6011\d{12}$/";//Discover Card
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^5[12345]\d{14}$/";//Mastercard
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^4\d{12}(\d\d\d){0,1}$/";//Visa
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^30[012345]\d{11}$/";//Diners
if (preg_match($pattern,$cc_num))
{
return true;
}

$pattern = "/^3[68]\d{12}$/";//Diners #2
if (preg_match($pattern,$cc_num))
{
return true;
}

// Not valid
return false;
}

Hot Features

-> No Configuration - Set-up the database and let the magic begin
-> Extremely Simple - Just look at the name...It's Cake
-> Active, Friendly Community - Join us #cakephp on IRC. We'd love to help you get started
-> Flexible License - Distributed under the MIT License
-> Clean IP - Every line of code was written by the CakePHP development team
-> Best Practices - covering security, authentication, and session handling, among the many other features
-> OO - Whether you are a seasoned object-oriented programmer or a beginner, you'll feel comfortable.

Screenshots
http://cakephp.org/screencasts

Download CakePHP
http://cakephp.org/downloads

CodeIgniter is a powerful PHP framework with a very small footprint, built for PHP coders who need a simple and elegant toolkit to create full-featured web applications. If you're a developer who lives in the real world of shared hosting accounts and clients with deadlines, and if you're tired of ponderously large and thoroughly undocumented frameworks

CodeIgniter is right for you if...

> You want a framework with a small footprint.
> You are not interested in large-scale monolithic libraries like PEAR.
> You need exceptional performance.
> You need broad compatibility with standard hosting accounts that run a variety of PHP versions and configurations.
> You want a framework that requires nearly zero configuration.
> You want a framework that does not require you to use the command line.
> You want a framework that does not require you to adhere to restrictive coding rules.
> You do not want to be forced to learn a templating language (although a template parser is optionally available if you desire one).
> You eschew complexity, favoring simple solutions.
> You need clear, thorough documentation

You can download CodeIgniter From Here
http://codeigniter.com/downloads/

If you want to learn CodeIgniter Thank take a referance of following sites for your further help
http://codeigniter.com/tutorials/

For CodeIgniter Documentation
http://codeigniter.com/user_guide/

Projects Based on CodeIgniter
http://codeigniter.com/projects/

If you're building a SaaS (Software as a Service) startup you're in great company. Most software entrepreneurs today are taking this approach -- including me. Below are some simple insights that I've learned in the process of being in the trenches with my own startup.

Insights On SaaS Startups

1. You are financing your customers. Most SaaS businesses are subscription-based (there’s usually no big upfront payment). As a result, sales and marketing costs are front-loaded, but revenue comes in over time. This can create cash-flow issues. The higher your sales growth, the larger the gap in cash-flows. This is why fast-growing SaaS companies often raise large amounts of capital. My marketing software company is an example.

2. You’ve got operating costs. In the shrinkwrapped software business, you shipped disks/CDs/DVDs (or made the software available to download). There were very few infrastructure costs. To deliver software as a service, you need to invest in infrastructure — including people to keep things running. Services like Amazon’s EC2 help a lot (in terms of having flexible scalability), but it still doesn’t obviate the need to have people that will manage the infrastructure. For a startup, the people cost to manage the IT stuff can be significant (since the team is very small). So, even though hardware and infrastrucutre are cheap, managing it can take a significant percentage of the startup’s time.

3. It Pays To Know Your Funnel: One of the central drivers in the business will be understanding the shape of your marketing/sales funnel. What channels are driving prospects into your funnel? What’s the conversion rate of random web visitors to trial? Trial to purchase? Purchase to delighted customer? As a SaaS startup grows, a lot of leverage can be found by understanding the shape of the funnel and removing the “leaks” (i.e. where are you losing business)? For example, if a lot of people are signing up for the trial, but very few convert to paying customers, you should dig into what the early usage pattern is. Are people logging on at all? If so, where are they getting stuck? Remove the friction that is keeping customers from getting value and you’ll unlock some revenue. Do this at all stages of the funnel (focusing on the easy stuff first).

4. Install Knobs and Dials In The Business: One of the great things about the SaaS business is you have lots of aspects of the business you can tweak (examples include pricing, packaging/features and trial duration). It’s often tempting to tweak and optimize the business too early. In the early days, the key is to install the knobs and dials and build gauges to measure as much as you can (without driving yourself crazy). Get really good at efficient experimentation (i.e. I can turn this knob and see it have this effect). As with most experiments, don’t change too much at the same time (even though you think several different things will all have positive effects). The reason is simple: If you change more than one thing, you won’t really know what really happened. Unless you have lots of data points, simple tests are usually better.

5. Value the Visibility: One of the big benefits of SaaS businesses is that they often operate on a shorter feedback cycle. You’re dealing in days/weeks/months not in quarters/years/lifetimes. What this means is that when bad things start to happen (as many experienced during the start of the current economic downturn), you’ll notice it sooner. This is a very good thing. It’s like driving a fast car. Good breaks allow you to go faster (because you know you can slow down if conditions require). But, great visibility helps too — you can better see what’s happening around you, and what’s coming. The net result is that the risk of going faster is mitigated.

Running a SaaS startup is a lot of fun. There are so many more things under your control than the traditional shrink-wrapped business. Use this to your advantage. Keep your feedback cycles short, maniacally track the data and invest in continual (but cheap) experimentation. In the long term, these things will give you a huge advantage.

What have you learned while building your SaaS startup?