Clipping is a fundamental part of traditional GUI systems, and is also very handy in a canvas. Essentially, clipping limits the areas of the screen that drawing operations can write to.
In a traditional GUI environment, applications draw graphics by performing drawing operations on a graphics context, such as a window. In order to understand why clipping is so important, we need to understand how these graphics contexts are implemented. At first glance, it seems that using an off-screen pixmap would be the obvious method - applications would be free to write this off-screen pixmap as they saw fit, and the windowing system could simply copy regions from the pixmap to the physical display as they're updated or exposed. However, as more windows are opened, the memory taken by these off-screen pixmaps would soon become quite large, especially when you consider that the first GUI environments ran on machines with mere kilobytes of RAM. Even on todays machines, with hundreds of megabytes of RAM, this method is quite wasteful - if you open 3 full-screen applications on a 1280x1024 pixel, 32-bit desktop, the off-screen buffers would take up over 15Mb of RAM.
Instead of employing off-screen buffers, GUI environments let applications perform their drawing operations directly onto the display. However, this method would fail miserably if the windowing system didn't have some way of limiting the areas of the screen that any given application could write to. This is where clipping becomes so important. Each graphics context is assigned a clip region, which covers the area of the graphics context that is currently exposed (ie: not hidden behind other windows), and whenever a drawing operation is performed, it is "clipped" against the clip region, and only the portions of the objects drawn that lie within the clip region are actually drawn to the screen. Clip regions are almost always implemented using a list of rectangles.
In a canvas like Evas, clipping isn't of such vital importance as it is in a traditional GUI environment (unless, of course, you're building some kind of windowing system on top of the canvas). However, it still comes in very handy for many things, especially in Evas, where clipping has been given some great new features.
Probably the most obvious thing to use clipping for is to make objects appear and disappear. Clipping lets you stop an object from being shown whole - it's quite easy to display only the left half of an object for example. Once you've got that working, it's a simple matter to move your object and make it slide in out of nowhere, or change the clip region gradually so that it's slowly revealed. These basic "wipe" effects are the bread and butter of a presentation program, letting you slide text or images into view. Even better, once you get these effects working nicely with individual objects, it's only a small step to apply them to groups of objects, all the way up to complete pages filled with objects.
Evas clipping has a special trick hidden up it's sleeve though. Like most clipping implementations, Evas can only clip against rectangles. However, quite unlike other implementations where clipping is a boolean operation - pixels are either drawn or not - Evas clip regions can be coloured, or even made transparent! By changing the RGBA values of a clip rectangle from their default of opaque white (255,255,255,255), you can "tint" the clip region, make it transparent or even make it disappear completely. By clipping an object so that it's completely within the clip region, but with a clip region that's fully transparent, the object doesn't appear at all. By slowly changing the alpha value on the clip rectangle, the object gradually fades in, and thanks to Evas's OpenGL acceleration, it's all very smooth indeed.