Welcome To BlogerDesign

The ability to control the flow of your program, letting it make decisions on what code to execute, is valuable to the programmer. The if statement allows you to control if a program enters a section of code or not based on whether a given condition is true or false. One of the important functions of the if statement is that it allows the program to select an action based upon the user's input. For example, by using an if statement to check a user entered password, your program can decide whether a user is allowed access to the program.


Without a conditional statement such as the if statement, programs would run almost the exact same way every time. If statements allow the flow of the program to be changed, and so they allow algorithms and more interesting code.

Before discussing the actual structure of the if statement, let us examine the meaning of TRUE and FALSE in computer terminology. A true statement is one that evaluates to a nonzero number. A false statement evaluates to zero. When you perform comparison with the relational operators, the operator will return 1 if the comparison is true, or 0 if the comparison is false. For example, the check 0 == 2 evaluates to 0. The check 2 == 2 evaluates to a 1. If this confuses you, try to use a cout statement to output the result of those various comparisons (for example cout<< ( 2 == 1 );)

When programming, the aim of the program will often require the checking of one value stored by a variable against another value to determine whether one is larger, smaller, or equal to the other.

There are a number of operators that allow these checks.

Here are the relational operators, as they are known, along with examples:

>     greater than              5 > 4 is TRUE
<     less than                 4 < 5 is TRUE
>=    greater than or equal     4 >= 4 is TRUE
<=    less than or equal        3 <= 4 is TRUE
==    equal to                  5 == 5 is TRUE
!=    not equal to              5 != 4 is TRUE

if ( TRUE )
 Execute the next statement

if ( TRUE ) {
 Execute all statements inside the braces
}

if ( TRUE ) {
 // Execute these statements if TRUE
}
else {
 // Execute these statements if FALSE
}

#include  

using namespace std;
  
int main()                            // Most important part of the program!
{
 int age;                            // Need a variable...

 cout<<"Please input your age: ";    // Asks for age
 cin>> age;                          // The input is put in age
 cin.ignore();                       // Throw away enter
 if ( age < 100 ) {                  // If the age is less than 100
    cout<<"You are pretty young!\n"; // Just to show you it works...
 }
 else if ( age == 100 ) {            // I use else just to show an example
    cout<<"You are old\n";           // Just to show you it works...
 }
 else {
   cout<<"You are really old\n";     // Executed if no other statement is
 }
 cin.get();
}

A. !( 1 || 0 )         ANSWER: 0 
B. !( 1 || 1 && 0 )    ANSWER: 0 (AND is evaluated before OR)
C. !( ( 1 || 0 ) && 0 )  ANSWER: 1 (Parenthesis are useful)

Getting set up

#include 



using namespace std;



int main()

{

cout<<"HEY, you, I'm alive! Oh, and Hello World!\n";  cin.get(); } 

int x;

int a, b, c, d;

char letter;

float the_float;

#include 



using namespace std;



int main()

{

int thisisanumber;



cout<<"Please enter a number: ";  cin>> thisisanumber;

cin.ignore();

cout<<"You entered: "<<>

a = 4 * 6; // (Note use of comments and of semicolon) a is 24

a = a + 5; // a equals the original value of a with five added to it

a == 5     // Does NOT assign five to a. Rather, it checks to see if a equals 5.

a <> 5  // Checks to see if a is greater than five

a == 5 // Checks to see if a equals five, for good measure

This tutorial uses Photoshop CS2 however it is also suitable for PSCS and PS7 users.

Using a basic circle, this tutorial will demonstrate some of the effects that the Layer Style options is used to create.

This tutorial is large(36 pages) and is available in PDF Format. DOWNLOAD BY CLICKING HERE

You can download Adobe Acrobat Reader for free if required from www.adobe.com




ReadMore...

This tutorial will help you create a basic round glass ornament, just in time for the holidays.

1. Begin by creating a new image in the dimensions you want. Be sure to click Raster Background and Transparent.


2. Activate the Ellipse Tool (Q) and choose a background color you want your ornament to be. Draw a vector circle and center it vertically on your layout using the Object Selection Tool (O).

3. Duplicate the vector circle onto a new layer by right-clicking on the layer containing the circle and choosing Duplicate.

4. Expand the layer containing the duplicated circle by clicking the plus sign located on the left side of the layer.

5. You should now see the sub-layer containing the vector circle.

6. Double-click the sub-layer containing the duplicated circle (be sure you click the sub-layer and not the Vector layer). Once you double-click the sub-layer containing the circle, you should see the following window:

7. Click the fill block on the bottom and choose the Gradient tab. Choose the black-white gradient. Enter 180 for the Angle, Repeats = 0, check Invert, Linear style. Click OK.

8. The duplicated circle should now have changed to the black-white gradient.

9. Change the blend mode for the black-white gradient to Hard Light (try experimenting with different blend modes for various looks).

10. Your ornament should now look like this:

11. Let’s give the ornament a shinier glass look. Create a selection by activating the Object Selection tool (O) and Ctrl+Shift+B. Your circle should now have marching ants surrounding it.

12. Create a new Raster layer (Layers > New Raster Layer > OK).
13. Expand the selection by clicking Selections > Modify > Expand. Expand the selection by 2 pixels. Click OK. The marching ants should now be on the outside of your circle.

14. Create a shiny glass look by clicking on Effects > Artistic Effects > Balls and Bubbles. On the Shape tab, choose the Single ball or bubble and check Maximum possible size.

15. Click the Illumination tab and fill in with the following settings:

16. Click OK. Change the blend mode for this layer to Overlay. You should now have a shinier surface on your ornament.

17. Click on the layer containing your original circle. Then using the Magic Wand tool, click on the outside of the circle, selecting the area surrounding the circle.

18. Click the layer containing the glassy bubble and hit the delete key on your keyboard. Merge visible layers (Layers > Merge > Merge Visible).

19. At this point, you could save the image as a PNG file and use it as is. Or, you can create the metal hanging cap.
20. Choose the Rectangle tool (G). For the background color, choose the Metal steel gradient, linear style, angle = 90, check Invert. Click OK.

21. Draw a small rectangle at the top of the ornament and center it vertically using the Object Selection tool (O).

22. Convert the rectangle into a raster (Layers > Convert to Raster Layer). Apply an inner bevel with the following settings and click OK.

23. Your ornament should now have a metallic cap on top.

24. Create a hanging loop by using the Ellipse tool (Q) and drawing a thin ellipse using the same Metal steel gradient as your stroke color. Move the layer containing the loop below the cap so that it sits behind the cap.

25. Apply an inner bevel to the loop and click OK.

26. Merge all visible layers and save as a PNG file. Your ornament is now ready for “hanging!”

Most, if not all of the permanent topics of conversation on XML-DEV revolve around two camps of people: one which thinks aspect N of XML is a wart, the other which thinks N is an elegance. These threads never end because, in part, there is no final or absolute context within which XML is meant to be used. Whether you think of N as a wart or an elegance is context dependent and interest relative. It depends almost entirely on who you are and what you want and need XML to do. In other words, all opinions about XML are equal. Except that that's not really true. All opinions about XML are equal, except some are more equal than others. Among the more equal opinions are ones held by the people who drafted the XML specification.

Among that select group of people, as far as XML-DEV is concerned, Tim Bray stands out, if for no other reason than he has consistently contributed to the conversational life of the community. So when Bray, over the course of a few weeks, leads an effort to relocate XML-DEV and publishes a widely-read essay in which he seems to question XML itself, it's time to take a closer look.

Is XML Too Hard?

In a recent weblog entry, one which has been picked up by Slashdot, Bray asks whether XML has become too hard for programmers. Faced with writing code "to process arbitrary incoming XML", Bray confesses that the experience was "irritating, time-consuming, and error-prone" -- quite an admission from someone as instrumental in the creation of XML as Bray. The point here -- before someone accuses me of hero worship -- isn't that Tim Bray is always right. He isn't. The point is that when Tim Bray starts talking about XML's problems, it makes sense for the XML development community to pay some attention.

So what's Bray's beef? It isn't, he says, that XML parsers are so hard to write. If they were, Bray says, there wouldn't be so many of them (which doesn't strictly follow, logically speaking, but it may be a useful heuristic). The problem is that XML parsers are so hard to use. (I wrote about a similar issue -- the difficulty of SAX or DOM for some kinds of programmer -- in one of my first XML-Deviant columns, "DOM and SAX Are Dead, Long Live DOM and SAX".)

Specifically, Bray offers the standard lament: DOM processing is inefficient, SAX processing is awkward.

If I use any of the perl+XML machinery, it wants me either to let it read the whole thing and build a structure in memory, or go to a callback interface.

Since we're typically reading very large datasets, and typically looking at the vast majority of it, preloading it into a data structure would be impractical not to say stupid. Thus we'd be forced to use parser callbacks of one kind or another, which is sufficiently non-idiomatic and awkward that I'd rather just live in regexp-land.

What? Bray "parses" XML with regular expressions? Apparently so, at least for some data munging tasks at Antartica, his data-mapping company. He's even written some code to make regexing XML more reliable:

Now here's the dirty secret; most of it is machine-generated XML, and in most cases, I use the perl regexp engine to read and process it. I've even gone to the length of writing a prefilter to glue together tags that got split across multiple lines, just so I could do the regexp trick.

Bray's preferred way of parsing XML for some kinds of project, like his weblog software, would be to have a kind of regular expression syntax which "abstracts away all the XML syntax weirdness, ignoring line-breaks, attribute orders, choice of quotemarkers and so on". While his example is Perl, it's not Perl-specific. "I want to have my idiomatic regexp cake," Bray says, "and eat my well-formed XML goodness too".

XML-DEV reacted to Bray's essay in a relatively muted way, perhaps because it was busy discussing his proposal to relocate XML-DEV? Simon St. Laurent suggested that Bray's lament reflects the different expectations and assumptions which follow from the markup and programming worlds. Dare Obasanjo took Bray to task, suggesting that what Bray is asking for is already available in Java and C# (and, as Daniel Veillard pointed out, in libxml2 and so in any language, like Python, which has libxml2 bindings; likewise, Sean McGrath reminded XML-DEV that this processing style is available in his Pyxie Python toolkit), namely, a "pull-based XML parser". Obasanjo went even further:

Tim's post indicates that he is quite disconnected from the world of modern XML programming practices, I especially like his "The notion that there is an 'XML data model' is silly and unsupported by real-world evidence" quote. I'm interested in what criteria he used to determine that the thousands of users of XPath, XSLT and the DOM don't count as "real-world evidence".

Micah Dubinko takes a different approach, noting that part of the difficulty of parsing some kinds of XML is handling ID values. One of the changes that might be made to XML to make it less painful to process is to fix the ID issue. As Dubinko puts it,

Anyone who's worked much with XML knows that IDs are painful, since they require DTD or schema processing. A recurring proposal has been circulating for a self-describing xml:id attribute that confers ID-ness without need of DTD or schema. With that in place, even XML delivered inside the DTD-free zone of a SOAP envelope could be handled with code not significantly more complex than Adam's example, and without the dependencies and hassle of a schema language.

Two very substantial posts, by Robin Berjon and Barrie Slaymaker, responded specifically to Perl-specific part of Bray's comments. Berjon makes the obvious point:

A couple years after you think you and your friends have convinced all the Perl community to not use regex based parsers on XML you get Tim Bray to hit you on the back of the head with one. I guess it's fair though, because he makes sense.

Which is especially telling (and rather funny) if you remember classics which asked whether "wily Perl hackers" could handle XML. Berjon's primary suggestion is to commend Barrie Slaymaker's XML::Filter::Dispatcher module:

It is basically a collection of utilities wrapped inside rules that match an XML stream using an XPath-like language (which is probably preferable to raw regexen, and has in fact similar functionality). They will do things such as maintain state for you or assist you doing so, in a way that is much simpler than SAX. You need to learn a new little language, but if you know XPath it's a five minute job. I don't think the docs do it full justice.

This sounds an awful lot like the kind of thing Bray is asking for.

If you're a Perl-XML hacker, you could do far worse than paying very close attention to Barrie Slaymaker's post about XML::Filter::Dispatcher and XML::Essex. I can only quote some of its highpoints here, but it definitely deserves a careful reading.

XML::Essex is "a prototype of a pull mode scripting environment ... that is also event driven so it allows while ( pull ) style processing without reading the entire document (via Perl's newish ithreads)". That is, it is meant to allow Perl programmers to deal with XML files in much the same way as they'd deal with other text files. It is, Slaymaker says, "an attempt to build a toolkit that allows processing XML files in the same way that you would process a text file, modulo the fact that text files are treated as flat sequences of records in Perl while XML is hierarchical". Again, if you're interested in Bray's lament specifically for its Perl-angle, you should take a careful look at Barrie Slaymaker's recent work.

The previous three editions of XML-Deviant reviewed Web Forms 2.0, or WF2, a Member Submission made to the W3C by a loose group called The Web Hypertext Application Technology Working Group, often abbreviated WHATWG.

This week, continuing a web application theme leading up to the XTech Conference, XML-Deviant takes a look at the issues involving the broader internet application community. The first stop is the W3C Team Comment on WF2. Normally, the W3C won't acknowledge a Member Submission if it falls under the domain of an existing Working Group--in that case the submission should be made directly to the Working Group in question. As the lead-in quote shows, though, the submission was acknowledged. Additionally, the Team Comments offered a few specific suggestions:

1. Consider separating the backwards-compatible features from the features that require users to update their user agents or rely on scripting.

2. Provide comprehensive use cases and requirements for each enhancement.

3. Demonstrate how Web Forms 2.0 maps to XForms (and the reverse), giving more attention to the features in Web Forms 2.0 that are similar to XForms.

4. Participate in the development of XHTML and XForms specifications (note that Opera has been a member of the HTML Working Group for 4 years.)

5. Build a community, with cooperation from the W3C, to discuss, develop and promote adoption of improved forms on the Web.

While a good starting point, these comments by nature are addressed only to the WHATWG. That group didn't form in a vacuum; it formed as a response to pre-existing conditions in the community. Accordingly, any one-sided plan for change is simply doomed. On the other hand, the group is specifically asking for comments, so nobody should be surprised if some of the comments point to WF2. Even then, however, it's worth thinking about the wider implications of suggested changes. So with that, the remainder of this column offers some specific points for discussion and alignment within the community.

Point: Where the state goes. Earlier, this column's review of WF2 introduced FormAttic, a simple framework for client-side forms validation, in order to highlight an important discussion about the design of forms languages: namely, that new features require new information to be specified somewhere in a target document. FormAttic placed all the additional information in one place, in the document head. WF2 places the information across many elements throughout the document. Lots of ink could be spilled over discussions about which way is better.

But the interesting thing is that the existing XForms specification already caters to both ways. A fully specified XForms Model appears in one place in the document head, but for cases when that is too heavyweight, a technique called (with tongue firmly in cheek) lazy author style allows the scattered form control elements themselves to contain all the needed information. XForms and WF2 are more closely related than has been credited. Without serious changes to either specification, they could be even more so.

Point: Common foundation. The XForms Model, which is in turn based on the XPath data model and the XML Infoset, provides a common dictionary of terms for specifications and implementers to use. Note that this doesn't automatically imply the need to use XPath itself, only the data model, which in practical terms only means writing specifications a certain way and using certain terminology. The result will be that developers familiar with WF2 will have an immediate familiarity with XForms, and vice versa. Additional areas of overlap, especially around serialization and submission handling, can also be more easily identified this way. Many of the improvements found in areas of WF2 fit in with current work on the XForms 1.1 Working Draft.

Point: Common framework. WF2 is defined in terms of Modularization of XHTML, a framework for mixing and matching different parts of XML vocabularies. Without using a separate heavyweight specification, XForms uses another layer on top of XHTML Modularization to mix and match form-specific components. The result is diagrams like this puzzle piece, which as far back as 2001 already showed XHTML as an option for user interface. It should be possible to use the updated UI controls defined in WF2 with the rest of the XForms core, not to mention other kinds of combinations.

Point: Discard the WF2 repeat model in favor of the existing one. Previously I wrote about the WF2 repeat model, which has some shortcomings besides being duplicative. The WF2 submission itself acknowledges: "There is some debate about whether the repetition model section should be included or not."

Point: Acknowledge the need for a transition. This might be the hardest point for both respective sides to come to terms with, yet in some respects it's the easiest since it involves only editing one's viewpoint as opposed to editing a specification or working code. Perhaps Gerald Weinberg's Second Law of Consulting sums it up best: "No matter how it looks at first, it's always a people problem."

The huge quantity of existing code, markup, practice, and W3C Recommendations speaks for itself. So does the demand for more advanced solutions. There are valid 'before' and 'after' states in this discussion, which points to the need for a bridge between the two.

Another area of common ground comes from scripting, which any kind of client-side transition plan will involve. Work like FormFaces or DENG feel eerily similar to the kind of preliminary work going into WF2, such as that from the remarkable Dean Edwards. It doesn't take a big imaginative leap to visualize these kinds of projects coming together.

Point: Unify the community. One community working out these issues will be better than two or n, even though compromises will need to happen. The W3C might often get criticized for producing cumbersome "design-by-committee" specifications, but it still holds a leadership role in web applications standards space. If that weren't the case, the WHATWG wouldn't have made a Member Submission out of WF2 in the first place. The proprietary forms market is fractious enough. Let's not have the standards-based forms sector be the same way.

Conclusion

In preparing this article, I was stuck by how many areas of common ground exist between XForms and WF2, much more so than reading either specification alone would indicate. Still, not enough work has gone into identifying and expanding these areas. This is where XML-Deviant readers can help. In the comments section below or in your weblog, post some constructive comments, markup samples, or other ideas on how to move this community forward. A later issue of XML-Deviant will report on the progress.

Births, Deaths, and Marriages

OpenReader announcement: Open-standards eBook Format and Reading System

New discussion groups for Open-standards eBook Format development as well as a reference implementation.

Documents and Data

Uche Ogbuji's latest article, Principles of XML Design: When the Order of XML Elements Matters, which spawned a useful thread on xml-dev this week.

How to implement Google Maps (and other Ajax patterns) with XForms.

For more information on Gerald Weinberg's Laws of Consulting, see The Secrets of Consulting.

Chapter 5: Managing Spam

Most people consider spam to be any unsolicited e-mail that they might receive that attempts to sell them something¹. It can also include e-mails with chain letters, political statements, or messages from people who just need some attention. Although some people might think that the e-mail version of spam was named after the food SPAM,² because both are considered tasteless and a waste of time (at least to some people), nothing could be further from the truth. (As an aside, SPAM is served during breakfast at McDonald's in Hawaii, where it has the highest consumption rate per capita in the United States.²)

The origin of the use of the term spam for unsolicited e-mail appears to come from the Monty Python skit about SPAM³. The Vikings in the skit annoyed a waitress by repeating the word spam over and over again. In much the same way, unsolicited e-mail can elicit the feeling of annoyance in people who receive it. The way in which the Monty Python skit was connected to the act of unsolicited communication came from the Multi-User Dungeon (MUD)⁴ community. One member of that community, after becoming upset with his treatment by some of the other members, created a macro to repeat the word spam several times in the MUD environment during a sacred hatching. Later on, MUD members would refer to the event as the time they got "spammed."

SoftQuad's XMetaL takes a good first cut at a workable interface for writers (as opposed to programmers or data-entry clerks) working with structured text. It's more than an "XML editor", a label that might be applied to products like XED, XML Spy, and Vervet that provide basic data and metadata editing functions with explicit control over XML markup. XMetaL falls into new category that you might call XML or structured word processing along with Arbortext's Adept Editor and Word Perfect SGML.

	XMetaL is available for Windows platforms at $495 per user.
Find out more about XMetaL in our product guide. Have you used XMetaL? Share your opinion with us.

XMetaL is relatively inexpensive, relatively easy to set up, and relatively easy to use as a word processing tool for writers who need to produce valid documents according to established formulas. The target market for SoftQuad's XMetaL includes the traditional market for SGML editors, tech doc and integrated vertical applications. However, it should make it easier to deploy a structured editor to an off-site writer who may have little or no training in XML. Another target is editorial groups in which Microsoft Word is producing copy that will eventually be converted to XML and will need to stand up to XML validation. This includes Web sites such as the Wall Street Journal Interactive Edition, where writers use a customized version of Word to produce RTF files that are converted to XML, validated, and then fed into the production system or sent back to the author for revision.

So the goal for XMetaL was to be a word processing tool for structured documents that is as easy to use as Word when customized for an individual DTD. SoftQuad, Adobe and Arbortext all have experience customizing an interface for a specific environment. Most of the successful, SGML-authoring projects utilize a dedicated editor that conforms to its document type and work requirements. In XMetaL, SoftQuad has tried to produce a tool that can be set up in two weeks by anyone with general scripting skills instead of two months by an XML consultant.

Eric van der Vlist is the author of XML Schema.Microsoft Office Embraces XMLFor many participants, the most memorable event of XML 2002 will be JeanPaoli’s presentation of Office 11, which promises to deliver easier access toXML for hundreds of millions of workstations.Those of us who had to connect a Windows PC to the Internet in theearly 90s remember the difficulty of choosing and installing TCP/IP andthe browser software necessary to access and browse the Web. At that time,Microsoft didn’t be

Microsoft Office Embraces XML

For many participants, the most memorable event of XML 2002 will be Jean Paoli's presentation of Office 11, which promises to deliver easier access to XML for hundreds of millions of workstations.

Those of us who had to connect a Windows PC to the Internet in the early 90s remember the difficulty of choosing and installing TCP/IP and the browser software necessary to access and browse the Web. At that time, Microsoft didn't believe in the future of the Internet, TCP/IP wasn't natively supported by Windows, Internet Explorer was a vague project in a laboratory, and many companies had developed market segments left uncovered by Microsoft.

This era was wiped away by a U-turn, which I have always considered a miracle from a company of the size of Microsoft. Within months, it bundled a TCP/IP stack and Internet Explorer with Windows. Internet features have been rapidly added to Office. Users applauded. Companies positioned on these segments either changed their strategy or disappeared, which is believed to have decreased the overall possibility for innovation in some domains.

The impression given in the presentation by Jean Paoli, co-editor of the XML 1.0 recommendation and pilot of the "XMLization" of Office, is that Microsoft is doing with XML what it did with the Internet.

XML was already well-supported by Microsoft BackOffice products from Biztalk to CMS through XML Server, but a key piece was missing: tools to let users manipulate XML on their workstations. The issue of editing XML documents is still as difficult as the connection to the Internet in the early 90s: technically there is a solution and many XML editors are available, but the financial, institutional, and human impact of deploying these tools on a large scale is considered a major obstacle by many organizations.

"XML for the masses" is the target of Office 11, and Paoli's presentation suggested that Microsoft will likely meet the target. Without major innovations (except maybe the linking of XML documents to Excel spreadsheets using XPointer references), Office 11 appears to xmlizing Office using largely standard technologies and enabling the manipulation of arbitrary XML documents using customer-chosen schemas:

• Word 11 has been transformed into a XML editor and can be used to edit any XML document, assuming you can write a W3C XML Schema for it. The presentation can be configured and validation is done on the fly like spell-checking. A standard XML format has also been added for ordinary Word documents.

• Excel XP already exports documents as XML. Excel 11 adds support for arbitrary documents and, maybe more interesting, the possibility to import values from XML documents as with a DBMS. The selection of the values to import is done through drag and drop; the links are stored as XPointer expressions.

• XDocs is a new application that defines and uses document-oriented forms, more similar to the forms in Lotus Notes than those on the Web. User input may be stored together with the form in a XML document using a schema defined by Microsoft or in external XML documents with arbitrary schemas.

• Access 11 can export its content as XML using a user-supplied schema.

• Visio has its own XML format and can also read arbitrary XML documents and display their content in its drawings. Visio is the first Microsoft application to support SVG; it can load and save SVG documents.

• Front Page 11 includes a WYSIWYG XSLT editor to define XSLT transformations through drag and drop.

Powerpoint is the only piece without an XML update because, according to Paoli, of the lack of time. For the rest of the applications, XML can be used as a channel of information between front and back office applications, but also between front office applications, creating a lot of new possibilities for users, consultants, and integrators who will be able to exploit them.

"XML for the masses", the target of Microsoft, is not the same as the target of the XML editors we know today, and it will probably take some time for Word to become a serious challenger. Nevertheless, many will be tempted to use a tool which is installed on so many workstations. The effect of this may well be to reduce the opportunity for competition, innovation, and value-add in the existing XML editor world, yet also to create new market segments.

Often criticized for its "embrace and extend" strategy, Microsoft has finally decided to continue to play the game with XML, even though the extensibility of XML opens new and unpredictable possibilities. But Microsoft needs to control all the major market segments in fear that XML might give to the masses the possibility of emancipation from its domination.

While the deployment of XML on millions of workstations is good news in the short term, it will certainly modify the landscape of desktop XML. The shape of this new landscape, and the longer-term consequences, are difficult to foresee.

OpenOffice: the XML format for the masses

Jean Paoli for Microsoft and Daniel Vogelheim for OpenOffice both chose the same title "XML for the masses" for their presentations, a commonality which hides two very different approaches from the editors of two competing office productivity suites.

The strategy of OpenOffice is to focus on the XML format natively used to store the documents. In his presentation Daniel Vogelheim gave an overview of the OpenOffice XML format and justified the design decisions taken to meet the following requirements:

• use existing standards -- don't reinvent the wheel
• "transformability" -- the format must be usable outside of the office application
• first class XML -- all structured content must be accessible through XML structures

The result is a complex format (over 450 elements and more than 1600 attributes), with a good amount of redundancy, but easily readable and easily transformable. To some extent it's an XML format for users more than for developers.

This format has been given as an input to the OpenOffice OASIS Technical Committee, which aims to create an "open, XML-based file format specification for office applications."

For Microsoft, the strategy appears to be to bring XML tools to each desktop, and leave each user free to choose appropriate schemas, rather than promoting an XML office format which will be specific to Microsoft, and for which a licensing model is still unclear.

If the target of Microsoft Office 11 is to deliver XML tools to the masses, the target of OpenOffice is to become the XML office format for the masses.

ISO DSDL on the move

Document Schema Definition Languages (DSDL) is a project of the ISO/IEC JTC 1/SC34/WG1 working group chaired by Charles Goldfarb. After the meetings held in Baltimore during XML 2002, this working group has published a set of recommendations which have been all approved:

• Relax NG specification is published as "ISO/IEC FDIS 19757-2, DSDL Part 2: Regular-grammar-based validation - RELAX-NG". This stage is similar to a W3C Proposed Recommendation and the specification should be approved as a final ISO standard within a period of two months.
• Part 0 (Overview) is published as a CD (i.e. a first Working Draft).
• Part 4 (Selection of Validation Candidates) is published as a CD. Proposed by Murata Makoto, this part defines a language for selecting XML islands which can be validated through different schemas. The document is derived from prior work known as "Relax Namespaces".

DSDL has also advanced the definition of the remaining parts, and several of them should lead to publications during the next meeting at XML Europe 2003. Among the decisions taken on part 1 (Interoperability Framework), are as follows:

• The Interoperability Framework should allow one to use existing languages without modifications and thus to manipulate full documents instead of fragments. This approach will follow the principles of the Schemachine proposal by Rick Jelliffe, but it will be made more declarative and less procedural.

• My own XVIF proposal is considered interesting and an extension mechanism will be added to Relax NG to support it in a more standard way.

Further reading on DSDL and XVIF:

• Updated release of XVIF
• RELAX NG becomes ISO draft standard

A burst of schemas

For different reasons many XML 2002 presentations proposed the use of multiple validations and transformations for advanced needs, rather than using a single schema considered too complex or even impossible to write and maintain.

Perhaps influenced by my editorship of "DSDL part 1 -- Interoperability Framework", I observed the justification of such a framework returning as a leitmotif in many presentations:

• Liora Alschuler, in her presentation " Layered Constraints: The Proposal for HL7 Healthcare Templates," explained why, in face of the huge diversity of the practices for health reports, HL7 has chosen to associate a very lax generic schema together with templates, i.e. specific constraints which formalize the different local usages of the common schema.

• Walter Hamscher in " XBRL: XML, XLink, and the Revolution in Corporate Reporting" explained why, for similar reasons, XBRL has chosen to express most of the structure of its reports as extended XLink link bases. Since these links cannot be validated using W3C XML Schema, to be complete the validation of XBRL documents requires a validation by the application layer that could also be performed using a language such as Schematron.

• Gabe Beged-Dov in " Normalized Metadata Format: RDF Meets XML Schema" showed how RDF documents may be "normalized" to facilitate their validation through W3C XML Schema.

• Eric Freese in " Using DAML+OIL as a Constraint Language for Topic Maps" proposed a modification of the syntax of XTM Topic Maps documents (which could be done by a XSLT transformation) that enables their validation using RDF applications such as OWL or DAML+OIL.

• Bob DuCharme in " Maintaining Schemas for Pipelined Stages" has shown that the customization of generic W3C XML Schema or Relax NG schemas with added metadata could be performed through XSLT transformations more easily than using the derivation techniques of these languages.

There are few commonalities between these presentations, but all of them show how, confronted with the issue of a complex validation in very different domains, projects have chosen to split the validation of their documents into different, easier to write, elementary steps.

That's also the approach taken by DSDL, the reason why it will be a multi-part standard, and the justification of its part 1, Interoperability Framework, which will define a language to describe the choreography of the elementary steps needed to perform a complex validation.

Impossible, Except For James Clark

The fact that the translation of Relax NG schemas into W3C XML Schema was considered impossible wasn't a good enough reason for James Clark, who presented at XML 2002 the latest progress of Trang, his multi-format schema converter.

While it is not possible to transform any Relax NG schema into W3C XML Schema, Clark considered that in most of the cases a converter smart enough to figure out the intent of the author should be able to write a readable W3C XML schema. This would be as good as a schema written directly using W3C XML Schema and a good approximation of the Relax NG original schema. Clark's presentation showed that this goal is not far from being met.

To achieve his aim, Clark had to make abstraction of the syntaxes beyond the two schema languages and to define a data model which is intermediate between Relax NG and W3C XML Schema. The translation is done in two steps: the Relax NG schema is parsed and feeds the data model, and criteria are applied to this data model to decide which W3C XML Schema should be used to get the best results both in term of approximation and readability.

The results from the examples presented by Clark is outstanding, and he has acknowledged that writing Trang was much more complex than writing a Relax NG implementation.

There appears to be quite a demand behind this tool too, as many developers are attracted by the simplicity of Relax NG, while they need to publish WXS schemas to be used by an increasing number of tools (Office 11 will require WXS schemas). Clark's answer to this request is simple: "don't bother with W3C XML Schema, write your schemas with Relax NG and use Trang to convert them."

Literate Programming in XML

Norm Walsh presented at XML 2002 his implementation ( XWEB) of Literate Programming in XML, available as part of his DocBook stylesheets, which enables the extraction of both documentation and code from common documents.

Introduced in 1984 by the father of TeX, Donald Knuth, Literate Programming is a software development methodology that focuses on documentation by embedding the source code in the documentation. Michael Sperberg-McQueen has proposed its application to SGML back in 1993.

Its principle is to document code fragments (classes, methods, variables or XSLT templates are examples of code fragments), to include the code fragments in their documentation, and to link them into a "web". This web can then be transformed to produce, on one hand, readable documentation in any format and, on the other, the source code.

The XML implementation presented by Walsh is thus based on mature concepts, and its current version was published in March 2002. It supports not only embedding traditional languages such as Perl or Java but also XML languages such as XSLT, schemas, or any other XML "code". Support for languages such as Python would probably require some adaptation since XWEB doesn't appear to care much about indentation.

Literate Programming isn't incompatible with other methodologies such as Extreme Programming; among the extensions which seem most interesting, one could probably easily add the definition of the unit tests within the documentation of the code fragments.

Purists will also note that, following tradition, XWEB is implemented through XWEB documents, a minimal XSLT transformation being provided to "bootstrap" these documents into usable pieces of code, which consist mostly of XSLT transformations.

Elliotte Rusty Harold's new XML Object Model ( XOM) is a simple, tree-based API for XML, written in Java. XOM attempts to build on good ideas from other Java XML APIs -- SAX, DOM, and JDOM -- and to leave behind some of their frustrations. The result is a high-level open-source API that is easy to learn and use, assuming that you are already familiar with Java and XML.

Unlike SAX, XOM is written with classes instead of interfaces, making it more straightforward to use. With SAX you must first implement interfaces before you can get it to work. This work is eased somewhat by helper classes like DefaultHandler; but overall, interfaces make programming in SAX somewhat more complex, even though they also make SAX uniform and flexible. XOM's classes provide some flexibility by offering a number of check methods that may be overridden in subclasses.

M does not stand by itself. It depends on an underlying SAX parser, such as a recent version of Xerces, to handle well-formedness checking and validation. XOM provides a simple interface to a parser, in effect hiding code without much of a performance hit.

I like XOM for the same reasons I like RELAX NG: you can pick it up in a snap if you already have a reasonable familiarity with Java idioms. And, like RELAX NG, the more I use XOM, the more I like it. It is well considered and doesn't try to do everything or please everybody. For more information on XOM's relationship to other XML APIs, you can read a presentation that Elliotte gave at the New York XML SIG meeting on 17 September 2002.

On the other hand, if you are underwhelmed by XOM's simplicity, you can go back to your favorite old API or mix APIs, taking what you like from each. But if simplicity, openness, and ready availability are keys to the wide adoption of software, XOM has little problem measuring up to that standard.

Bear in mind that XOM is still a work in progress. This article only walks through part of the interface, but it should give you enough example code to get you well on your way.

The sample programs and documents discussed in this article are available for download in ZIP archive form. And you can read the Javadocs for nu.xom.* online.

To run the examples, your system must have:

• Java version 1.2 or later. I have tested the examples with Java version 1.4 in a Windows 2000 environment.
• Xerces version 2.1 or later. I have tested appropriate examples with Xerces 2.2.
• The latest XOM JAR file. The latest version at this writing is xom-1.0d8.jar.

Parsing a Document with XOM

Create a working directory and unzip the program archive there. Copy the Xerces and XOM JAR files there, too. The program Wf.java checks a document for XML 1.0 well-formedness:

import java.io.IOException;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.ParseException;

public class Wf {

   public static void main(String[] args)
       throws IOException, ParseException {

       Builder builder = new Builder();
       Document doc = builder.build(args[0]);
       System.out.println(doc.toXML());

   }

}

To compile the program, type the command:

javac -classpath xom.jar Wf.java

Use colons to separate the JAR files if you are working on a UNIX platform. The command line explicitly places the Xerces and XOM JARs on the classpath, making it evident what is going on. I've renamed the latest XOM JAR, from "xom-1.0d8.jar" to "xom.jar" for simplicity. After you successfully compile the program, you can run it by typing

java -cp .;xercesImpl.jar;xom.jar Wf file:///wrk/inst.xml

The fully qualified file path for the argument to Wf may work more reliably than the filename alone, depending on your platform. If the program runs successfully and inst.xml proves to be well-formed (it should), the program will echo the input and add an XML declaration:

Wf.java imports three XOM classes: nu.xom.Builder, nu.xom.Document, and nu.xom.ParseException. Builder creates a document object by reading an XML document. It can pick up the document from a file (as shown), a URL, or an input stream. Builder's build() method actually reads the document. Document represents the document, including its document element and prolog. XML output is delivered by Document's toXML() method, with help from System.out.println(). The entire document is echoed using this mechanism, with an XML declaration thrown in as part of the parcel.

The IOException and ParseException classes are checked and therefore required. They are declared the easy way in Wf.java, that is, with a throws keyword. Wf2.java uses a try/catch statement instead.

Validating a Document with XOM

With just a few changes, you can add validation support. In the following program (Val.java), notice three additions highlighted in bold.

import java.io.IOException;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.ParseException;
import nu.xom.ValidityException;

public class Val {

   public static void main(String[] args)
       throws IOException, ParseException, ValidityException {

       Builder builder = new Builder(true);
       Document doc = builder.build(args[0]);
       System.out.println(doc.toXML());

   }

}

When you add true as an argument to the Builder constructor, you create a document object that is set for validation. When this is the case, you also need to check for validity exceptions by importing nu.xom.ValidityException and declaring it on main() or in a try/catch statement (see Val2.java).

Compile this program and then run it against instant.xml with this command:

java -cp .;xercesImpl.jar;xom.jar Val file:///wrk/instant.xml

The document is validated against the DTD asserted in the document type declaration, intant.dtd:

              day NMTOKEN #REQUIRED
              year NMTOKEN #REQUIRED>

              minute NMTOKEN #REQUIRED
              second NMTOKEN #REQUIRED
              zone NMTOKEN #REQUIRED>

When running Val.class, success is indicated when the program echoes its input:

Adding Elements and Attributes

Suppose you picked up a copy of inst.xml and you wanted to add an element with an attribute to it? The program AddUtc.java does just that (note changes in bold):

import java.io.IOException;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.ParseException;

public class AddUtc {

   public static void main(String[] args)
       throws IOException, ParseException {

       Builder builder = new Builder();
       Document doc = builder.build("inst.xml");
       Element root = doc.getRootElement();
       Element utc = new Element("utc");
       Attribute att = new Attribute("offset", "-08:00");
       utc.addAttribute(att);
       root.insertChild(0, "\n ");
       root.insertChild(1, utc);
       root.removeChild(4);
       root.removeChild(4);
       System.out.println(doc.toXML());

   }

}

This program imports the Element and Attribute classes from the nu.xom package. Instead of using a command line argument to pick up a file to parse, it is hardcoded to grab inst.xml. It uses the getRootElement() method from the Document class to determine the document element of inst.xml.

A utc element is created along with an offset attribute using the Attribute class. The addAttribute() method from Element adds this attribute to the utc element. Calling insertChild() inserts a text child at position 0, immediately after the root element time. Following that, insertChild() places the utc element at position 1.

The code also removes the time element (and preceding whitespace) by using the removeChild() method twice with the same argument value. (The argument represents a node position.) After XOM removes the first node (two contiguous whitespace characters), the following node (the time element) moves up in the tree to the position previously occupied by the whitespace.

The result looks like this (utc.xml):

Serializing Output

You can use the Serializer class to encode output, format it, or send it to a file, among other things. The Time.java program shows you how to do this.

import java.io.FileOutputStream;
import java.io.IOException;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Element;
import nu.xom.Document;
import nu.xom.Serializer;
import nu.xom.ParseException;

public class Time {

   public static void main(String[] args)
       throws IOException, ParseException {

       Builder builder = new Builder();
       Document doc = builder.build("inst.xml");
       Element root = doc.getRootElement();
       Element utc = new Element("utc");
       Attribute att = new Attribute("offset", "-08:00");
       utc.addAttribute(att);
       root.insertChild(0, "\n ");
       root.insertChild(1, utc);
       root.removeChild(4);
       root.removeChild(4);

       Element time = new Element("time");   
       Element hr = new Element("hour");
       time.appendChild(hr);
       hr.appendChild("10");
       Element min = new Element("minute");
       time.appendChild(min);
       min.appendChild("17");
       Element sec = new Element("second");
       time.appendChild(sec);
       sec.appendChild("33");
       Element zone = new Element("zone");
       time.appendChild(zone);
       zone.appendChild("PST");
       root.appendChild(time);

       FileOutputStream out = new FileOutputStream("inst-new.xml");
       Serializer ser = new Serializer(out, "ISO-8859-1");
       ser.setIndent(1);
       ser.write(doc);

   }

}

The program creates five elements and appends these nodes after the last remaining child of instant, which happens to be the date element (the old time element having been removed). The FileOutputStream is also imported and an output file is created (inst-new.xml). The constructor for Serializer specifies an output stream and a character encoding (ISO-8859-1). Serializer also supports encoding for UTF-8, UTF-16, ISO-10646-USC-2, and ISO-8859-2 through ISO-8859-16. The setIndent() method indents child nodes by a line feed plus one space character. The write() method writes the document to the file inst-new.xml:

 10
 17
 33
 PST

Without Serializer, the output of the new elements would appear without indentation, as in time2.xml (see Time2.java):

101733
PST

You could also send the new XML document to standard output instead of a file (see the Serializer constructor in Time3.java).

One More Program

This last program, Final.java, adds several other common structures to the XML document:

import java.io.FileOutputStream;
import java.io.IOException;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Comment;
import nu.xom.DocType;
import nu.xom.Element;
import nu.xom.Document;
import nu.xom.Serializer;
import nu.xom.Text;
import nu.xom.ProcessingInstruction;
import nu.xom.ParseException;

public class Final {

   public static void main(String[] args)
       throws IOException, ParseException {

       Builder builder = new Builder();
       Document doc = builder.build("inst.xml");
       Element root = doc.getRootElement();

       DocType dtd = new DocType("instant", "final.dtd");
       ProcessingInstruction pi =
           new ProcessingInstruction("xml-stylesheet",
               "href=\"final.xsl\" type=\"text/xsl\"");
       doc.insertChild(0, dtd);
       doc.insertChild(1, pi);

       Element utc = new Element("utc", "http://www.wyeast.net/utc");
       Comment gmt = new Comment(" Greenwich Mean Time ");
       Attribute att = new Attribute("offset", "-08:00");
       utc.addAttribute(att);
       root.insertChild(0, "\n ");
       root.insertChild(1, gmt);
       root.insertChild(2, "\n ");
       root.insertChild(3, utc);
       root.removeChild(6);
       root.removeChild(6);

       Element time = new Element("time");   
       Element hr = new Element("hour");
       time.appendChild(hr);
       Text h = new Text("11");
       h.setData("10");
       hr.appendChild(h);
       Element min = new Element("minute");
       time.appendChild(min);
       min.appendChild("17");
       Element sec = new Element("second");
       time.appendChild(sec);
       sec.appendChild("33");
       Element zone = new Element("zone", "urn:wyeast-net:utc");
       zone.setNamespaceURI("http://www.wyeast.net/utc");
       time.appendChild(zone);
       zone.appendChild("PST");
       root.appendChild(time);

       FileOutputStream out = new FileOutputStream("final.xml");
       Serializer ser = new Serializer(out, "UTF-8");
       ser.setIndent(3);
       ser.write(doc);

   }
}

This program creates both a document type declaration and a processing instruction, then inserts them into the prolog of the final.xml. A namespace is declared for the utc element and a comment is inserted just above it. The text child or content of the hour element is set with the Text class; then it's changed with the setData() method of Text. Another namespace is set for zone in its Element constructor and then altered with the setNamespaceURI() method.

Here is the file that this program outputs:

  
  
  
  
     10
     17
     33
     PST
  

Wrapping Up

It's worth noting that XOM avoids convenience methods like the plague. But it is flexible enough to allows users to write their own methods in subclasses. XOM also has several other packages, which I haven't discussed in this article: nu.com.canonical, a serializer for outputting canonical XML; nu.xom.xslt, supporting XSLT transformations for TrAX-aware processors, such as Saxon; and nu.xom.xinclude, an implementation of XML Inclusions.

I've found XOM to be simple and straightforward. It offers me a lot of functionality without much fuss. If you have any suggestions for XOM's development, contribute them by subscribing to the XOM-interest mailing list.

So you've hardened your Windows boxes and locked down Exchange. So what? If I can monitor your network (and if I work at your company, I can quite easily do so), I can read e-mail as it crosses the wire. Finding that easy and worthwhile, I might monitor payroll transactions, financial reports, and whatever else I can capture.

You see, protecting servers is all well and good, and you should definitely do that. But have you given a thought to how exposed the confidential information traveling across your network is? Most data is not encrypted by default, and tools for monitoring the data are readily available. Even when the ability to encrypt e-mail exists, what guarantees that users will do so? A search of the Internet returns no less than a dozen free software-based sniffers—tools that, when installed on a computer in your network, can capture the packets traveling across it and open them for reading by any Tom, Jane or Harry. While these tools are a boon to the administrator charged with troubleshooting network problems, in the wrong hands they can mean disaster. Wouldn't it be nice if there was some utility that would sit in the background and automatically negotiate secure, encrypted sessions whenever it was necessary? There is!

To accomplish this wizardry in Windows 2000, you write IPSec policies. IPSec, a standard proposed by the Internet Engineering Task Force (IETF) for secure communications, is built into the Windows 2000 TCP/IP stack. IPSec policy agents are installed by default on every machine. This means that you can have exquisite control over the packets that enter and leave any W2K machine. You can allow or deny their entry or exit, and you can negotiate secure communications between any two Windows 2000 computers on your network. Wouldn't it be a good idea to encrypt communications between Exchange servers? What about transfers of confidential information from Human Resources? How about protecting Active Directory replication? You can do all this on a machine-by-machine basis, or, even more exciting, you can use Group Policy to ensure that multiple systems on your network follow the same IPSec rules. Note that I'm not suggesting that you go hog wild and make all systems talk IPSec all the time, but for those conversations that should be restricted to approved participants, IPSec is the solution.

To apply IPSec, you must understand it. Here's what you need to know.

IPSec: The Standard

The IPSec protocol was originally developed to be part of IPv6, the new version of our current IP protocol. IPv6 expands the Internet addressing scheme and provides native security capabilities and other features. Several IETF Requests for Comments (RFCs) detail its specifications (see RFCs 2709, 2410, 2401, 2207 , 2857, 2403, 2402, 2404); you can read them at http://www.rfc-editor.org/rfcsearch.html.

To successfully implement IPSec, you do not need to be a mathematician or have a Ph.D. in computer science. However, you do need to understand its basics. You can't configure IPSec correctly by right by accident. It just won't work. Worse, you may think you are protecting communications when you're not, or you may shut down necessary communications between systems. The first thing to remember is that there are two phases of IPSec and several steps to each phase. In W2K, you create a policy by making choices that are utilized in each phase. One of the key elements of your success, then, will be a thorough understanding of each phase. Figure 1 illustrates the process.

Figure 1 IPSec policy phases.

IPSec Phase I

The first phase performs multiple setup tasks, including these:

• Mutual authentication—Each computer must positively identify itself to the other. Windows 2000 provides a choice of Kerberos, certificates, or shared-key authentication methods.

• Negotiate encryption and integrity algorithms—W2K can use either DES, 3DES (if using the high-encryption pack), 40-bit DES, or no encryption. Integrity algorithms are used to verify that data received is actually the data sent. Integrity is implemented by preparing a checksum over the packet contents. The checksum, which is also encrypted and transmitted, is recalculated at the receiving computer. If both checksums match, the data has not been changed. W2K uses MD5 or SHA algorithms.

• Select the Diffie-Hellman group—The Diffie-Hellman group represents the size of the large prime number used in the calculations. The name comes from the two gentlemen who first proposed this solution to the key-sharing problem of symmetric key–based encryption algorithms.

• Generate a master key—This is used in Phase II to create the bulk encryption keys. The IPSec symmetric key algorithms that encrypt and decrypt the data use the bulk encryption keys. The master key is generated by both computers and is never transmitted across the network.

• Create an IKE security association—A security association (SA) defines how two computers will securely share information. It consists of both the defined policy and the keys. The IKE security association is used to secure Phase II negotiation.

IPSec Phase II

Phase II creates the SAs that are used to secure your data. Two SAs are required for each conversation: one that originates on computer A and ends on computer B, and one that travels in the other direction. To create the SAs, Phase II must negotiate the following:

• IPSec protocol. The IPSec standard defines two protocols, Authentication Header (AH) and Encapsulating Security Protocol (ESP). One or both may be used.

• Integrity algorithm (MD5 or SHA1).

• Encryption algorithm (DES, 3DES, 40-bit DES, or none)

Renegotiation

IPSec is very flexible. During communications, both Phase II and Phase I can be renegotiated. Renegotiation of Phase II generates new bulk encryption keys and new SAs. Renegotiation of Phase I generates a new master key. In W2K policies, you can require regeneration of keys based on time or the number of packets transmitted. For example, you could require a new encryption key every few minutes or few thousand kilobytes. This limits an attacker's ability to decrypt packets. If she manages to break or acquire the key, she has only the information contained in those packets encrypted with that key, not the entire communication.

IPSec Policies in Windows 2000

IPSec is implemented in Windows 2000 through the use of built-in IPSec drivers in the IP stack, customizable policies, and a policy agent that filters all IP packets against the policy. To take control of the where, when, and how, you define the particulars of negotiation. A wizard walks you through choosing the options defined previously. Once implemented, the IPSec policy is triggered either when packets that match those identified in your filters are required to be transmitted or received, or when the policy requires negotiation of authentication, integrity and encryption with another system. Figure 2 shows the internals of one of default polices that can be used to help you understand IPSec in W2K. You may customize them or develop your own.

Figure 2 Properties of the default Windows 2000 IPSec policy.

Three types of W2K IPSec policies exist:

• Blocking—Prevents packets that meet the criteria of protocol, port, source, or destination from leaving or entering the computer

• Allow—Allows packets that meet the criteria of protocol, port, source, or destination to leave or enter the computer

• Negotiate—Negotiates secure communication between two computers

Both blocking and allow IPSec policies can be applied to single computers. The policies either enable or disable communication facilities. For example, you may want to prevent Windows 2000 Professional systems from responding to HTTP requests. Although no Web services are installed on Professional by default, someone might do so. If your corporate policy forbids such action, it's still pretty tough to prevent all users from doing so. An IPSec blocking policy can prevent the server from answering requests on port 80. (No Code Red worm would infect such a system, even if Joe user installs IIS.)

Negotiate policies, on the other hand, require matching policies to exist on two machines. They are used to secure communications between the machines.

Using Group Policy to Apply IPSec Throughout an Active Directory Domain

Creating IPSec policies computer by computer is a tedious and dangerous task. That's because asdasthere are many steps to follow. In addition, if you make a mistake and policies that should be used between cooperating computers do not match, they will not work. If multiple computers in an Active Directory environment must participate in IPSec-negotiated sessions, the easiest way to ensure consistent application is through Group Policy. Figure 3 indicates the area of a Group Policy where IPSec policies reside. In this figure, a policy for negotiating Exchange server administrative functions has been activated.

Figure 3 The Exchange Server Admin IPSec Policy is created in the Exchange Server OU Group Policy.

IPSec policies are created within the IPSec container of a Group Policy. The Group Policy is linked to the OU that contains the servers that should use it. Let's imagine, for example, that you want to encrypt administrative sessions between the Exchange administrator's computer and all Exchange servers. If all Exchange servers and the administrators computer are placed in the same OU, the IPSec policy written in a Group Policy linked to that OU will be applied consistently to all computers. Likewise, you might establish policies for communications between all computers in the Accounting department and the Accounting database server, or between top executives.

Chapter 2, "Packet Switching Architecture," examined how changesin the IOS software implementation have been used to improve packet switchingperformance. Cisco also uses special hardware designs to improve switchingperformance. The first notable example of this was the introduction of the Cbuswith the AGS+ router and its successor, the Cisco 7000 series router, in theearly 1990s. Although these products are no longer sold or supported in currentIOS versions, a large part o

Chapter 2, "Packet Switching Architecture,"examined how changes in the IOS software implementation have been used to improve packet switching performance. Cisco also uses special hardware designs to improve switching performance. The first notable example of this was the introduction of the Cbus with the AGS+ router and its successor, the Cisco 7000 series router, in the early 1990s. Although these products are no longer sold or supported in current IOS versions, a large part of their design was adapted for the Cisco 7500 series routers that are widely deployed today. This chapter covers the AGS+ and 7000 routers because a sizeable part of the 7500-specific switching features actually had their origins in the IOS design for these early platforms.

AGS+ Hardware Architecture

The AGS+ router was an improved version of the original AGS router. The AGS (without the plus) was based on a Motorola 68000 series CPU (M68k) and used media interface cards interconnected by a relatively slow 155-Mbps data bus called the Multibus. Due to the speed limitations of this processor and the Multibus, packet switching performance was limited to the range of 7000 to 14,000 packets per second (pps) even with fast switching—pretty anemic by today's standards. In fact, under some conditions the Cisco 2500 series routers can outperform these switching speeds!

The Cisco AGS+ and 7000 routers were designed before the advent of high speed computer buses and economical RISC-based CPUs. So, when Cisco's engineers started looking for ways to boost switching performance, there weren't many off-the-shelf solutions from which to choose. The engineers decided to solve the problem by designing their own high-speed data bus and packet switching engine. Thus was born the Cbus.

The original Cbus (short for "Cisco bus") was a 32-bit bus operating at 16.67 MHz, giving a total bandwidth of 533 Mbps—a vast improvement over the Multibus. The bus was designed with 32 data lines, 24 address lines, and 8 command lines.

The Cbus switching engine was based on a microcoded 16-bit slice microprocessor with an 80-bit instruction word that allowed several operations to execute concurrently in a single cycle. Unlike general purpose processors such as the M68k, the Cbus processor had a small, customized instruction set designed specifically to support data switching operations. The processor was packaged on a special interface card containing memory for the processor's instructions (called control store), fast packet memory, and interfaces to both the Multibus and the Cbus. This card comprised the switching engine and was called the Cbus Controller.

These two new features, the Cbus and the Cbus Controller, were added to the original AGS architecture to create the AGS+ router. Figure 4-1 shows a diagram of the AGS+ architecture.

Figure 4-1 AGS+ Architecture

The following list describes each of the major components shown in Figure 4-1:

• Processor (CPU)—Runs IOS and performs process switching functions, and performs fast switching between Multibus interfaces. The processor also performs fast switching for packets that are received from Cbus interfaces but can't be autonomously switched.

• Main Memory—DRAM containing the running IOS image, its data, and system packet buffers.

• Multibus—Data bus interconnecting the processor with the Multibus interface cards. The Cbus controller card also has a connection to the Multibus.

• Cbus Switching Processor—Runs optimized non-IOS microcode to perform fast switching of packets between Cbus interfaces. This processor is on the Cbus controller card.

• Fast Packet Memory—High-speed memory on the Cbus controller card that is dual-ported between the Cbus switching processor and the Cbus interface cards. Used to store packets received from or transmitted to Cbus interfaces. This memory is referred to by the name MEMD in the Cbus architecture.

• Cbus—The Cisco proprietary data bus interconnecting the Cbus controller card with the Cbus interface cards.

The AGS+ retained the Motorola 68000 series processor and the Multibus backplane used on the AGS. The Cbus enhancement was made by converting five of the interface card slots on the backplane to access the Cbus. This allowed Multibus interface cards to be used in the same chassis with the new Cbus interface cards.

After the hardware enhancements were added to the AGS+, how did IOS actually use them to increase switching performance? Let's examine how IOS put these enhancements to work.

Packet Switching with the Cbus

Recall the descriptions of fast switching and process switching from Chapter 2, "Packet Switching Architecture." In both of these methods, the receiving interface hardware copies the received packet into I/O memory and interrupts the main processor to begin switching the packet. Whether during the interrupt or in a background process, the main processor has to do all the work of actually switching the packet; the interface hardware just receives the packet and transmits it to the media. Also, packet switching is just one of the many tasks the main processor has to do, so not all of its capacity is available for packet switching.

The Cbus and the Cbus Controller provided another processing alternative on the AGS+. Instead of IOS performing all the switching on the main processor, much of the switching could be performed by the Cbus Controller without involving the main processor at all. The Cbus Controller was capable of performing fast switching autonomously on the switching processor as long as both the receiving and the transmitting interfaces were on Cbus cards. This capability provided a new method of switching appropriately called autonomous switching.

Autonomous Switching

Autonomous switching worked essentially like fast switching—except on a different processor. It was triggered by a packet receive interrupt (this time to the switching processor) and used a local cache to look up forwarding information, just like fast switching. In fact, autonomous switching used the same hash table structure for its fast cache that IOS used prior to release 10.2. IOS maintained both the main fast cache and the local switching processor (Cbus) cache during process switching in the same way. Each time an entry was added or invalidated in the main cache it also was added or invalidated in the Cbus cache.

Autonomous switching did differ from fast switching in a couple ways, though. Autonomous switching didn't support as many protocols as fast switching—only IP, IPX, and bridging—and it handled cache misses differently.

Recall that in fast switching, if a packet is received and there is no fast cache entry for it, the packet is queued for process switching. In autonomous switching, however, if there was no Cbus cache entry for a packet, the packet was sent to the main processor for possible fast switching. If the packet was destined to another Cbus interface, the main processor could fast switch the packet while it was still in the Cbus Controller. However, if the packet was destined to a Multibus interface, the whole packet had to be copied across the slow Multibus to a system buffer, and then process switched. Although the Cbus Controller had a Multibus interface, it couldn't use it to autonomously switch packets.

Cbus Fast Packet Memory

The Cbus Controller design introduced a new strategy for IOS packet buffering that is still in use today on the Cisco 7500 series. On the AGS+, process switching and fast switching used the system buffers for packets as described in Chapter 1, "Fundamental IOS Software Architecture." However, these system buffers held a distinct disadvantage for autonomous switching: They were located in main memory on the main processor card, which made them inaccessible to Cbus interface cards.

To provide packet buffers for the Cbus interfaces, Cisco designed the Cbus Controller with its own local dedicated packet buffer memory. The memory, referred to as MEMD, was a fixed 512 KB region that could be addressed by both the switching processor and the Cbus interface cards. Of the total 512 KB available, the first 8 KB (called page zero) was set aside for control structures, leaving the rest available to be carved into packet buffers.

What's most interesting about MEMD is how it was logically organized. Like the system buffers, MEMD was divided into buffers of varying sizes to accommodate different sized packets. Unlike the system buffers, MEMD buffer sizes were determined by the actual MTU sizes of the Cbus interfaces present on the router—not by a predetermined set of sizes.

The buffers were divided into a maximum of four pools, and then they were allocated to the interfaces from those pools. Within each pool, all buffers were the same size. Due to the limited size of MEMD and its control structures in page zero, the maximum number of packet buffers that could be defined was limited to 470 regardless of the number of Cbus interfaces present.

The switching processor maintained two queues in MEMD's page zero for each Cbus interface: a receive queue and a transmit queue. These queues were similar in function to the input queues and the output queues maintained by IOS. When a Cbus interface detected an incoming packet, it allocated a MEMD buffer from the appropriate pool, copied the packet data into the buffer, and placed the buffer on its receive queue to await switching by the switching processor. If the packet was autonomously switched, the switching processor switched it and placed the modified packet on the transmit queue of the destination Cbus interface. If the packet was fast switched, the main processor switched it and directed the switching processor to place it on the appropriate Cbus transmit queue. For packets that had to be process switched, the switching processor copied the packet to the main processor memory over the Multibus and returned the MEMD buffer to its original pool.

The switching processor also maintained counters and limit values in MEMD for each of the receive queues and the transmit queues. Each receive queue had a receive queue limit (RQL) and each transmit queue had a transmit queue limit (TQL) to prevent a single interface from hoarding all the MEMD buffers.

The RQL value determined the maximum number of packet buffers that could be held on the receive queue at any time. When a receive queue contained the RQL number of buffers, it was considered full and any additional packets received were dropped until the number of buffers dropped below the RQL level. Similarly, the TQL value determined the maximum number of packet buffers that could be held on the transmit queue at any given time. Any additional packets switched to an interface while its transmit queue was full were dropped until its transmit queue depth dropped below the TQL value.

You can find a more detailed description of the MEMD counters and the buffer carving process in Chapter 6, "Cisco 7500 Routers."

The Cisco 7000 Series Router

The Cisco 7000 series router represented the next step in the evolution of the AGS and the Cbus architecture. Other than the mechanical structure and outward appearance, the 7000 wasn't drastically different from its predecessor, the AGS+. The biggest architectural difference was the elimination of the Multibus and Multibus interface cards—only Cbus interface cards were supported on the 7000.

Some of the changes were mostly superficial. On the 7000, the AGS+ processor card was replaced by the Route Processor (RP) card and the Cbus Controller was replaced by the 7000's Switch Processor (SP) card, but the RP and SP retained the same CPUs as their AGS+ counterparts. Although there was no Multibus, per se, on the 7000, the switching processor on the SP still connected to the main processor on the RP via a 155-Mbps Multibus-like interface. These similarities allowed the IOS software and switching processor microcode to work on the 7000 without requiring a large number of changes.

The 7000 did introduce a new hardware feature not present on the AGS+: hot-swappable interface cards. The 7000 routers allowed Cbus interface cards (called interface processors on the 7000) to be removed and re-inserted while IOS was operational with minimal operational disruption to other interface processors. When IOS detected that a card was being removed or inserted, it momentarily stalled operations on the Cbus while the insertion/removal was underway. When the insertion/removal completed, IOS resumed operation of the Cbus and continued switching packets where it left off.

This new feature necessitated a change in the operation of the switching processor microcode. Whereas the composition of interfaces was fixed on the AGS+ while IOS was in operation, on the 7000 that composition could change on the fly. The original switching processor microcode on the AGS+ was designed to carve a static MEMD buffer allocation at initialization time. On the 7000, however, the microcode had to be changed to re-carve the buffer allocation each time a card was inserted or removed. This allowed the SP to keep the most efficient use of packet memory resources even if the interface composition changed.

Quiz time: What do you think are the two most important files on your system? Justify your answer. Note: There’s not necessarily a right or wrong answer to this, so tell me what you think. My answer to this "quiz" is the substance of today’s article.Personally, I think the two most important files on anybody’s system are /etc/inetd.conf and /etc/sysconfig.conf. These two files are probably the least reviewed, most poorly understood files on the average system. Wh

# tcpdchk

warning: /etc/inetd.conf, line 75: in.tftpd: not found in /usr/sbin: No such file or directory

# netstat -a
tcp        0      0 *:smtp                  *:*                     LISTEN    
tcp        0      0 *:7110                  *:*                     LISTEN    
tcp        0      0 volcan.pananix.c:domain *:*                     LISTEN    
tcp        0      0 localhost:domain        *:*                     LISTEN    
tcp        0      0 *:www                   *:*                     LISTEN    
tcp        0      0 *:printer               *:*                     LISTEN    
tcp        0      0 *:auth                  *:*                     LISTEN    
tcp        0      0 *:swat                  *:*                     LISTEN    
tcp        0      0 *:finger                *:*                     LISTEN    
tcp        0      0 *:uucp                  *:*                     LISTEN    
tcp        0      0 *:imap2                 *:*                     LISTEN    
tcp        0      0 *:pop3                  *:*                     LISTEN    
tcp        0      0 *:pop2                  *:*                     LISTEN    
tcp        0      0 *:exec                  *:*                     LISTEN    
tcp        0      0 *:login                 *:*                     LISTEN    
tcp        0      0 *:shell                 *:*                     LISTEN      

# fuser -n tcp 7110
7110/tcp:             2967

# ps awx | grep 2967
2967 ?        S      0:02 /usr/opt/applix/axdata/fontmetrics/gallium/fs/axfontfs -cf /usr/opt/applix/axdata/fontmetrics/gallium/fs/

# fuser -n tcp shell
shell/tcp:             617

  617 ?        SW     0:00 [inetd]

imapd:  ALL except localhost, 127.0.0.1: DENY

swat:  ALL except david@localhost, david@127.0.0.1 : DENY

# tcpdmatch imapd pananix.com
client:   hostname mail.pananix.com
client:   address  209.127.112.154
server:   process  imapd
matched:  /etc/hosts.allow line 8
option:   DENY

access:   denied

# tcpdmatch imapd localhost
client:   hostname localhost
client:   address  127.0.0.1
server:   process  imapd
access:   granted

# tcpdmatch swat localhost
client:   hostname localhost
client:   address  127.0.0.1
server:   process  swat
matched:  /etc/hosts.allow line 7
option:   DENY
access:   denied

]# tcpdmatch swat david@localhost
warning: /etc/inetd.conf, line 75: in.tftpd: not found in /usr/sbin: No such file or directory
client:   hostname localhost
client:   address  127.0.0.1
client:   username david
server:   process  swat
access:   granted

# tcpdmatch swat david@chiriqui.pananix.com
client:   hostname chiriqui.pananix.com
client:   address  192.168.0.2
client:   username david
server:   process  swat
matched:  /etc/hosts.allow line 7
option:   DENY
access:   denied

Step 1

Open an image in Photoshop. I chose the next one to work with:

Step 2

Select Filter > Artistic > Smudge Stick with the next settings:

This tutorial will show you how to quickly add motion to your images in a few easy steps.

Step 1

To complete this tutorial, import on your computer the next pictures: “initial-photograph.jpg”, “initial-single-eye.jpg”.

Step 1

Step 2

Inside the document type your company name and company slogan with what font you want. I’ve used “Arial Black” for company name and “Arial Regular” for the slogan:

I use widgets a lot. They are very useful, but at the same time is very hard to find the right design for your theme. I usually search a lot for one that has both the things I need and colors. Here is how to design a volume control widget in two classic colors, black and blue. You can choose other two colors

Step 1

Open a new Adobe Photoshop document 200x200 pixel with white background. Make a new layer and set your foreground to black and with your Rounded Rectangular Tool draw a rectangular.

Step 2

Open a new layer and with your Elliptical Marquee Tool draw a circle in the upper part of the rectangular. Fill it up with white and set the opacity to 46%.

Step 3

Open a new layer set the foreground color to #397fff and the Rounded Rectangular Radius to 5 px. Now draw a rectangular in the middle of the first one.

Make a new layer, select your Line Tool (U) and start cutting the blue rectangular. Make sure the sections have the same size.

Step 4

Now add some shadow to the first rectangular.

The result should be this.

The Microsoft ASP.Net MVC platform enables developers to build MVC applications using the .ASP.Net framework. Serving as an alternative to ASP.Net Web Forms, ASP.Net MVC provides separation of concerns, support for test-driven development, fine-grained control over HTML and JavaScript, and intuitive URLs, Microsoft said. ASP.Net is Microsoft's technology for building dynamic Web applications

The company is offering assistance Friday for developers using ASP.Net MVC, providing free, downloadable HTML design templates for use with ASP.Net MVC applications. Templates are part of the ASP.Net MVC Design Gallery.

Each template features a Site.master file, a CSS style sheet, and an optional set of images and helper methods, said Microsoft's Scott Guthrie, corporate vice president of the company's Developer Division, in his blog.

"The gallery allows you to preview each of the designs online as well as download a .zip version of them that you can extract and integrate into your site. The gallery allows anyone to create and submit new designs under the creative commons license," Guthrie said.

"We think this will provide a useful way for developers to more easily create attractive, standards-compliant sites," he said.

The company also is preparing to ship improvements to its MVC platform via an ASP.Net MVC Release Candidate build due in January. ASP.Net MVC was released as a beta technology in October. Improvements in the release candidate build include a change in which MVC view files by default do not have code-behind files.

"This change helps to reinforce the purpose of views in a MVC world (which are intended to be purely about rendering and not contain any non-rendering-related code) and for most people eliminates unused files in the project," Guthrie said.

With the release candidate, Developers also can build strongly typed HTML and AJAX helper extensions that use expression syntax to refer to the View model. Also featured is a top-level model property on views.

An automatic UI scaffolding capability is offered when creating views using a new ASP.Net MVC "Add View" command inside Visual Studio. This support enables automatic generation of views against any .Net type or object.

Also planned is jQuery-vsdoc intellisense support and new FileResult and JavaScriptResult ActionResult types to more easily download files and executable JavaScript to browsers. Project template improvements and extensibility also are eyed as well as bug fixes.

Additionally, a built-in MSBuild task can be used to include views as part of the project compilation process. This verifies syntax and code included inline within views and master pages for the application. Build errors are provided if there are problems.

Source : webwereld.nl

Ok, this is a really particular post.

I’m working to create one of the biggest post about Photoshop (you know, i love this software…).

It is “in progress” which means that i will update it every time i’ll find new cool things. JUST FREE COOL THINGS.

If you want to participate, please, leave a comment with a good link and if you like this post…your vote is always appreciated (Digg it, Add to Delicious, Stumble This)!

UPDATE (august 9th): At this moment there are 50 links

70 Beauty-Retouching Photoshop Tutorials

15 Amazing Photoshop Text Effects

41 Nicest Photo Effects

45 Photo Editing Tutorials for Photoshop

11 Super Awesome Photoshop Movie Effects

15 Photoshop Tutorials for Creating Product Advertisements

70 Horror, Blood and Gore Photoshop Effects and Brushes

18 of the best photoshop videos online

53 Killer Photoshop Illustrator Effects and Tutorials

45 Photoshop Tutorials for Better Navigation

20 Excellent Photoshop Tutorials for Web Designers

27 Best Photoshop Web Layout Design Tutorials to Design Decent Web Layouts

Top 15 Fire effect Photoshop tutorials

Create vector and cartoonish characters: Top 25 Photoshop tutorials

Create an Awesome Illustration Using Custom Brushes

Grunge Textures (2400 pixels x 1800 pixels minimum)

30 Paper Textures

12 Places To Download Free Textures

55 Human Brush Sets

36 cool free textures

300+ Vintage Style Textures

75 Insane High Res Photoshop Brushes

Over 300 high resolution textures

300+ Free Hi-Res grunge textures you’ve never seen before

30 Brilliant Textures

Dinpattern (free to use commercially and non)

400+ High Quality Patterns

18 Excellent Sources for Free Photoshop Patterns

400+ Swirls, Curls, and Fleurons

35 FREE abstracts and cool Photoshop brushes hand-picked from Deviantart

25 New Brushes hand-picked from DeviantArt - Round 2

Brushes Download (Various)

100 Awesome High Resolution Photoshop Brushes

64 Beautiful And Free Nature Brush Sets

200+ Free Grunge Photoshop Brushes

Oriental Photoshop Brushes And Vector Images For Mysterious Designs

10 Swirls & Decorative Brush Sets

Animals

Psd Freebee (Various)

Official PSDS (Various)

My (free) professional template for you

14 Amazing Free Photoshop .psd Resource Sites

iPhone interface psd

Spider Man 3 Logo

860 Shapes

8940 Custom shapes

Foliage Shapes

1000 Web 2.0 Gradients

1000s of Free Photoshop Plugins & Filters MegaList

The history of Photoshop

Source: blogof.francescomugnai.com

Step 1

Open the next two pictures in Photoshop.

Step 2

Use “drag and drop” to move the picture “neon-picture.jpg” over the “initial-neon-picture.jpg”. Now we have two layers “background” and “layer1”. Set the “blending mode for the layer” in Layers Tab to “screen” for the layer “Layer1”.

Step 3

For the layer “Layer1” Filter > Blur > Motion Blur with these settings:

Repeat this step and apply again these settings and you should get the neon effect on you picture:

Step 1

Open a new document in Adobe Photoshop with a black background. Create a new layer and draw few lines like in the next picture, using the Brush Tool in the Tools Tab:

Step 2

Now, set the Filter > Blur > Radial Blur with these settings:

Step 3

Choose Filter > Distort > Zig-Zag with the settings:

And the result:

Step 4

Filter > Blur > Gaussian Blur with the radius “1.1” and add a new layer with a blue rectangle. Set the layer “blending mode” to “Soft Light”. You should get something like below:

If you configure Filter > Blur > Motion Blur with the settings:

And set the layer “blending mode” to “overlay” for the layer that contains the rectangle you obtain a metallic effect:

Step 1

Create a new document in Photoshop with a white background. New layer in the Layers Tab and draw some kind of lines using the Brush Tool. The color of the lines should be black:

Step 2

Choose Filter > Blur > Motion Blur with this settings:

Step 3

Using the Paint Bucket Tool (Tools Tab) color all the lines with white and the background with black. Like this:

Step 5

Select Filter > Blur > Radial Blur with the next settings:

And you obtain:

Step 6

Draw a rectangle in a new layer with the color “#20424B” and set the layer “blending mode” (in the Layers Tab) to “Soft Light”.
That’s all. Here is the result: a centrifugal movement effect.

Step 1

Open a picture that you want to retouch in Adobe Photoshop. I used the next picture to work with:

Step 2

Duplicate your picture in the Layers Tab and clear everything except the face skin like this:

Step 3

Now choose Filter > Blur > Gaussian Blur with the settings (for the layer which you duplicated):

Step 4

Adjust the duplicate layer if needed, with a small brush tool, change the brightness and contrast of the “parent” layer (Image > Adjustments > Brightness/Contrast) using the settings:

And that’s the results: a beautiful model photo for your magazine.

Step 1

Open a picture which you want to retouch in Photoshop. I will with the next image:

Step 2

Add more luminosity to the picture using Filter > Render > Lighting Effects. Use the next settings and see the preview:

Step 3

Select Image > Adjustments > Color Balance to add more color to your picture, using these settings:

Step 3

A little more contrast Image > Adjustments > Brightness/Contrast with the settings:

And you have a new picture for your collection:

Step 1

Open the next picture in Photoshop:

Step 2

Duplicate the layer in Layers Tab. And on the duplicate layer apply the effect Filter > Blur > Radial Blur with the next settings:

The new layer should look like this now:

Step 3

With a small brush (like “Soft Round 30 pixels”) delete an area on the duplicate layer and adjust the luminosity and the contrast on the layers, and that’s the result: a nice dynamic movement from a static picture.

Step 1

Use the next picture in a new document window in Adobe Photoshop, with a black background:

We were allowed to use this picture thanks to Mr. John Steven French from Abrams Planetarium at the Michigan State University.

Step 2

Adjust the picture’s position like here:

Step 3

Adjust the picture colors using Image > Adjustments > Color Balance with the next settings:

Set the contrast and luminosity like here, using Images > Adjustments > Contrast/Luminosity:

Step 5

Adjust the picture position again and export the picture:

Step 1

Open an image in Photoshop. I chose the next one to work with:

Step 2

Select Filter > Artistic > Smudge Stick with the next settings:

Step 3

Add a new layer in the Layer Tab, draw a rectangle with a white color and add shadow to this layer; this new layer must be below the layer that contains the picture:

Add a small border to the rectangle, if you want, using the Layer > Layer Style > Drop Shadow.

Step 4

Now add a color to the layer “background” and some kind of texture using another picture and the “Blending Options” in the Layers Tab:

Step 1

Open the next picture in Photoshop. Like in many of our tutorials we used a picture provide by http://www.sxc.hu/.

Step 2

Right click on the layer in the Layers Tab and Duplicate Layer. Now we have two layers: the layer “background” and the layer “Background copy”:

Step 3

On the layer “background copy” apply the next effect: Filter > Blur > Radial Blur using the settings:

Step 4

Apply the step 3 again:

Step 5

Resize the layer “background” to a small dimension like here:

Step 6

Select the layer “background copy” and delete an area using an “Airbrush Soft Round 100” (Brush Tool in the Tools Tab):

Step 7

To the layer “background copy” apply the Filter > Render > Lighting Effects using the settings:

Step 8

Choose the layer “background” and apply the radial blur effect using Filter > Blur > Radial Blur with the settings:

Step 9

Apply the radial blur again, for the same layer, but this time with the next settings:

Step 10

Rotate the layer “background” to the left and look at the result:

Now you can play with the contrast and luminosity settings on the layers:

Add lens flare using Filter > Render > Lens Flare. I chose “Movie Prime” with 133% brightness settings:

Step 9

Make another rectangle at the bottom of the first one, change the perspective and adjust the position to be like here:

Step 10

Duplicate the layer “rectangle”; now you have a new layer “rectangle copy”. Change the color by selecting Layer > Layer Style > Color Overlay and choose a light grey color. Use Elliptical Marquee Tool to delete an area of the rectangle:

Now select Select > Inverse and delete again:

Step 11

Use a small brush like “Soft Round 135 pixels” to delete the right and the left margins of the layer “rectangle copy”. Do this step with caution if you want the result to be something like this:

Step 12

Duplicate the layer “rectangle copy” and move it in a new position like here:

Duplicate the layer again and move it again. Pay attention to details and the result is something like:

You can play with the details or the background elements like me, or better, and the results can be very realistic; now you have a microphone created using just Abode Photoshop CS 2:

Step 4

Duplicate the layer “duplicate circle” and name it “duplicate circle 90″. Rotate the layer with 90 degrees choosing Edit > Transform > Rotate 90° CW and set the opacity (in the Layers Tab) to 18%. After this step you should obtain the next result:

Step 5

Set the background color to a light green (#dffca2). For this double click on the “Foreground Color” in the Tools Tab and type the color code like here (or choose the color using the “Color Sampler”):

Add a lighting effect to the layer “background” using Filter > Render > Lighting Effects. We’re doing this step to apply a kind of perspective to our work:

And this is the result after this step:

Step 6

Above the layer “duplicate circle 90″ make a new layer and draw a rectangle inside this new layer. Name the new layer “rectangle”. Set the rectangle color to black (double click on the “Layer Thumbnail” in the Layers Tab and set the black color in the window that appears):

Step 7

Right click in the Layers Tab and select Rasterize Layer (do this to manipulate easier the rectangle). Using the Elliptical Marquee Tool (M) (select that in the Tools Tab), delete an area like in the next picture:

With the same tool delete an area like this:

Make same thing on the right side of the rectangle, and the result:

Step 8

Transform the rectangle perspective using Edit > Transform > Perspective. Drag the bottom-left rectangle corner to the center like here:

Step 1

This tutorial should help you through making a simple, yet realistic-looking microphone using Adobe Photoshop CS 2, and only Adobe Photoshop CS 2.
Open a new document in Adobe Photoshop CS 2 with the size 500x500 pixels and a white background. Create a new circle in a new layer on your scene. To do this use the Ellipse Tool (U), you can find it in the Tools Tab (if the Tools Tab is not open select Window > Tools to open it).
To make a perfect rounded circle hold down the SHIFT key when you draw the ellipse. Now you have two layers in the Layers Tab: the layer “background” and the layer which contains the circle. Name this layer “circle”. Right click on the layer “circle” in the Layers Tab and select the option Rasterize Layer. On the same layer apply a gradient color. To do this, select Layer > Layer Style > Gradient Overlay; use the next settings for the “Gradient Overlay” (you can add an gradient to an layer using the Layers Tab window, just clicking the icon “Add a Layer Style” at the bottom of the window):

After this step the result should be like this:

Step 2

Duplicate the layer “circle”. Name this new layer “duplicate circle” and delete the gradient effect. Click on the arrow icon in the Layers Tab to view the “Layers Effects”, right click on the effect and Disable Layer Effects (you can delete the layer effect just using the “drag & drop” technique: drag the layer effect on the recycler icon in the bottom of the Layers Tab). In the Tools Tab select the Single Column Marquee Tool and delete a area like in the next picture (to do this use the next technique: 3 steps right, delete, 3 steps right, delete … and do this for entire area of the circle):
Look at an intermediary step:

And the final step:

Step 3

Using the Filter > Distort > Spherize apply a “Spherize Effect” to the layer “duplicate circle”. Use the next settings for the “Spherize Effect”:

Adjust the size of the layer “duplicate circle”. To do this select Edit > Transform > Scale and reduce the scale until it has the initial size (this may be the same size with the size of the “circle” layer; hold on the SHIFT key, in this case the resize area should be symmetric) like here:

Step 1

Create a new document in Photoshop CS 2 with a black background. Type a text (I chose “Cinema”) with a hand font type like “HansHand”. This is the font type that I used:

Step 2

Select the layer which contains the text and apply the next effect using Layer > Layer Style > Outer Glow. Set the “Outer Glow” settings like in the next picture:

Step 3

On the layer with the text apply the “Color Overlay Effect”. To do this select Layer > Layer Style > Color Overlay. Use the next settings to apply the effect:

Now you have a neon text for your cinema :

Step 4

You can use Adobe ImageReady to create a blinking text. In the Tools Tab select the option to jump to ImageReady:

Step 5

Open the “Animation Window” (if that is not opened) using Window > Animation. In this window select Duplicate Current Frame:

Step 6

On the frame number two, in the Layers Tab, make the layer which contains the text invisible. Click on the “eye” like this:

Step 7

Export the picture as “.gif” file and you have a blinking neon text using the Photoshop CS 2 and ImageReady CS 2:

Step 1

This tutorial will help you through making a simple, but realistic-looking wireless mouse using Adobe Photoshop.
Open a new document in Adobe Photoshop with the size 500x500 pixels and a white background.
Create an ellipse using the ellipse tool. You can find it in the Tools Tab, Ellipse Tool (U):

Draw an ellipse like here:

Step 2

Now we’re going to apply a few effects on this ellipse. First we’re going to apply the “Drop Shadow Effect”. To do this step select Layer > Layer Style > Drop Shadow or click on the icon Add Layer Style in the Layers Tab bottom. Use the next settings for this effect:

Step 3

Apply the Layer > Layer Style > Inner Shadow effect using for this the next settings:

Step 4

Now select Layer > Layer Style > Inner Glow with the settings:

Step 5

Apply Layer > Layer Style > Bevel & Emboss. Use the next settings when applying the effect:

Step 6

The final effect is “Color Overlay”. Select Layer > Layer Style > Color Overlay. Use the settings:

This is our intermediary result after these steps:

Step 7

Draw a new ellipse, in a new layer, on the top of the first one and set opacity to 32%. To set the opacity check the Layers Tab:

And this should be your result:

Step 8

Ok. Now we’re going to make the mouse buttons. To do this select the last ellipse which you drew. Use the Single Column Marquee Tool (you can find it in the Tools Tab) to delete the four lines in the ellipse center like here:

Step 9

We’re making the scrolling mouse button. Take the Rectangular Marquee Tool (in the Tools Tab), set the “smooth border” to 7 px. To do this select Select > Modify > Smooth and set the “Samples Radius” to 7 pixels. Delete the selected are and the result:

Step 9

Move the selection in this position (the Rectangular Marquee Tool should be selected):

Use CTRL+C and CTRL+V to copy the selection to a new layer. Move and resize the new layer; with the Single Row Marquee Tool delete an area like here and set the opacity to 50%:

Step 10

Now select all layers (but not the layer “background”) and use Edit > Transform > Scale to make the mouse oval. Using the backgrounds elements or more mouse details you can obtain a result like me, or even better:

Step 1

Open the next picture in Adobe Photoshop (save it on your computer first):

Step 2

We’ll try to make a “water drop” on that picture. Select the Elliptical Marquee Tool (M). You can find it in the Tools Tab:

Select an area like here (using the ellipse tool); hold down the SHIFT key to draw a perfect rounded selection:

Step 3

Use CTRL+C to copy the selection and CTRL+V to past it into a new layer. Apply the “Drop Shadow Effect” to the new layer. To do this make the next step: select Layer > Layer Style > Drop Shadow. Use the next settings when applying the effect:

Step 4

Select Layer > Layer Style > Inner Shadow to add the “Inner Shadow” effect to the new layer. Use the next settings for this effect:

And here’s the intermediary result after these steps:

Step 5

Draw an ellipse with a white background color. “Rasterize” the new layer by right clicking on the new layer in the Layers Tab and selecting Rasterize Layer:

Step 6

Use the Elliptical Marquee Tool (in the Tools Tab) to make a selection like here (hold down the SHIFT key when you make this selection to draw a perfect circle):

Select Select > Feather with the “feather radius” 5:

Choose the Select > Inverse and press down the DELETE key to delete an area of the new layer. Make this for 3 times. Make sure you are on the layer with the ellipse whish draw it last time. Set the layer opacity to 33% and your result should be like this:

Step 7

Draw another “water drop” using the above steps and then another one. Resize the new “water drop” and that’s the result:

Ok. Now you can play with your creation and using Photoshop you can get a nice result:

Step 1

This tutorial will show you how to do a fighter effect using Adobe Photoshop tools and effects, with only Photoshop without any other photo or something else.
Create a new document in Photoshop with a black background and draw a rectangle in a new layer. Right click on the new layer and choose Rasterize Layer. Use the Rectangular Marquee Tool (M) (find it in the Tools Tab) to delete an area like here:

Step 2

Apply the next effect to the new layer. Select Filter > Distort > Spherize with the next settings:

Step 3

Apply the “Outer Glow Effect” choosing Layer > Layer Style > Outer Glow. Use the next settings when applying this effect:

Step 4

Select Filter > Distort > Twirl. Apply the next settings to the effect:

And here is an intermediary result:

Step 5

Now apply the blur effect. Select for this Filter > Blur > Radial Blur and use the next settings to apply the effect:

And another intermediary result:

Step 6

Change the color to the layer “background” to a dark blue and apply the “Color Overlay Effect” for the layer “Shape 1”. Use the next settings to apply the effect:

And the result:

Use a picture in the center of the background and with a “Radial effect” and a little bit attention to details you can obtain a result like below (please check the “Racing Car” tutorial if you are not sure how to apply the “Radial Effect”):

Step 2

This Adobe Photoshop tutorial will guide you through creating a space scene.
First we will create the star field using Photoshop.
Open a new document in Adobe Photoshop with a black background. Apply the next effect to the layer “background”: select Filter > Artistic > Film Grain. Use the next settings when applying the “film grain” effect:

Step 2

Duplicate the layer “background” and set the “blending mode for the layer” to “Linear Light”. This should be the result:

Step 3

Select the layer “background” and choose Image > Adjustments > Brightness/Contrast with the next settings:

We will obtain the result:

Now the star field is more realistic and the stars are disproportional.

Step 3

Duplicate the layer “background copy” (right click in the Layers Tab and choose Duplicate Layer). Set the “blending mode for the layer” to “Multiply”. With Eraser Tool (you can find it in the Tools Tab) delete an area like here (note: use a brush like “Soft Round 160 pixels”):

Step 4

Draw a rectangle in a new layer (above the layer “background copy 2”) and set the rectangle background color to a dark blue. Set the “blending mode for the layer” to “Color Dodge” and the result should be this:

Step 5

On the layer “background copy” select Filter > Render > Lens Flare and place a little star like in the next picture. Make the stars one by one and with a different lens flare dimension of the effect. If you are careful with the details you can obtain a result like this or even better:

Step 1

Step 2

Draw another rectangle having the dimension like in the next picture:

Step 3

Open a picture and draw it over the rectangle. Resize it if the picture is bigger then you need to get something like this:

Step 4

Using the Rectangle Tool (you can find this tool in the Tabs Tool) add more details on the product box:

Step 5

Use the Text Tool to add some kind of text on your product:

Step 6

Now in the Layers Tab “link” the layers which you created. To do this click on the link box highlighted below (do not link the layer “background”):

Step 7

Now we will add some perspective on the front of the box. To add perspective “rasterize” first the layers which contain text. To do this step select the layer in the Layers Tab and choose Rasterize. Repeat the step for all the layers which contain text. Return now to the perspective effect: select Edit > Transform > Perspective and distort the picture like this (drag down the center of the left border):

Step 8

Use the Rectangle Tool to draw the box margins:

“Rasterize” the layer and apply a perspective effect:

Add another margin to the box:

Step 9

You can now add some details on your product box and some shadow. This is a virtual software box for your product. You can use it on the web site or for multimedia presentations:

Step 1

Create a new document in Adobe Photoshop with the size 400x400 pixels and a white background. Type a text with a red color. I used the text “web” for this tutorial:

Step 2

Duplicate the layer with the text. To do this, right click in the Layers Tab (on the layer which want to duplicate) and choose Duplicate Layer. Set the “Fill” to 0% and add stroke to the new layer; use the next settings for the stroke effect:

And the result:

Step 3

Duplicate the layer “web”. Set the color on the layer “web” to black and move it in the new position like in the next picture:

Step 4

Duplicate the layer and move it; and move it again like this:

Step 5

Duplicate the layer again and add some perspective, change the opacity (to create a drop shadow effect) and you have a nice 3d text:

Step 6

You can now add a texture on your text or other effect:

Step 1

In this tutorial you will learn how to draw some 3D tubes using just Adobe Photoshop. Open Photoshop and create a new document with the size 400x400 pixels. Set the background color for layer “background” to black. To do this set the “foreground color” to black in the Tools Tab, then select the Paint Bucket Tool (G) in the same tab and just click on the document. The background should be black now.
Now select the Rectangle Tool in the Tools Tab and draw a rectangle like here:

Step 2

Add some kind of 3D effect to the rectangle. To do this thing, add a gradient overlay effect on the rectangle: select Layer > Layer Style > Gradient Overlay and use the next settings when apply this effect:

Step 3

Draw an ellipse on the top of the rectangle like here:

Step 4

Duplicate the layer which contains the ellipse. Right click on the layer with the ellipse in the Layers Tab and choose Duplicate Layer. Now we have two layers and the each one contains an ellipse. Select the ellipse on the duplicate layer and resize it like in the next picture. To resize the ellipse select Edit > Transform > Scale (hold down the SHIFT key when resize the ellipse):

Step 5

Now add a gradient effect on this layer (to add more perspective on you tube and create the tube’s interior). To add the gradient effect check step 2 from this tutorial. Use the next settings for this gradient effect:

And your result should be something like here:

Step 6

Create a few more tubes using what you’ve learned in this tutorial. Something like this:

Step 7

Add lighting effect to the background and other elements that you’d like. This is what I’ve got:

Step 1

Create a new Adobe Photoshop document. And draw a rectangle with a black background:

Step 2

“Rasterize” the layer; to do this, right click on the layer in the Layers Tab and choose Rasterize Layer. Now make a selection like here, using the Polygonal Lasso Tool:

Step 3

Use the key combination CTRL+C, CRTL+V to copy and paste the selected area. Apply color overlay to the new layer selecting Layer > Layer Style > Color Overlay. Set the white color in the window which appears and adjust the position of the new layer to be in the upper left corner of the rectangle, like here:

Step 4

Right click on the layer “layer 1 copy”, in the Layers Tab, and select Duplicate Layer. On the new layer apply the color overlay effect and set the color to grey. Flip the layer horizontal and vertical. To do this step select first Edit > Transform > Flip Horizontal and then Edit > Transform > Flip Vertical. This is the result:

Step 5

Duplicate the first layer and set the color overlay to black. Delete an small area like in the next picture, using a small brush like “Soft Rounded 20 pixels” and set the opacity to 30% in the Layers Tab:

Step 6

Select the layer “shape 1” and duplicate it. Set the color overlay to white, delete an area with a “soft rounded brush 155 pixels” and set the opacity in the Layers Tab, for this layer, to 62%. Move this layer one pixel up and one pixel to the left:

Step 7

Above of the layers draw a horizontal line with white color:

Set the opacity to 50% and make others like here:

Step 8

Link the layers in the Layers Tab and rotate all these layers like here:

Step 9

Apply other elements on your icon and that’s all:

Step 1

Create a new document in Adobe Photoshop with the dimensions 200x100 pixels and a white background. Draw a rounded rectangle with a light grey color.

Step 2

Select Layer > Layer Style > Drop Shadow to apply the drop shadow effect. When applying the effect use the next settings:

Step 3

Apply the inner shadow effect on your layer. To do this select Layer > Layer Style > Inner Shadow and set the next settings in the window which appears:

Here is an intermediary result:

Step 4

Draw another rectangle, like in the next picture, with a white color and “rasterize” it. To make this step choose your layer in the Layers Tab and select Rasterize. Now you can work better on this layer:

Step 5

Using the “Polygonal Lasso Tool” (find it in the Tools Tab) make a selection like in the next picture (make this selection on the last rectangle that you drew, the white rectangle):

Using the DELETE key delete the selected area:

Step 6

Select a small brush in the Tools Tab, like “Soft Rounded 45 pixels” and delete the bottom corners of the white polygon like here:

Set the “Opacity” to 50% in the Layers Tab:

Step 7

Draw another rectangle with a white color and place it in a position like here:

Set the “Opacity” of this layer to 12%, and the result should be something like this:

Step 8

Select the layer “Shape 1” in the Layers Tab. In the Tools Tab select the Horizontal Type Tool and type a text on your button with a grey color:

Step 9

Set a stroke to your text. To do this select, on the layer with the text, Layer > Layer Style > Stroke. Apply the next settings to the stroke:

And another intermediary result:

Step 10

A little bit more color on your text and that’s the result:

Step 1

Open Adobe Photoshop and create a new document with a white background color. Draw a sphere in you document, using the “Ellipse Tool” (find this tool in the Tools Tab). To make the sphere symmetric hold down the SHIFT key when you are drawing the sphere:

Step 2

Select Layer > Layer Style > Drop Shadow to add shadow to your layer. Apply the next settings for this effect:

Step 3

Apply the “Inner Shadow” effect. To do this, select Layer > Layer Style > Inner Shadow with the next settings:

After these two steps the result should be something like this:

Step 4

Create a new sphere with a white color and “resterize” the layer which contains this sphere:

Step 5

Make a selection on this sphere like this:

Delete the selected area and set the opacity for this layer to 25%:

Step 6

Duplicate the layer, resize it and rotate it, move it like below (to make these actions check the Edit options menu):

Step 7

Duplicate the layer “Shape 1” and set the “Blending Mode”, in the Layers Tab, to “Pin Light”:

Step 8

Duplicate it again and set the “Blending Mode” to “Multiply”. Make this step again and this is the result:

Step 9

You can now play with the details and obtain a nice translucent ball:

Step 1

Open the next picture in Adobe Photoshop. Save it first on your computer.

Step 2

Create a new document in Adobe Photoshop with the size 360x600 pixels. Drag the picture which you saved in this new document and place it at the bottom. Draw now a rectangle in a new layer with a light blue color like #7AB5FD; set the “blending mode” for this layer, in the Layers Tab, to “Soft Light”:

Step 3

“Rasterize” the blue rectangle. To do this, right click in the Layers Tab, and select Rasterize Layer. Now, with a small brush like “Soft Rounded 30 pixels”, and delete the area which contain the shadow of the headphones:

Step 4

Duplicate the layer “Layer 1” and delete an area like here with same brush tool:

Add the motion blur effect on this layer. To do this select Filter > Blur > Motion Blur with the next settings:

After these steps your result should be something like this:

Step 5

Select the layer “Layer 1 copy” in the Layers Tab and set the opacity to 72%; move it in the position like here:

Step 6

Duplicate the layer “Layer 1 copy” and apply the motion blur effect with the next settings:

Move the layer in the position like here and set the opacity to 50%:

Step 7

Select the layer “Shape 1” and delete an area like in the next picture, using a “rounded soft brush 100 pixels”:

Step 8

Draw a rectangle, with a yellow color, above all layers, and place it lake here; set the “blending mode” to “Soft Light”:

Step 9

With a “Soft Rounded Brush 200 pixels” delete an area and here’s the result:

Now you can play with the contrast and luminosity, or lighting effect to get this:

Step 1

In this tutorial we’ll guide through the necessary steps for creating a kids website layout with Adobe Photoshop.
Save the next pictures on your computer, if you don’t have others to complete this tutorial:

Step 2

Create a new document in Adobe Photoshop with the size 740x540 and a white background. Import the picture “kids1.jpg” in your document:

Flip the picture horizontal and place it in the position like here (to flip the picture horizontal select Edit > Transform > Flip Horizontal and to move it just drag the picture in the new position):

Step 3

Make a selection using the Rectangular Marquee Tool and use the CTRL+C, CTRL+V key combination to copy and paste the selected area:

Step 4

Select Edit > Transform > Scale and transform the scale of the new layer like here:

Drag the layer “layer 2” below the layer “Layer 1”:

Step 5

Select the layer “Layer 1” in the Layers Tab and delete an area like in the next picture, using a brush like “Soft Rounded 100 pixels”:

Step 6

Add a nice logo to your site:

Step 7

Make a border around the header using a brush like “Rough Round Bristle” with the size 23 pixels, and a dark red color:

Step 8

Import the picture “kids3.jpg” on the scene, resize it and rotate it like here (to resize it select Edit > Transform > Scale and hold down the SHIFT key when making the transformation; to rotate it, select Edit > Transform > Rotate):

Step 9

Duplicate the layer which contains the border, resize it, rotate it and move it in the position like here, above the next picture (drag the layer in the Layers Tab above the layer which contains the picture):

Add the color overlay effect on the new layer; to make this, select Layer > Layer Style > Color Overlay and choose a yellow color in the window that appears:

Step 10

Import the picture “kids4.jpg” on the scene and repeat the step 8 and 9 (resize it and add border to this picture, but this time set the color to green):

Step 11

Repeat the step 10 again, this time for the picture “kids5.jpg” and for the picture “kids2.jpg”:

Step 12

Apply some kind of text on your categories, and a welcome text, and you have a nice layout for your kid’s website: