2005 2006 2007 2008 2009 2010 2011 2015 2016 aspnet azure csharp debugging exceptions firefox javascriptajax linux llblgen powershell projects python security services silverlight training videos wcf wpf xag xhtmlcss

Introductory 3D WPF Video Demo

The other night I remembered a video I recorded around July 2006 about 3D XAML development in WPF. I never publicly published the video as it wasn't really all that great, so I just used it for internal training.

The videos is an accelerated demo of how you can start using WPF's 3D functionality. There's some errata in the video, so don't go taking notes... just take it as a proof-of-concept and an overall how-to.

Here are the videos...

New XAG Feature - Better Generics

In the original release of XAG, properties could be generic only by using aliases. That is, if you wanted to have a property with a type of "Collection<Item>" you would have to create an alias like this:

using LineItemsCollection = System.Collections.ObjectModel.Collection<XagNewGenericsExample.Item>;


private LineItemsCollection lineitems;

public LineItemsCollection LineItems {
    get { return lineitems; }
    set { lineitems = value; }

which in XAG's markup looked like this:

  <Alias x:Key="LineItemsCollection" Name="Whatever" Type="System.Collections.ObjectModel.Collection[{Type Item}]" />
  <LineItems Type="{Type LineItemsCollection}" />

That's not really a bad deal as it really helps to enforce proper type design. For example, many times I will see people doing this:

public class MyAlias : Collection<Item> {}

MyAlias is NOT an alias for Collection<Item>. Try to compare them in code, they won't match up. However, in the first example "LineItemsCollection" and "Collection<Item>" are the same.

That said, I wanted to add something a bit more flexible. So I wrote an extension markup subsystem for XAG that allows for more complex generics. Here's an example of a property using the new generics system (assuming you have the System.Collections.ObjectModel namespace in):

<LineItems Type="{GenericType Name=Collection, Types=({Type Item})}" />

As you can see it's completely inline. Now here's a more complex example:

<ComplexItems Type="{GenericType Name=Dictionary, Types=(Int32, {GenericType Name=Collection, Types=({Type Item})})}" />

This XAG property translates to the following C# property:

private Dictionary<Int32, Collection<Item>> complexitems;

public Dictionary<Int32, Collection<Item>> ComplexItems {
    get { return complexitems; }
    set { complexitems = value; }

Here's a complete example you can try on your own.

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/" DefaultNamespace="XagNewGenericsExample">
  <Item x:Key="Item" Type="Class" AccessModifier="Public" />
  <ItemSet x:Key="ItemSet" Type="Class" AccessModifier="Public">
      <Import Name="System.Collections.Generic" />
      <Import Name="System.Collections.ObjectModel" />
      <Items Type="{GenericType Name=Collection, Types=({Type Item})}" />
      <ComplexItems Type="{GenericType Name=Dictionary, Types=(Int32, {GenericType Name=Collection, Types=({Type Item})})}" />
So now you an have more complex generic types in your XAG structure.


Using XAG to Create a WCF Service

Here's a good example of what you could use XAG for. Using XAG, the below XML document compiles to a WCF Service Project. It contains an interface, a class implementing the interface, a few data contracts, and all appropriate references.

As you can see, you can include a literal configuration in the XML structure. This will be included as an app.config in your project.

What is XAG? XAG is a new FREE .NET 2.0/3.0 architecture and development tool allowing the creation of entire VS2005 projects in a single XML structure. You can access XAG at http://www.jampadtechnology.com/xag/

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/">
    <Reference Name="System.Runtime.Serialization " />
    <Reference Name="System.ServiceModel" />
  <Folder Header="Data Contracts">
    <Person x:Key="Person" Type="Class" AutoGenerateConstructorsByProperties="True" AccessModifier="Public" Namespace="AcmeCorp.Sales ">
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
        <FirstName Type="String" />
        <LastName Type="String" />
        <Address1 Type="String" />
        <Address2 Type="String" />
        <City Type="String" />
        <State Type="String" />
        <PostalCode Type="String" />
    <CreditCard x:Key="CreditCard" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
        <Number Type="String" />
        <Cvv2 Type="String" />
        <Name Type="String" />
        <ExpDate Type="String" />
    <Item x:Key="Item" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
        <ItemCode Type="String" />
        <Name Type="String" />
        <Price Type="Decimal" />
    <Cart x:Key="Cart" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales ">
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
        <Alias x:Key="LineItemsCollection" Name="LineItemsCollection" Type="System.Collections.ObjectModel.Collection [{Type Item}]" />
        <LineItems Type="{Type LineItemsCollection}" />
    <Sale x:Key="Sale" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization " />
        <Person AccessModifier="Public" Type="{Type Person}" InstantiateObject="True" />
        <CreditCard AccessModifier="Public" Type="{Type CreditCard}" />
        <Cart AccessModifier="Public" Type="{Type Cart}" />
  <Folder Header="Services">
    <IProcessorService x:Key="IProcessorService" Type="Interface" AccessModifier="Public" Namespace="AcmeCorp.ServiceContracts">
        <Attribute Type="ServiceContract" Namespace="System.ServiceModel" Reference="System.ServiceModel" />
        <ProcessSale ReturnType="Void">
            <Attribute Type="OperationContract" Namespace="System.ServiceModel" />
            <Parameter Name="sale" Type="{Type Sale}" />
    <ProcessorService Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Service">
        <Interface Name="{Type IProcessorService}" Namespace="System" />
// Sample Console Application

using System;
using System.ServiceModel;

namespace ConsoleApplication1
    class Program
        static void Main(string[] args) {
            using (ServiceHost service = new ServiceHost(typeof(AcmeCorp.Service.ProcessorService))) {
                service.Open( );
                Console.ReadLine( );
        <service name="AcmeCorp.Service.ProcessorService" behaviorConfiguration="Service1Behavior">
              <add baseAddress="http://localhost:3827/"/>
              <add baseAddress="net.pipe://localhost/"/>
          <endpoint address="" contract="AcmeCorp.ServiceContracts.IProcessorService" binding="netNamedPipeBinding"/>
          <endpoint address="mex" contract="IMetadataExchange" binding="mexHttpBinding"/>
          <behavior name="Service1Behavior">
            <serviceMetadata httpGetEnabled="true"/>
            <serviceDebug includeExceptionDetailInFaults="true"/>

Introducing the XML Assembly Generator

OK, so I'm back... with a gift to the world. For the last month or so I've been working on a project in my spare time that has already been a great help in my architecture and development work. About a month ago I got COMPLETELY fed up with writing code manually and I've always despised UML and graphical code generation systems (like Visio for Enterprise Architects-- I hate Visio anyhow!), but I'm completely addicted to XML and have been for years. What I wanted (demanded!) was a declarative (NON GUI!!!!!) programming tool that allows brainstorms/architectures/projects to be written in pure XML, so that I can think in concepts without having to work directly with code. So, I decided that it was about time that I create a system that will compile a XAML-like structure to a complete VS2005/C# project.

The system has already been a tremendous help to me. In fact, when I got the initial features of the system setup, I used it to create the rest of the system. This helped speed up development because I think in terms of trees, branches organization, and XML. When I was architecting the internal components of the compiler, I was doing all my work in XML using my XAML-like format. Then, when I got a design I kinda liked, I would run it through my compiler (at the time just a console application) and VOOM I got my C# project.

So, as of today, I'm releasing to the public in alpha form under the project-name "XAG" or "XML Assembly Generator". I considered the project-name "XAC" for "XML Assembly Compiler" as it's more of a compiler than anything else... but "XAC"? That's a real name and I found that beyond lame.

Though there is a complete documentation page linked from the XAG start page, here are some of the features that XAG provides.

  • Creation of classes
  • Creation of structs
  • Creation of enumerations
  • Creation of delegates
  • Creation of interfaces
  • Creation of physical folders
  • Creation of custom attributes
  • Creation of type aliases ("using A = B;")
  • Automatic Interface Implementation
  • Usage of Polymorphism
  • Strongly-linked objects (the resource "x:Key" subsystem)
  • Inclusion of properties
  • Inclusion of fields
  • Inclusion of constructors
  • Inclusion of methods
  • Inclusion of events
  • Auto generated constructors for properties
  • Static members
  • ref and out parameters
  • Inline instantiation of properties and fields
  • Inclusion of app.config data
    • I would like to point out a few special features of the system besides what should be obvious. First, I tried to make the syntax as close to XAML as possible, including the concept of resources. So, not only can you create types, but you can strongly-link types together just like you can do in XAML with resources. For example, you can create a class called "Item" and give it a key of "MyItem01" then you can create another class and declare a property using the type referring to the key "MyItem01". XAG will do all the magic for you in finding the real name of the type. This same concept is used for many things including inheritance, interface implementation, and aliasing generics. This helps you keep your structures strongly-linked, so you can ensure that when you want to inherit from a specific class named "MyClass" you get the specific one you want, not another one with the same name, but in a different name space. This also decouples the name of the type from the key. So you can rename the class all day long and not have to update any references. As a side note, just like with WPF/XAML, in order to access a resource, you have to first declare it. I don't think that's too much to ask.

      Second, have you ever created a type with multiple properties and then had to create a constructor to set all the properties? I hate doing that. I appreciate it when it's done (who isn't frustrated at the WPF guys forgetting to do that on their UIElements!?), but still... it just seems like work that should be done for you. C# 3.0 makes this work easier... but XAG simplifies this for you today. So, when you want to create a class with properties that has a constructor to set the properties, simply create the class and the properties and set AutoGenerateConstructorsByProperties to true and BAM, your type will magically have a constructor (in addition to the parameterless one) that maps parameters to properties.

      Third, when compiling the XML to C# (or VB2005 or IL or whatever the destination is--given I add those abilities), XAG looks for compliance to many coding practices. For example, if you try to set a class field to public, the compiler will give a warning and tell you it's changing it to private. I personally hate it when people write code that doesn't obey the .NET coding laws. So, I'm not allowing some of the most common things that lead to screw ups. Also, structs have many rules that are enforced. In fact, structs have more rules enforced than all other types combined. This is not so much for compliance to the .NET coding laws, but, rather, because structs just have more rules than classes. For example, say you have a struct with three instance Int32 fields and you want a constructor. Well, first off, you can't have a parameterless constructor and secondly, if you have a constructor at all, you have to initialize all the fields before control leaves that constructor. When creating constructors, XAG knows about your fields and initializes them for you.

      Here are some sample XML documents that will compile to VS2005 projects:

      The simplest ever:

      <assembly />

      Something a bit more interesting:

      <Assembly xmlns:x=" http://www.jampadtechnology.com/xag/2006/11/ ">
        <MyClass x:Key="MyClass" Type="Class" Namespace="ClassNamespace" />

      OK, that wasn't interesting at all... So, here's one that should explain things a bit better:

      <Assembly xmlns:x=" http://www.jampadtechnology.com/xag/2006/11/">
        <MyClass x:Key="MyClass"
            <Id Type="Int32" />
            <Name Type="String" />
        <MyOtherClass Type="Class" AccessModifier="Public" Inherits="{Type MyClass}" Namespace="ClassNamespace" />

      This last one creates a project with two classes, one inheriting from the other. The first class has two properties and two constructors, one which is parameterless (as you should always have!) and one which takes two parameters and sets them to their respective properties.

      Looking at that, you may think it's too much overhead. Well, this isn't a sissy C# file creator. This thing actually creates the entire project and returns it to you as a single zip file. So, even if you wanted to start a new project, this system will help you tremendously. Simply open the XAG screen, select a template (optional), type in your code, hit Create Project, and you'll immediately get a ZIP file containing all folders, all files, an AssemblyInfo.cs file, and the project file. You will have everything you need to start your solution or to continue your solution by simply adding the XAG project to your existence solution.

      The XAG website also currently has a few tools you may find useful. Not only can you use the initial screen to create your XAG projects, but you can also use it to check for well-formed XML and also to format your XML. The entire website is Ajax based, so responsiveness is unsurpassed. As a side note, in case anyone is wondering, I did all the Ajax code manually as I find it much more efficient than using Atlas, however... I am using Atlas for web service calls to the main compilation server.

      As a warning, I'm still cleaning up the website (it's alpha!) so there may be problems in selling all compilation errors. I'm also redoing major parts of how compiler warnings are displayed, so, for now, there might not be any compiler warnings (it depends on when you look at the site!) Ideally, I would like the system to give a list of compiler errors and warnings to the end user (you!) It does in the console version, but I've yet to completely add that to the website.

      In the future I'll probably be modifying the syntax a bit (and therefore adding a release notes/change log here) and adding a few features and simplifications that I've been meaning to add for a while. For example, I wrote a much more powerful subsystem for generics, but decided that I should hold off on a public release of that to version 2.0. I will also be monitoring the exception logs and fixing bugs as they come up. I'm sure I'll be adding a ton of "if(v != null)" in this initial release.

      You can access this application at http://www.jampadtechnology.com/xag/. You can hit the intro link to see how it works, but it's fairly obvious. Most importantly, PLEASE SKIM THE DOCUMENTATION. I didn't say read it. Only super-geeks with no lives READ documentation. Just skim it and take in the overall idea and syntax. Lastly, please feel free to use any examples in the documentation, documents in the samples section (which I will be expanding upon), or provided templates to start or assist in your usage of the system.


Firefox 2.0 Officially Released!

Firefox 2.0 Officially Released!

The world's most powerful web access system has now been released in a new version: 2.0.

A few of the new features in Firefox 2.0 are:

  • In any text box you now have a SPELL CHECKER! So, if you are typing a comment in a form... you have little red underlines for misspelled words (goodness, I'm seeing them all over this e-mail. I just have to right click and fix it).
  • It's prettier for Mac and Vista people.
  • When you type in the search bar it starts to give you suggestions as to what you may be looking for.
  • Phishing protection -- Phishing is when you go to a website that says "Welcome to eBay! Give us your credit card number to continue service!". Firefox (and well most web browsers now these days) helps protect against that.
  • It handles even MORE powerful websites and intranets (Internet Explorer is finally caught up to 2003).
  • You ever want to restart your computer or just for (some odd reason and hopefully very rare reason) shut your down your computer and want to remember what you were doing? Well, now you can close Firefox and when you reopen it you have the option of continuing right when you left off (thank you Firefox 2.0 spell checker-- I could NOT spell continuing!). So, if you have 9 or so tabs open then you can have them all back when you restart your Firefox 2.0. Opera people have had this for a long time and many Firefox users had an extension that gave them this ability, but now it's finally native.

For those of you who are in a corporate environment (which is just about everyone in my target audience I suppose), to deploy Firefox in your corporate environment you won't want to install Mozilla Firefox directly, but rather, you will probably want to use FrontMotion Firefox. You can get this from FrontMotion's website. As of the time of this writing they haven't released the new 2.0 MSI (how could they... it was JUST officially released!), but in a few days they should have it posted. This Firefox is an MSI version that allows deployment via Active Directory ("AD"), which if very cool and REALLY needs to be native to Firefox anyhow. FrontMotion also provided administrative templates for your Firefox AD deployment. Their mozilla.adm template is a very powerful template allow customization of many aspects of the Firefox internal registry.

As a reminder, you can extend Firefox in any which way you want. I don't mean by using "add ons" in general, but I mean extensions. Don't like something? Fix it... Here are some extensions that I have installed everywhere.

  • All-in-One Sidebar
  • IETab
  • Download Statusbar

FrontMotion will also customize your corporate Firefox to have to extensions that you want in your MSI. What if you want to install Firefox extensions AFTER the MSI install? Well, the way to do that is simple and it does not involve a sissy GUI. Most people think that when you install a Firefox extension it's installed in the entire system. That's not true. Firefox extensions are per profile, not per operating system login nor per system. If you want to install an extension on a system use the following command.

firefox.exe --install-global-extension MyExtensionName.xpi

That will install the Firefox extension globally on the machine. This command is something you can definately package in an MSI yourself and if you know anything about MSI and AD deployment, then you know that you can set prerequisites, which will allow you to deploy the extensions after Firefox 2.0 is installed. Now, as with all properly designed software, Firefox extensions are versioned. Extension are versioned not only to have their own version, but they are versioned to work with specificially tested versions of Firefox (thats actually a Firefox extension development best practice). So, version your Firefox extension MSI packages so that you can tell AD to deploy the new versions as needed.

Given my audience, I think it would be a good idea to make a few statements about about the architecture of Firefox. This week I was at the HDC06 convention and one of the keynote speakers said something to the effect of "COM was never really implemented anywhere else other than in Microsoft operating systems" (that's a super paraphrase). Obviously that's not true... but one place it is definately not true is with Firefox. Internally Firefox has a technology called XPCOM (Cross Platform COM) that looks and feels much like Microsoft's implementation of COM (though a lot cleaner). You have interfaces and you query interfaces... blah blah blah. If you know COM, you know know what I mean.

Firefox also has it's own internal registry kinda like the Windows registry, except it's actually intuitive and it's not yet bloated to the point of complete uselessness. To access the Firefox registry, simply put "about:config" (with out the quotes) in the address bar. This allows you to customize just about anything about Firefox. As with anything, some of the really awesome stuff isn't directly seen in there (i.e. there aren't entries or "keys" for them by default), but the many Mozilla-specific websites have great documentation on how to customize and tweak your web system to your own likings. There's not really any limit to what you can do with the Firefox registry, so any documentation you see will by in some sense be incomplete, though MozillaZine's documenation is great for much of the Firefox registry defaults. You can tweak anything form the lowest geekiest component to something web developer-ish like toggling strict JavaScript mode on (... remember the Option Strict in VB? Same type of thing...) So, you may wanna dive into that depending on your needs (btw, if you see bold entries... that means they have been changed from their defaults or they have been added -- by an extension, by you, or by something else; they just aren't at their default state.) With regard to AD deployment, this Firefox registry type of stuff is what the mozilla.adm AD template will allow you to control in your AD group policy.

Lastly, for those of you have haven't seen my Firefox Web Developer videos, you can view them at the below links. Even though the videos were created using Firefox 1.0, everything in them is still true in Firefox 2.0. In the future I may released more videos, but for now what's posted is all I have prepared. I had one last video in the series , but "something" happened and it got cut in half.

So, if you haven't done so already GetFirefox.com today and help spread the goodness around the world and into your corporation

Links in this Entry

My Firefox Web Developer Video Series Link

Powered by
Python / Django / Elasticsearch / Azure / Nginx / CentOS 7

Mini-icons are part of the Silk Icons set of icons at famfamfam.com