Well, I've been doing a bunch of Atom content for developerWorks, so they asked me if I would host an Atom and RSS forum to help answer any questions people have, and I'm happy to do that. My XQuery/XPath 2.0 forum has been going pretty well, so they thought they'd have me do another one. Tyler's been in charge of a form to get XForms help, but it's been a little quiet. (Which is too bad, because if people have questions, they'll have his full attention. :)) Apparently, they've also been featuring my XForms Sudoku series on the home page for several weeks, which is unusual. I'm pretty excited about that. They're probably pushing it because of the podcast.
I've done a ton of interviews, but always as the interviewer. Yesterday I got a call asking me to be the interviewee for the IBM developerWorks podcast. They're featuring one of my articles, Use XForms to create your own Sudoku game on the developerWorks homepage this week.
I think I was almost more interested in seeing the interview from this perspective than actually doing the interview. Scott Laningham is really a great interviewer; he's great at putting people at ease, and I learned a heck of a lot from the experience.
And I've never been compared to Buckaroo Banzai before, which was funny. But is it pathetic that I wound up actually referencing my own blog?
I'm very fortunate that a lot of the pieces I write for IBM developerWorks get featured, either on the home page or in the particular "zone" in which they belong. Today I see that The ultimate mashup -- Web services and the semantic Web, Part 5: Change out Web services is on the home page. I'm particularly proud of this series, which introduces people to all kinds of concepts, from the Semantic Web to RDF and ontologies, which I find absolutely fascinating. Maybe it's the puzzle-solver in me, but the idea of trying to reconstruct the structure of information and how different pieces relate to each other fascinates me.
It's just an area that I don't feel people are taking seriously enough; this is where we're going, people! You may not like it, and it may be extra work, but somebody's going to figure out a way around that, just you wait.
I've just posted an introductory discusion on JavaScript Object Notation (JSON). What's itneresting about it is it provides away to get around the cross-domain issues you get when you try to access web services using Ajax. Yahoo's now outputting JSON in a ridiculously easy way, so this is worth checking out.
I just posted some remarks on why I think we're seeing the very beginning of the end for Google.
Now available on IBM's developerWorks (and actually, featured on the home page!): Create a problem determination scenario from scratch:
This tutorial chronicles the building of an autonomic computing system that monitors a Java application to demonstrate the ability to detect and resolve issues within the system, a problem determination scenario. In the autonomic computing world, a problem determination scenario is one in which you can demonstrate how an overall system can detect, diagnose, and resolve problems. The Problem Determination Scenario, which you can download from the developerWorks Autonomic computing content area, is an example of a system that does just that by showing you how you can use the various pieces of the Autonomic Computing Toolkit together. In this tutorial, you can follow along and create each piece of our own simple problem determination scenario, which will give you an in-depth understanding of key autonomic computing concepts by using the Generic Log Adapter Runtime and Rule sets, the Resource Model Builder, and the Autonomic Management Engine.In other words, it tells you how to build a system that fixes itself.
Technorati tags: Autonomic Computing | IBM
Now live on DevSource -- Creating a GUI Feedreader using C++, Part 1: A No-Brainer Guide to UML: "If you've never used the Uniform Modeling Language (UML) before, it can seem a little intimidating. However, UML is actually not all that difficult, once you get to be familiar with the different diagrams and how they can help you to model and document your project. This article takes you through the process of modeling an application using UML, explaining each of the different diagrams, and the basics of how they work. When you're done, you'll have enough of an understanding of UML to document your own project. You'll also have enough of an understanding to delve into UML's finer points without feeling overwhelmed."
Note that this is also the first article chronicling the development of ChaosCrusher, an RSS/Atom/syndication feedreader that will hopefully do what I want a feedreader to do.
Almost a year ago, I wrote about what I want in an RSS aggregator, and now, as I actually write one in C++ (see, I told you I was doing it) I've gone back and found that all of those requests are still valid. And I still don't see anybody doing all of it.
I've actually got a pretty good track record of seeing trends as they're coming along, but I've never before been forced to actually write my predictions down. This year, all of us InformIT guides took it upon ourselves to document our predictions for the coming year. I sweated over mine for about 3 days, and I'm actually pretty happy with the results. (We'll see how happy I am in 11 months. :)) They're posted in the guide itself, but I've also reposted them in the blog, as Predictions for 2005, part 1 and Predictions for 2005, part 2. I wish I could have gotten them all in one posting, but there it is.
Now featured on IBM developerWorks -- Use the GLA with the Log and Trace Analyzer with Release 2 of the Autonomic Computing Toolkit: The GLA and LTA are Eclipse-based tools that enable logs to be parsed for occurrences of pre-defined events, relate those events to situations, and recommend actions based on information in a knowledge base. This tutorial is of particular interest to developers and administrators of applications with dependencies on multiple servers, such as DB2, Apache, and WebSphere. The key lesson imparted here is how to use the GLA to create your own adapter for custom application logs. Additionally, the tutorial introduces the underlying elements of the log adapter process. These low-level enablers of autonomic computing systems are an important contributor to the creation of more autonomic computing systems. This tutorial takes you through an example of how high-level open standards, such as the Common Base Event description, can be incorporated into development and administration functions at a practical level.
My article, Working With Avalon Today: Getting started with XAML, has been posted on DevSource. The blurb:
I'm just to blasted tired to elaborate at the moment, so if you don't already know that I've written more tutorials for IBM than ... well ... just about anybody -- I think Doug Tidwell has edged me out, but that's about it -- you'll just have to take my word for it.
This weekend I gave a presentation at the Florida Association of Computer Users' Groups conference, which was quite enjoyable. I'll elaborate later, but for those of you looking for the link to that presentation I promised you, here it is.
More later...
I've been trying to catch up on my InformIT blog, and consequently have also been catching up on The Vanguard Science Fiction Report. Here are some things I've been talking about:
InformIT:
Mosh Ado About Nothing
A library of regular expressions
The Enterprise Service Bus
Feed of the week: The Open Source Vulnerability Database
The Vanguard Science Fiction Report
The Asimov legacy is safe
Hawking changes mind on alternate universes
Jerry Goldsmith dead at 75
Now on developerWorks, Tip: Use XForms to send and receive Web services messages: "One of the great strengths of XForms is the fact that an XForms client can send its data as XML, and that it receives XML in return. This capability can be exceptionally useful in the field of Web services, where that's exactly what gets sent and received: XML messages. In this tip, I'll look at how to use an XForms browser as a Web services client, sending a SOAP request and displaying the results directly in the browser."
Now featured on developerWorks: Using the Generic Log Adapter with the Log and Trace Analyzer
The GLA and LTA are Eclipse-based tools that enable logs to be parsed for occurrences of pre-defined events, relate those events to situations, and recommend actions based on information in a knowledge base. This tutorial is of particular interest to developers and administrators of applications with dependencies on multiple servers, such as DB2, Apache, and WebSphere. The key lesson imparted here is how to use the GLA to create your own adapter for custom application logs. Additionally, the tutorial introduces the underlying elements of the log adapter process. These low-level enablers of autonomic computing systems are an important contributor to the creation of more autonomic computing systems. This tutorial takes you through an example of how high-level open standards, such as the Common Base Event description, can be incorporated into development and administration functions at a practical level.
Now on developerWorks: Understand the Autonomic Management Engine
"The idea of an autonomic computing system is attractive -- who wouldn't want a system that knows what to look for, and what to do if it finds it? But, building one from scratch is too much of an undertaking for most shops. Fortunately, the Autonomic Management Engine simplifies the process. This tutorial explains how AME works and shows you how to embed it into one of your own applications."
This is actually pretty cool. Well, I think so, anyway. :)
Now on developerWorks -- The making of MetroSphere, Part 30: Overcome cross-site scripting limitations:
Unfortunately, not everyone on the Internet has good intentions. To prevent users from entering malicious code into submitted material, the designers of WebSphere Portal disabled the ability to submit HTML to the Portal through a Web form. This article explains how you can selectively allow HTML in user-submitted material.
Now in the XML Reference Guide over at : DOM and PHP
PHP has support for XML built in, but as far as production code, it's limited to SAX. You can install the DomDocument module, but you do, of course, have to have access to the actual server in order to use it. Fortunately, for those of you who, like me, use an external web server and don't have that kind of control, there's a simple way to get Document Object Model functionality. ...
This must be my week for being featured! Domino applications and the Portal API was featured in this week's IBM Portal News:
Lotus Domino is great for storing all sorts of information in one place, and WebSphere Portal is great for gathering information from all sorts of places. But how do you get the two of them together? One option is to directly incorporate your Domino data into your portal application using the WebSphere Portal API. This tutorial details the process for reading from, and writing to, a Domino database from within a portlet.
Now featured on the developerWorks home page: The making of MetroSphere, Part 29: Understand the web.xml and portlet.xml files
With all of the magic that goes on in the WebSphere® Portal Web interface, it's easy to forget that at its heart, a portlet application is just a collection of servlets and their supporting classes, strung together using the web.xml and portlet.xml files. As we moved to customize the MetroSphere.com experience, we realized that understanding just how these two files fit together was crucial to controlling items such as the initial title of a portlet window. This article explains the major pieces of these two files and how they control what you see in your portlet application.
I've been publishing for IBM for a couple of years now, so I don't even blink when they feature an article of mine, but this
is really cool. Last summer, I took a trip to Austin Texas to sit in on a session of IBM engineers talking about their brand new Autonomic Computing initiative. I came home and proposed about 15 articles and tutorials and such. Or was it 25? I can't remember now. It's been such a long road to get here -- I didn't write all of the pieces, but I've been involved in most of them in one way or another -- but it's still cool to see my "vision" out there for people to see.
Now the featured story on developerWorks: A quick tour of autonomic computing
Autonomic computing architecture is a range of software technologies that enable you to build an information infrastructure that can, to lesser and greater degrees, manage itself, saving countless hours (and dollars) in human management. And all this without giving up control of the system. This tutorial explains the concepts behind autonomic computing and looks at the tools at your disposal for making it happen -- today.
Now on InformIT in the XML Reference Guide: Java in XSLT: Extension Functions
Using XSLT to transform XML into another form has a lot of advantages, not the least of which is flexibility. When you want to change the output, you don't have to go back to the code, you simply have to change the XSLT style sheet. But it's easy to mistake this simplicity for shallowness. XSLT can enable you to do much more than simply reformatting text.
In the InformIT XML Reference Guide: DOM and Perl
Perl was originally designed as a lnaguage for sorting through text, so it's not surprising that it is a good fit for XML. In fact, there are multiple ways to handle XML using Perl, so in this section we're going to look at manipulating DOM "objects" using the Perl XML::DOM module, available on CPAN. ...
Now updated on developerWorks: Integrating applications with Web services using WebSphere Studio V5.1.1: "This tutorial looks at making your application Web-services ready using WebSphere Studio's tools to wrap an existing application as a Web service, announce it using a UDDI directory, and to discover and use Web services within your applications. It also looks at how to deploy your application to a WebSphere Application Server."
In the InformIT XML Reference Guide: .NET and XMLReader
In the world of XML, it's natural to think of XML in terms of two contexts: DOM and SAX. DOM is flexible, in that it provides the ability to navigate around the document tree and make changes, but SAX is fast, in that it doesn't load the entire document into memory, looking instead at just a single node at a time in a forward-only, read-only manner. ...
Just posted at InformIT:
Microsoft has announced that it would hold off on the "minor changes" it would need to make to Internet Explorer in order to comply with the adverse ruling it received in the the Eolas case.
This case is the definition of ambivalence for me.
Sigh.
Well, I've finally gotten around to writing about .NET, with a section on DOM and .NET at the InformIT XML Reference Guide. It explains how to create an application in .NET that traverses the Document Object Model of an XML Document object. It uses Visual Basic .NET, but the concepts are the same for C#.
Well, I've finally taken the gloves off and posted a snarky posting to InformIT, What? You mean you can read an XML file from another application?
The scoop? Microsoft is now trying to patent methods for reading an XML file produced by another application as a way to keep companies from building competing products that read a Word file.
But I've dropped my usual objective demeanor on this one. Let's see if anybody notices or -- gasp -- comments on the InformIT blog. I hope so.
OK, the first posting from the list is up. News from the world of DSDL incorporates items number 2, 3, 4 and 5 and talks about Document Schema Definition Languages, which aims to make it easier to validate documents that have data from more than one namespace, such as a SOAP envelope or an XHTML document with SVG embedded within it.
I understand that there are people who read all of the blogs on their blogroll every day, or at least, every few days. And they even find time to comment on them. I want to know who these people are and how they manage to make a living.
I have, in essence, three blogs that I am supposed to be updating on a regular basis. I'm supposed to do at least three blogs a week for the XML Reference Guide, I've got this one, and I've got The Vanguard Science Fiction Report, which has been fallow so long I'm embarrassed to admit that it's mine. So today, now that the weeks of emergency room visits and surgeries in the family have settled down into the normal level of chaos, I sat down and went through my blogroll for potential posting material.
I thought it might be a little educational to document the "flow" of my surfing, and how it eventually gets turned into actual postings, so here is the list of the "first cut". These are postings that may eventually wind up on one of my three blogs:
And some XML tools mentioned on Cafe Con Leche:
Even I can't believe how long the list is.
As you can see, it's a rather eclectic group, but it also shows the pattern of how I surf. (Note that I didn't even touch Op-Ed News today, because I know I have enough material for this blog, which is the only place it belongs, or the W3C because I've adopted a "monthly" schedule for them on InformIT.)
Over the next week or so, you can see what makes the cut and what doesn't, and what leads to other things.
So I posted over at InformIT about How to survive the changes to IE.
So what are the actual changes? Well, it turns out to not be as bad as originally thought. The patent covers the automatic loading of an application that resides on a remote server, so a page either needs to avoid automatically loading the application or loading it from a remote server. For the former, IE will pop up a window asking the user to click a button to load the Active X control. For the latter, Microsoft has guidance on embedding the data directly into the page so that it doesn't actually have to be loaded remotely. They also provide a look at using JavaScript to create the object tag in such a way that the patent isn't violated, but you don't have to jump through a hundred hoops to keep the dialogue box from coming up.
What I want to know is: how does this embedding affect security? Is it possible that slimebags are currently embedding the code in the page to avoid warnings about downloading controls?
More fodder for discusson on InformIT: Technology, social norms, and why it matters
Does technology shape us, or do we shape technology? Or is it a little bit of both? I think there's an inexorable cycle, in which we find ourselves rocked by a new paradigm, then adjust to it as though we'd never lived without it, and then start all over again. For example, take just the last century or so. We started out terrified of electricity "leaking" out of wall sockets. Then, of course, we couldn't get along without it. Then came radio, and television. Once we were good and settled in there, we got computers. Then the Internet. Then the World Wide Web. (No, those last two are not the same.)
At the end of December, I wrote about The evils of escaped markup as seen by Normal Walsh. It was a well-though-out piece about why he doesn't like that people are using CDATA sections to escape potentially non-well-formed content, particularly in data feeds.
But the interesting thing to me is that I'd actually already written about this particular topic -- and in fact, this particular piece of Norman's -- last summer.
So far, nobody has noticed. Or if they have, they haven't commented.
I'm considering thinking of something completely ridiculous and controversial to say just to see if anybody notices. Suggestions welcome.
In the InformIT XML Reference Guide: DOM and .NET
With XML so fundamental in Microsoft's .NET framework, it should come as no surprise that the ability to manipulate an XML document is built right into the system. In fact, although DOM Level 2.0 doesn't include a standard way to create or save a document, .NET makes it easy. In this section, we'll get a feel for how these manipulations work by using Visual Basic .NET to load a simple document, make some changes to it, and then save it back out to a file. (We'll be running directly from the command line, so if you're not familiar with GUI programming, don't worry.) ...
Over on my InformIT XML blog, I've noted that XML 1.1 is almost here, and not everybody is happy about it. Elliotte Rusty Harold specifically says "Don't use it."
Also, on a more lighthearted note, I've also noted over at the Vanguard Science Fiction Report that:
Now on developerWorks: DOM NodeFilters and XML data binding: Using a DOM NodeFilter lets you control the contents of a set of XML data without touching the base application, but the NodeFilter itself is still a class, and needs to be recompiled in order to make any non-trivial changes. This tutorial explains how to build a system that enables a user to control both the criteria for a report and the structure of that criteria simply by providing XML input, either through a file or through a web service, using XML Data Binding.
Now on developerWorks: Grab headlines from a remote RSS file: This article shows you how to retrieve syndicated content and convert it into headlines for your site. Since no official format for such feeds exists, aggregators are often faced with the difficulty of supporting multiple formats, so Nick also explains how to use XSL transformations to more easily deal with multiple syndication file formats. (This was actually published in September.)
Now on developerWorks: Making of MetroSphere, Part 24: Giving the user control - the ultimate portal theme: The heart of the MetroSphere site is the community weblog, but we also want to give users the ability to create pages that reflect their own personalities. Portal enables an administrator to add a new theme to the site, but because allowing users to add a new theme involves unacceptable security risks, built-in capabilities limit user control to selecting from available themes. This tutorial explains how to give users much of the same power they would have by creating a new theme without actually creating one.
Now on developerWorks: The making of MetroSphere, Part 23: Send messages between portlets: Sometimes, in the development of a portal, you need two portlets to talk to each other. For example, on MetroSphere, when the user clicks a topic in the Topic List portlet, the team needs the information to be sent not only to the Topic List portlet, but also to the Show Blog portlet. This portlet describes the process for sending messages between portlets and recording the information in the PortletSession object.
Now on developerWorks: The making of MetroSphere, Part 22: Set topics -- custom attributes and user sessions: In Part 21 of this series, Nick showed you how to add a custom attribute to users' information that represented their preferred topics. In this article, he shows you how to use that custom attribute as well as session information to enable users to choose between showing all topics and showing only their preferred topics.
I can't believe that this is only part 21 of this series. Feels like I've done a hundred of them. And this one was done months ago!
The making of MetroSphere, Part 21: Create custom user attributes: There comes a time in every portal's life when it needs to know something specific about its users in order to provide the best possible user experience. On the MetroSphere site, that point came when the team needed to determine the topics in which a particular user was interested so they could use them to "narrow down" the blog entries with which he or she was presented. This article explains how to create custom user attributes for the user to enter during registration and how to use them from within a portlet.
As if trying to figure out where to buy a book based on online and offline discuounds weren't confusing enough, Borders wants to take prices off books so the retailers can decide what they're worth.
It almost sounds good, when they talk about the ability to lower prices on new authors and such, and the ability to reverse buyer's tendency to buy books only on sale. Then you realize that it also means that retailers in without much competition can raise prices above their already ridiculous level.
Now on IBM developerWorks: Understanding SAX (Tutorial) -- This tutorial examines the use of the Simple API for XML version 2.0.x, or SAX 2.0.x. It is aimed at developers who have an understanding of XML and wish to learn this lightweight, event-based API for working with XML data. It assumes that you are familiar with concepts such as well-formedness and the tag-like nature of an XML document. In this tutorial, you will learn how to use SAX to retreive, manipulate, and output XML data.
Now in IBM developerWorks: Understanding DOM (Tutorial) -- Even before there was XML, there was the Document Object Model, or DOM. It allows a developer to refer to, retrieve, and change items within an XML structure, and is essential to working with XML. In this tutorial, you will learn about the structure of a DOM document. You will also learn how to use Java technology to create a Document from an XML file, make changes to it, and retrieve the output.
Now in IBM developerWorks: The making of MetroSphere, Part 15: Making tag libraries available throughout the portal -- This tip from the MetroSphere team takes you through the addition of the blogutil tag library to the MetroSphere portal's registration page. You can apply this when you need to use the tag library outside of a portlet
Now on IBM developerWorks: Tip: Send and receive SOAP messages with SAAJ -- In this tip, author and developer Nicholas Chase shows you how to use the SOAP with Attachments API for Java (SAAJ) to simplify the process of creating and sending SOAP messages.
Now on IBM developerWorks: Making of MetroSphere, Part 14: Create a new theme (Tutorial) -- Look and feel are important in Web portal design. Learn how to develop themes -- which provide the look and feel for a group of pages -- and skins -- which provide the look and feel for portlets -- in this tutorial from the MetroSphere team. Topics covered include the creation of a new template theme, installing the new theme, adding WebSphere Portal functionality to the theme, accessing language-dependent text, creating URLs within WebSphere Portal, and creating and installing new skins.
Now on IBM developerWorks: The making of MetroSphere, Part 13: Installing an existing portlet -- In this article, the MetroSphere team obtains a pre-written portlet application from the WebSphere Portal Catalog and installs it in their portal.
Now on IBM developerWorks: Making of MetroSphere, Part 12: Hands-on JSP technology intro: Creating a community weblog (Tutorial) -- This tutorial is for developers who want to learn more about using JavaServer Pages (JSP) technology to build applications. It discusses the basics of JSP components in general, their integration with JavaBeans, and the creation and use of custom tag libraries.
Now on IBM developerWorks: Making of MetroSphere, Part 5: Installing WebSphere Portal Express -- The first step in the MetroSphere project is getting the software installed so we can start working with it. This tutorial explains the necessary hardware and software prerequisites for installing WebSphere Portal - Express, and then explains the information necessary for a Quick Install and describes how that process should work. It also looks at some of the additional information necessary for a Standard Install.
Now on IBM developerWorks: The making of MetroSphere, Part 2: Creating the project plan -- Nicholas Chase describes how the planning process determines priorities and shape the project plan. Whether things will turn out exactly the way the team thinks they will is another story; the first rule of Web development, in the team's experience, is that a site is never quite what you thought it would be when you started out.
Now on IBM developerWorks: The making of MetroSphere, Part 1: Getting on the Express way -- Team Lead Nicholas Chase gives a brief overview of the project and what you can expect out of the series. He also explains why the team's first stop was WebSphere Portal - Express.
Now on IBM developerWorks: The making of MetroSphere, Part 3: Choosing a Business pattern -- Nicholas Chase examines some of the common situations described by IBM Patterns for e-business and explains how you might take advantage of the various cases, some providing application architecture and even sample code to help get a project started. In this article, the team puts the experience of others to work, and applies it to their own project while focusing on Collaboration, Access Integration, and WebSphere Portal patterns.
Now on IBM developerWorks: The making of MetroSphere, Part 8: Moving to WebSphere Portal Enable -- In this eighth part of the MetroSphere.com series you see the differences between WebSphere Portal - Express and WebSphere Portal Enable V4.2 and you see the steps the team took to create the first part of the main MetroSphere portal.
In the InformIT XML Reference Guide: DOM and Java
Because XML is a platform-independant language, using Java to manipulate it seems a natural choice. In fact, more than one DOM (or more specifically, DOM-like) implementation exists for Java, and the tools necessary for working with it have even been built into the language itself as of version 1.4. ...
Now on InformIT.com: Combining XSL Transformation and Applications -- Using transformations in applications is a powerful tool to control content and handle the presentation of your data. Learn how to not only combine style sheets, transformations, and applications to interact with different sources and outputs, but also how to make transformations more efficient and controllable.
Now on IBM developerWorks: Making of MetroSphere, Part 6: Getting started with WebSphere Portal - Express (Tutorial) -- This tutorial is for developers and administrators who want to get familiar with WebSphere Portal in general, and WebSphere Portal - Express in particular. It explains basic concepts such as portlet use and administration, user administration, and the basics of creating portal pages.
Now on IBM developerWorks: Making of MetroSphere, Part 6: Getting started with WebSphere Portal - Express -- This tutorial is for developers and administrators who want to get familiar with WebSphere Portal in general, and WebSphere Portal - Express in particular. It explains basic concepts such as portlet use and administration, user administration, and the basics of creating portal pages.
Now on IBM's developerWorks: Create multi-purpose Web content with XSLT (Tutorial) -- As more and more devices become Web enabled, it is crucial that your content be available in multiple forms, such as traditional Web pages, mobile phones or other small devices, or Web services. This tutorial shows you how to set up a Java servlet that detects the type of display that is necessary and automatically produces appropriate markup for the content that uses XSLT.
In the InformIT XML Reference Guide: Waht is XML?
A cousin of Hypertext Markup Language (HTML), Extensible Markup Language (XML) provides a human-readable, platform-independent way to represent data, whether it's content destined for a web page or brochure, or data destined for an enterprise database.
Like HTML and their mutual parent, Standard Generalized Markup Language (SGML), XML works on the principle of tags, which delineate elements and content. Consider, for example, the following XML document:
In the InformIT XML Reference Guide: Guides
The Simple API for XML, or SAX, was developed by the XML-DEV mailing list. Rather than treating an XML document as a tree-like structure, SAX treats it as a series of events such as startDocument or endElement. To accomplish this, a SAX appllication typically consists of three classes. ...
In the InformIT XML Reference Guide: Guides
The Simple API for XML (SAX) is an event-based model, in which a file is parsed sequentially, and the parser takes note of events such as startElement and endDocument. For example, parsing the following sample document: ...
In the InformIT XML Reference Guide: The Document Object Model
The most common methodology for writing XML programs is the Document Object Model (DOM). DOM looks at an XML document as a series of parent and child nodes of different types. For example, the following simple sample document consists of eight different nodes: ...
Now on IBM developerWorks: SAX-like apps in PHP -- While there is no official implementation of the Simple API for XML (SAX) in PHP, PHP does provide a SAX-like method for working with both local and remote XML files. In this article, author Nicholas Chase shows you how to work with XML files in PHP by building and setting handler functions and creating a parser. He demonstrates SAX in PHP with a page-building exercise in which he crafts a page based on the result of an Amazon Web Services query.
Now on IBM developerWorks: Making of MetroSphere, Part 5: Installing WebSphere Portal Express (Tutorial) -- The first step in the MetroSphere project is getting the software installed so we can start working with it. This tutorial explains the necessary hardware and software prerequisites for installing WebSphere Portal - Express, and then explains the information necessary for a Quick Install and describes how that process should work. It also looks at some of the additional information necessary for a Standard Install.
Now on IBM developerWorks: Integrating applications with Web services using WebSphere Studio V5 (Tutorial) -- This tutorial shows you how to make your application Web-services ready using the tools in WebSphere Studio Application Developer Version 5. You will learn how to wrap an existing application as a Web service and announce it using a UDDI directory and to discover and use Web services within your applications. The tutorial also explains how to deploy your application to a WebSphere Application Server.
Now on InformIT.com: PHP Basics, Part 3: User-Defined Functions and Objects -- In this third article in his series on PHP basics, Nick Chase shows you how to use PHP to create user-defined functions, as well as ways to create and use objects in PHP.
Now on IBM developerWorks: Install and configure Xalan-Java (Tutorial) -- This new tutorial by author Nicholas Chase tells step-by-step how to install, configure, and test the Xalan-Java XSL Transformation processor. Installing Xalan-J involves preparing the environment by obtaining an appropriate Java Virtual Machine, setting environment variables, and installing the files. After installation, you can set other environment variables, such as CLASSPATH.
Now on InformIT.com: PHP Basics, Part 2: Database-Driven Pages -- Part 1 of this series of three articles considered the basics of building a dynamic web page using PHP. This article explores using PHP to interact with a database, including creating tables and inserting, updating, and selecting data.
Now on IBM developerWorks: Tip: Control white space in an XSLT style sheet -- Because the style sheet and the source document in an XSLT transformation have different rules regarding white space stripping, it often seems as though the production of spaces and line breaks has no rhyme or reason in the process. This tip shows you how to control the production of white space in a transformation's result, which can lead to documents that more closely align with your requirements.
Now on IBM developerWorks: Install and configure the Xerces2 Java parser (Tutorial) -- The first step in working with XML is parsing the data into a workable form. This tutorial guides you through the steps necessary to install and configure the Xerces2 Java parser.
Now on IBM developerWorks: Tip: Use imports and includes to override XSLT templates -- Extensible Stylesheet Language Transformations (XSLT) provide two different ways to combine several style sheets in the transformation of a single source document. In the process, it's almost inevitable that more than one template will apply to a single node. Which template is actually applied depends on whether and how the template has been included in the main style sheet. This tip explains how to use these conflict resolution rules to give users control -- but not too much control -- over styling issues.
Now on IBM developerWorks: Tip: Using a DOM NodeFilter -- XML's DOM Level 2 Traversal module provides two new objects, the TreeWalker and the NodeIterator, which simplify the process of navigating a Document. More than that, the module defines a NodeFilter, which can be used to programmatically control what Nodes are visible to the TreeWalker or NodeFilter. This tip shows you how to create a NodeFilter as well as a Traversal object that uses it.
Now on IBM developerWorks: Building an Amazon storefront using SOAP and the WSDK (Tutorial) -- This tutorial is for developers who want to use SOAP to access the Amazon product database through Amazon Web Services (AWS). It shows you how to use the IBM WebSphere SDK for Web Services (WSDK) to create Java classes from the Amazon Web Services Description Language (WSDL) file, demonstrates the use of those classes, and then examines the process of using the WSDK to turn the classes into a Web application and Amazon storefront.
Now on InformIT.com: PHP Basics, Part 1: Creating a Scripted Page -- Learn how to build dynamic web pages with PHP in this three-part series. Part 1 starts you off with an explanation of how to create scripts for your pages.
Now on IBM developerWorks: Tip: Traversing an XML document with a TreeWalker -- XML's Document Object Model provides objects and methods that enable a developer to navigate a document's tree, but typically the process involves NodeLists and recursive methods that make it easy to get lost within the structure. The DOM Level 2 Traversal module provides a new object, the TreeWalker, which simplifies this process and makes navigation more reliable. This tip demonstrates the process of determining whether a TreeWalker is available and how to use it to extract information from a document.
Now on IBM's developerWorks: Understanding XForms (Tutorial) -- Today's Web applications require sophisticated control over a form's presentation and over the data that is ultimately submitted. XForms, currently at the level of Candidate Recommendation status at the W3C, aims to satisfy those needs, including separating functionality from presentation and streamlining validation and events processing.
Now on IBM developerWorks: Tip: Use a SAX filter to manipulate data -- The streaming nature of the Simple API for XML (SAX) provides not only an opportunity to process large amounts of data in a short time, but also the ability to insert changes into the stream that implements business rules without affecting the underlying application. This tip explains how to create and use a SAX filter to control how data is processed.
Now on IBM developerWorks: The Web's future: XHTML 2.0 -- Over the years, HTML has only become bigger, never smaller, because new versions had to maintain backward compatibility. That's about to change. On 5 August 2002, the first working draft of XHTML 2.0 was released and the big news is that backward compatibility has been dropped -- the language can finally move on. So, what do you as a developer get in return? How about robust forms and events, a better way to look at frames and even hierarchical menus that don't require massive amounts of JavaScript.
Now on IBM developerWorks: Building database applications with WebSphere and DB2 (Tutorial) -- One common use for Web services is the enabling of remote access to DB2 database information. Using parts of a simple commodity trading system, this tutorial teaches you how to select from, insert into, and update a DB2 database from WebSphere Studio and from a Java application. You will then convert this application to a Web service with the help of WebSphere Studio. The tutorial also discusses DB2 user-defined functions and stored procedures.
Now in IBM developerWorks: Process XML using XML Query (Tutorial) -- For years developers have been using SQL to retrieve data from structured sources such as relational databases. But what about unstructured and semi-structured sources, such as XML data? To be viable as a data source, XML needed a means for conveniently retrieving the data. XQuery provides this means, allowing developers to write a statement that both extracts data and (if necessary) structures the results as XML. This tutorial shows you how to use XQuery to retrieve information from an XML file. It also explains the ways in which XPath changes with version 2.0, and what those changes mean for data management.
Now on IBM developerWorks: Tip: Make choices at runtime with XSLT parameters -- Extensible Stylesheet Langauage Transformations provide the ability to perform sophisticated manipulation of data as it is transformed from one form to another. You can increase their capabilites even further through the use of parameters that can be specified at runtime. This tip takes a basic look at using parameters and conditional statements in an XSLT style sheet.
Now on InformIT.com: Understanding Java Factories -- How do factories work, and how can you use them in your own applications? Create two different "ferrets," and see how using a factory allows you to choose which one is actually loaded at any given time.
Now on developerWorks: Using HTML forms with PHP
One of the advantages of PHP has always been the ability to easily manipulate information submitted by the user through an HTML form. In fact, PHP version 4.1 adds several new ways to access this information and effectively removes the one most commonly used in previous versions. This article looks at different ways to use the information submitted on an HTML form, in both older and more recent versions of PHP. It starts out by looking at individual values and builds to a page that can generically access any available form values.
Now on IBM developerWorks: Tip: Include external information with general entities -- General entities enable XML authors to conveniently include not only characters that would be difficult to represent directly, but also information that must be repeated. They also enable you to import information from another file, as well as from another location. This tip shows you how to include external information through the use of general entities.
Now on IBM developerWorks: XML Schema validation in Xerces-Java 2 (Tutorial) -- XML Schema provides validation capabilities that weren't available with Document Type Definitions. Xerces-Java 2.0 provides virtually complete support for the W3C's XML Schemas, and beyond. This tutorial guides you through the process of using schema validation with Xerces-Java 2.0.
Now on IBM developerWorks: Tip: Customize a DTD with parameter entities -- Creating a Document Type Definition (DTD) and using it to validate your document is a good way to ensure that the data fits a particular structure. In some cases, however, you want to give users some control over the structure. Parameter entities enable you to create a structure that allows a document author to choose from two or more possible DTD structures without giving that person control over the actual DTD.
Now on developerWorks: JavaScript and the Document Object Model: While the Document Object Model (DOM) is perhaps best known in its role as a foundation for working with XML, variations on the theme actually started in browsers with HTML. Now DOM has come full circle as newer browsers implement the W3C Document Object Model through client-side scripting, such as JavaScript. This article looks at the JavaScript approach to DOM and chronicles the building of a Web page to which the user can add notes and edit note content.
Now on IBM developerWorks: Tip: XSL transformations to and from a SAX stream -- The Transformation API for XML (TrAX) simplifies the process of performing XSL transformations by creating a situation where you only need to create the source, style, and result objects, then manipulate them using a Transformer object. When sources and results are DOM nodes or files, it's easy. But what if you want to transform to or from a SAX stream? This tip shows you how to use SAX streams as both the source and destination of an XSL transformation.
Now on IBM developerWorks: Tip: Stop a SAX parser when you have enough data -- A SAX parser can be instructed to stop midway through a document without losing the data already collected. This is one of the most commonly mentioned advantages of a SAX parser over a DOM parser, which generally creates an in-memory structure of the entire document. In this tip, you'll parse a list of recently updated weblogs, stopping when you've displayed all those within a particular time range.
Now on IBM developerWorks: Introduction to ebXML (Tutorial) -- Whereas EDI for years has provided a usable but expensive way for companies to exchange information in an automated manner, ebXML now provides a means for companies to integrate their processes much more easily. Based on XML, it provides a methodology for business to determine what information they should exchange and how, as well as a set of specifications to allow automation of the process. This tutorial gives an overview of ebXML, explaining how all of the pieces fit together.
Now on IBM developerWorks: Integrating applications with Web services using WebSphere (Tutorial) -- The Site Developer configuration of WebSphere Studio and WebSphere Application Server ease the pain of integrating Web services with your application. This tutorial looks at making your application Web services-ready using Site Developer's tools. It takes you through the process of wrapping an existing application as a Web service, announcing it using a UDDI directory, and discovering and using Web services within your applications. It also looks at how to deploy your application to a WebSphere Application Server.
Now on IBM developerWorks: Building Web service applications with the Google API (Tutorial) -- The Google search engine can now be accessed via a SOAP-based Web service. This means that developers can now embed Google search results and other information into their own applications. Google also took this project one step further, creating an API and Java toolkit for accessing the data. This tutorial is for developers who want to use Google information from within their Java applications.
Now on InformIT.com: Using JavaScript with XSLT Style Sheets -- Learn to use XSLT style sheets to transform XML data from one from one structure to another.
Now on IBM developerWorks: Tip: Outputting HTML from an XSL style sheet -- Because HTML is so similar to XML, it should be fairly straightforward to create an XSLT style sheet that outputs HTML. Unfortunately, the differences between HTML and XML that do exist can cause pages to be displayed incorrectly in older browsers. This tip discusses those differences, and explains how to use XSLT's output element to resolve the issues they create.
Now on IBM developerWorks: Tip: Set an XSL style sheet based on XML content -- Using Extensible Stylesheet Language Transformations (XSLT) is often the easiest way to transform your XML data from one form into another, as it allows you a great deal of flexibility without having to change an application. On occasion, however, you may run into a snag because the style sheet to be used is based on the content of the document itself. This tip discusses two ways to base your choice of style sheet on the XML document -- the style sheet processing instruction and the data itself.
Now on IBM developerWorks: Tip: Call JavaScript from an XSLT style sheet -- XSLT style sheets allow you a great deal of freedom in manipulating the data in your original XML document. There are times, however, when you really want to do actual programming, and the XSLT recommendation is designed to allow that through the use of extensions. These extensions take the form of functions and elements, and can be written in any language the processor supports. One of your options is to embed JavaScript within the style sheet, either directly or as an external file.
Now on IBM developerWorks: Developing XSL Transformations with WebSphere Studio (Tutorial) -- This tutorial shows you how to use the Site Developer configuration of WebSphere Studio to map the elements and attributes of one XML structure to the elements and attributes of another, then convert that mapping to an XSLT style sheet. The tutorial will demonstrate how to use an XSL Trace facility to watch the actual progress of the transformation and locate errors. This tutorial will also cover how to add XSLT functions, external JavaScript functions, and Java classes to the style sheet.
Now on IBM developerWorks: Tip: Send and receive SOAP messages with JAXM -- In this tip, author and developer Nicholas Chase shows you how to use the Java API for XML Messaging (JAXM) to simplify the process of creating and sending SOAP messages.
Now in IBM developerWorks: Manipulating XML and SQL data with WebSphere Studio (Tutorial) -- This tutorial covers the basics of XML development with WebSphere Studio Site Developer, including how to create and edit new XML files, how to generate DTDs or XML Schemas from an existing XML file, and how to generate an XML file from an existing DTD or schema. The tutorial also looks at the relationship between XML and databases by examining Site Developer's applicable features in this area, including its ability to generate XML files from SQL statements and create mappings of XML data to a relational database structure for use by other applications such as application servers.
Now on IBM developerWorks: Introduction to Scalable Vector Graphics (Tutorial) -- Scalable Vector Graphics (SVG) makes it possible to specify, using text, graphical images that appear on a Web page. The advantages are many, including the ability to easily generate graphics (such as graphs and charts) from database information, and the ability to add animation and interactivity to graphics. This tutorial demonstrates the concepts necessary for building SVG documents, such as basic shapes, paths, text, and painting models, and also animation and scripting.
Now on InformIT.com: Using XML and XSLT to Personalize a Web Site Part 4: Dynamic Style Sheets and User Customized Layout -- XSL Transformations provide a handy means for converting XML data to HTML pages, allowing you to store your content in its most flexible form and still have complete control over its display in the user's browser. Part 4, the final part in this series on Web site personalization by Nick Chase, shows you how to build style sheets dynamically, allowing users to choose what content appears on their pages, and where.
Now on InformIT.com: Using XML and XSLT to Personalize a Web Site Part 3: Allowing Users to Choose Look and Feel -- XSL Transformations provide a handy means for converting XML data to HTML pages, allowing you to store your content in its most flexible form and still have complete control over its display in the user's browser. These and other issues are discussed in this third article on Web site personalizations by Nick Chase.
Now on IBM developerWorks: JavaScript floating objects (Tutorial) -- This tutorial is targeted at Web developers who want to create objects, such as images and menus, that hold their place (or float) in the browser window even when the user scrolls or resizes the window.
Now on InformIT.com: Using XML and XSLT to Personalize a Web Site Part 2: XSL Transformation Stylesheet Basics—Creating XHTML from XML -- XSL Transformations provide a handy means for converting XML data to HTML pages, allowing you to store your content in its most flexible form and still have complete control over its display in the user's browser. This article, which is the second in a series on Web site personalizations, shows the basics of XSL Transformations and discusses the basic techniques you need for any transformation project.
Now on IBM developerWorks: Creating and using JavaScript objects (Tutorial) -- This tutorial is for programmers who wish to take advantage of object oriented programming (OOP) using JavaScript -- either within the browser or on the server side -- by using custom-built JavaScript objects and their properties and methods.
Now on IBM developerWorks: Understanding dynamic positioning (Tutorial) -- This tutorial is designed to assist Web developers who need tight control over the placement of content on their pages, but who understand the need to separate content from presentation in order to improve compliance with standards and ease of maintenance.
Now on InformIT.com: Using XML and XSLT to Personalize a Web Site Part 1: Using XSLT to Transform XML to HTML -- XSL Transformations are a powerful tool in your efforts to provide a customized experience for your users. Using them allows you to take a single XML content file and adapt it to users' preferences. With the addition of a Web server environment capable of dynamically choosing a style sheet or even creating one based on the user's preferences, you have the potential for a powerful personalization system.
Now on IBM developerWorks: Manipulating data with XSL (Tutorial) -- This tutorial explains the basics of retrieving data from a database into a DOM document, transforming the DOM document into a second document, and inserting the data from the second document into the database using updatable ResultSets in Java. (Though the examples are all written in Java, the concepts are the same in any programming language and the tutorial can assist any developer who wants to learn how to manipulate data with XSLT.) Several of the more advanced features of XSLT and XPath are covered, demonstrating some of the ways that XSLT style sheets can be used to emulate the programming capabilities of database stored procedures.
Now on IBM developerWorks: Modularization of XHTML (Tutorial) -- This tutorial is designed for users who need to understand the modularization of XHTML, either to use a subset of XHTML, or to add their own tags to create their own markup language variants.
Now on IBM's developerWorks: Using JDBC to insert data from XML into a database (Tutorial) -- This tutorial is designed to assist Java developers who need to extract information from an XML document and enter it into a database.
Now on IBM developerWorks: Using JDBC to extract data into XML (Tutorial) -- This tutorial is designed to assist Java developers who need to extract information from a database and place it into an XML document.
Now on IBM's developerWorks: Validating XML (Tutorial) -- This tutorial examines the validation of XML documents using either Document Type Definitions (DTDs) or XML Schema. It is aimed at developers who have a need to control the types and content of the data in their XML documents.
Now at IBM's developerWorks: Understanding SAX (Tutorial) -- This tutorial examines the use of the Simple API for XML version 2.0, or SAX 2.0. It is aimed at developers who have an understanding of XML and wish to learn this lightweight, event-based API for working with XML data. It assumes that you are familiar with concepts such as well-formedness and the tag-like nature of an XML document. In this tutorial, you will learn how to use SAX to retrieve, manipulate, and output XML data.
Now at IBM's developerWorks: Understanding DOM (Tutorial) -- Even before there was XML, there was the Document Object Model (DOM). The DOM allows a developer to refer to, retrieve, and change items within an XML structure, and is essential to working with XML. In this tutorial, you will learn about the structure of a DOM document. You will also learn how to use Java to create a document from an XML file, make changes to it, and retrieve the output.
Now on InformIT.com: Creating an Opt-In Email List with Active Server Pages -- Using Active Server Pages, Nick Chase shows you how to create an Opt-in email list application. Opt-in email lets you send your messages only to those who’ve requested it, and also provides a way for users to get on and off the list, indicate their preferences for content, and even tell you whether they’d prefer HTML or text-based mail.
Syndicate this site |
or add it to | Amphetadesk
|
