Jared Anderson “Live From My Church” EPK from Andy Catarisano/beFree Films on Vimeo.

Jared Anderson_ how He loves from Andy Catarisano/beFree Films on Vimeo.

OFFICIAL-Light Up the World Music Video from Desperation Band on Vimeo.

Deliverables:

• PSD/Interface Design
• Valid CSS/HTML
• jQuery for preloading images and feature section
• Site Optimization

Research Publication View

Deliverables:

• Featured Publications with Flash/HTML/CSS/XML
• Rest-based URLs
• Mootools JS Framework

Open Website:

www.cba.unl.edu/research

Deliverables:

• PSD Re-design/Interface Design
• Valid CSS/HTML
• Print Stylesheet
• jQuery Navigation Integration
• Site Optimization
• Google Map

Open Website:

www.rosemoteldc.com

For now, I’ve posted the presentation. I hope it will spark some interest as it has done for me. I hope to post notes to the presentation in the near future.

1
2
3
4
5
6
7
8
9
10

<employee>
    <employee>
        <firstname>John</firstname>
        <lastname>Smith</lastname>
        <address>123 West Avenue</address>
        <city>Lincoln</city>
        <state>Nebraska</state>
        <zipcode>68588</zipcode>
    </employee>
</employee>

I won’t get into SOAP and web services here. I’ll do that another time. But, if we were to start with XML, it is best to start with the ideas of XML, XSLT, DTD, and XML Schema.

To get into the importance of XML, let first talk about well-formed markup versus validated markup. Well-formed markup means that for every start tag, there is an end tag. Secondly, that all markup is properly nested. Here are couple examples:
Example: Missing Closing Tag

1
2
3
4
5
6
7

    <table>
    <tr>
         <td>John <!-- Missing Closing Tag -->
         <td>Smith</td>
         <td>Lincoln, NE</td>
    </tr>
    </table>

Example: Improper Nested Tags

1

    <p></b>Employee</p></b> <!-- Improperly nested -->

Valid markup says that this set of markup follows these semantic rules. These rules tells you how the markup should be used. They enforce constraints. For instance, the W3C defines semantic rules for HTML. The two popular ones are Strict and Transitional. There are many other validations, but these seem to be widely used.

Now that we understand these two import aspects of XML, the next topics are XML Schema and DTD. XML Schema and DTD enforce validation. There is a difference between the two documents. XML Schema provides higher abstraction to an XML document. Though, a DTD (Document Type Definition) has a narrow use for enforcing constraints and structure.
Example: DTD

1
2
3
4
5
6
7
8
9
10
11
12
13

<!-- Notice: XML, DTD, XML Schema, XSLT start with the XML version and encoding -->
<?xml version="1.0" encoding="UTF-8"?>
 
<!ELEMENT employee (lastname, firstname, address, city, state, zipcode)>
<!ELEMENT firstname (#PCDATA)>
<!ELEMENT lastname (#PCDATA)>
<!ELEMENT address (#PCDATA)>
<!ELEMENT city (#PCDATA)>
<!ELEMENT state (#PCDATA)>
<!ELEMENT zipcode (#PCDATA)>
 
<!--Comment describing your root element-->
<!ELEMENT employees ((employee))>

Creating DTDs are simple. Above are the elements that are expected for the XML document. The Employee has children and for each child there is a specification as “#PCDATA”. This tells the parser that the text inside the tag will be parsed. “#CDATA” says the text will not be parsed.
Example: XML Schema

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:complexType name="employeeType"/>
	<xs:element name="employee">
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="firstname"/>
				<xs:element ref="lastname"/>
				<xs:element ref="address"/>
				<xs:element ref="city"/>
				<xs:element ref="state"/>
				<xs:element ref="zipcode"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
	<xs:element name="firstname" type="xs:string"/>
	<xs:element name="lastname" type="xs:string"/>
        <xs:element name="address" type="xs:string"/>
        <xs:element name="city" type="xs:string"/>
	<xs:element name="state" type="xs:string"/>
        <xs:element name="zipcode" type="xs:string"/>
	<xs:element name="employees">
		<xs:annotation>
			<xs:documentation>Comment describing your root element</xs:documentation>
		</xs:annotation>
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="employeeType">
					<xs:sequence>
						<xs:element ref="employee"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>
</xs:schema>

As you see, XML Schemas are more complex. There is a definition for a sequence for elements and as you can see the root element is defined at the end. Another point to notice is the definition for complex types. A complex type just enforces constraints on an element.

The last component to XML is XML Stylesheets (XSLT). If you look at the example below, HTML markup is embedded into the stylesheet. The “xsl:for-each” tag contains an attribute that selects what data will be placed in its postion as the dataset is rendered and styled for the browser.
Example: XML Stylesheet (XSLT)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:fn="http://www.w3.org/2004/10/xpath-functions" xmlns:xdt="http://www.w3.org/2004/10/xpath-datatypes">
    <xsl:output version="1.0" encoding="iso-8859-1" indent="no" omit-xml-declaration="yes" media-type="text/xml" />
    <xsl:template match="/">
		<html>
		<head>
			<title>Employee Example</title>
		</head>
		<body>
		<table cellpadding="0" cellspacing="0" border="0" width="776" bgcolor="#ffffff">
		<tr valign="top">
	        <td><div style="margin: 5px 5px 5px 5px;">
		<h3>Employees</h3>
                <xsl:for-each select="employees">
                    <xsl:for-each select="employee">
                        Name: <xsl:for-each select="firstname">
                            <xsl:apply-templates />
                        </xsl:for-each>
                        &#160;<xsl:for-each select="lastname">
                            <xsl:apply-templates />
                        </xsl:for-each>
                        <br />Address: <xsl:for-each select="address">
                            <xsl:apply-templates />
                        </xsl:for-each>
                        <br />City: <xsl:for-each select="city">
                            <xsl:apply-templates />
                        </xsl:for-each>
                        <br />State: <xsl:for-each select="state">
                            <xsl:apply-templates />
                        </xsl:for-each>
                        <br />Zip Code: <xsl:for-each select="zipcode">
                            <xsl:apply-templates />
                        </xsl:for-each>
                    </xsl:for-each>
                </xsl:for-each>
	        </div></td>
	        </tr>
	        </table>
		</body>
		</html>
    </xsl:template>
</xsl:stylesheet>

What is shown above are basic concepts to XML. These documents can get long and complicated so therefore I would recommend looking for some software to help you manage these documents. One I would recommend is Altova. Though to use it in the long term, purchase is necessary. Altova does offer a trial period. Altova was very handy in speeding up project completion.

Huddle is a web application for sports teams to document and analyze games either by their games statistics and game video.  This product increases the interactivity between the coaches and their players.  It is a built from Silverlight, WCF, LINQ from the .NET 3.5 Framework.  The development team also used Prototype and Scriptaculous for AJAX calls.  The interesting aspect of this project was that it was designed around scalability and the presentation descibed how the technologies they chose helped them achieve that goal.

When you look at their overall project in Visual Studio, they are designing their application into a 3-tier architecture such as creating object layers like Business, Core, and Data.  Much of their Data layer is LINQ to SQL.  The interface that contains Silverlight and web application for markup and client side scripts is in a separate project.

Windows Communication Foundation (WCF) is one of the major components that makes this product scalable.  With the use of services, Agile Sports development team utiliized AJAX and Silverlight to process and retrieve their data.  The advantages that WCF gave were higher performance, ease of development, code reuse, and services used as a commodity.

WCF can be deployed in different ways.  At the College of Business, I’ve deployed WCF under IIS, but an ideal deployment maybe writing your own console that monitors the connection to the service.  This can bypass the use of IIS and alleviate consuming more resources especially if your services are heavily consumed.  WCF can use different protocols besides HTTP.  Some other protocols to choose from are:

• TCP
• Named Pipes
• MSMQ (Microsoft Message Queuing)
• XML
• Optimized Binary (Binary Version of XML)

WPF (Windows Presentation Foundation) or for the web, Silverlight, was used to annotate on top of game video.  Annotations could also be made in a timeline of the video so step by step notes could be communicated as the play progressed.

The last major component was LINQ to SQL.  Though there were some down sides discovered for LINQ to SQL, LINQ turned out to be of use to the application.  One of the advantages to LINQ was the ability to query data right in the code.  Queries could also be setup as compiled queries to help improve performance.

Some of the downsides or bugs discovered in LINQ at the moment are:

• Inserts cannot be executed on tables without primary keys
• “Order By” is sometimes ignored
• Does not handle many to many relationships across tables
• Joins on tables cannot occur with more than one parameter

When it comes to debugging LINQ, Agile Sports suggested that you utilize SQL Profiler.

Debugging can also be complicated between these different technologies.  You would think that debugging in Visual Studio can be done at the same time.  Though what Agile Sports found that your debugging process is done separately for each JavaScript, Silverlight, and ASP.NET.

The presentation by Agile Sports was very enlightening for those just getting started or in that indermediate stage in working with .NET 3.5.  What Agile Sports shared definitely set the expectations needed for developers to be aware of these technologies how they are benefitual or in their case give them the edge, but also give us the amount of debugging and areas of attention needed to develop an end product.

What was more exciting was to see someone exceed with .NET in taking a business idea and making it into reality.

Related Links:

1. Lincoln .NET Users Group – http://www.lincolndev.net
2. Agile Sports Tech – http://www.agilesportstech.com