Alex Hoffman

Perspective on development, management and technology

Syndication

News

    Subscribe

    IASA Member

October 2004 - Posts

Why Code Separation in .NET 2.0?

While Amanda Silver of Microsoft demonstrates code separation through partial types in a clip on Channel 9, I remain convinced that this is solely of use to those creating development tools and frameworks.

It therefore, represents a mechanism well suited to Microsoft's pursuit of a tool (model/factory/domain specific language) dominated development world.

For those few developers remaining who actually write code, its likely to just result in hidden code and confusion.

Posted Saturday, October 30, 2004 6:17 PM by Alex Hoffman | 4 comment(s)

Filed under:

PostXING Your Weblog

Chris Frazier has released a free weblog editing tool - PostXING - supporting the Metaweblog API.  It's become my preferred application for creating and editing blog entries.  Thanks Chris.

Posted Friday, October 29, 2004 3:38 PM by Alex Hoffman

Filed under:

Updated: MS Longhorn Release Dates

Updated 23-Jul-06: This topic is now out of date. 

Microsoft Longhorn release dates are now included in the release date summary.

See http://weblogs.asp.net/ahoffman/archive/2004/02/25/79394.aspx

Posted Friday, October 22, 2004 11:16 PM by Alex Hoffman

Filed under:

What is the Zachman Framework for Enterprise Architecture?

Perhaps the biggest challenge facing organizations and those seeking to facilitate systems within them is complexity.  And that complexity has two facets:- content and process.

The Zachman Framework focuses on content by defining the views that provide a holistic perspective of the organization.  It is a classification scheme for descriptive representations of the enterprise. It takes the form of a five-by-six matrix of cells containing the full range of models describing the activities and functions of organizations.

Click to view Zachman framework Graphic

The horizontal dimension of the matrix is structured into six columns according to what framework developer John Zachman calls interrogatives that define the enterprise: what, how, where, who, when, and why. These interrogatives can also be defined respectively as data, function, network, people, time, and motivation.

The vertical dimension is presented in five rows covering the roles played by different actors within the enterprise: the planner, owner, designer, builder, and subcontractor. These actors have corresponding perspectives that are defined as scope, business model, system model, technology model, and detailed representations.

The intersection of each row and column forms a cell containing a specific enterprise artifact. Zachman contends that a fully architected enterprise would have an explicit representation that describes the enterprise's current and future activities related to that cell. He also maintains that all models in adjacent horizontal and vertical cells should be consistent with the artifacts in the cell.

Such a fully described enterprise would have complete alignment of its business mission to its systems implementation, and would be completely efficient in its application of resources, priorities, and processes. Of course, no such enterprise may exist in practice, but use of the Zachman framework to analyze existing problems and guide future plans would lead organizations toward that ideal.

Since its first publication in 1987, the framework has been applied in Global 2000 organizations such as General Motors, Bank of America, and Health Canada, among many others, to structure enterprise architecture programs and initiatives. The Zachman Framework has also spawned a number of other similar frameworks for applying enterprise architecture in specific domains. These include the Federal Enterprise Architecture Framework (FEAF), The Open Group Architecture Framework (TOGAF), and the Department of Defense Architecture Framework (DoDAF).

In addition to Zachman's own Zachman Institute for Framework Advancement (ZIFA) organization, whose mission is to further the conceptual and implementation understanding of enterprise architecture, a small industry of consultants, educational services, software companies, and publishers has sprung up to support the Zachman methodology (see links at bottom). In November, the EA Interest Group (EAIG) formed to drive the development and continuous improvement of a common reference for enterprise architecture based on the Zachman Framework.

Enterprise Architecture Sites

Fawcette Enterprise Architecture

Software Productivity Consortium

Zachman Framework

Zachman Framework Graphic

The Zachman Institute for Framework Advancement (ZIFA)

TOGAF

OMG TOGAF Home Page

TOGAF - Frequently Asked Questions

Posted Thursday, October 21, 2004 8:45 PM by Alex Hoffman | 1 comment(s)

Update: displaying the Gmail ATOM feed in your Web Browser

Update: you can download the script here and the script engine here. If your Gmail account name contains a 'dot', you should use the /a command line switch e.g. axscript /a:myaccount,mypassword gmail.csx

Transforming the Atom feed XML returned from Gmail to HTML and displaying the result in your web browser - makes the previous example somewhat more useful.

One way is to create a small transformation function (using a XSLT document like that provided by manalang.com) say in C#, and save it as xml.cs ...

// xml.cs
using System;
using System.IO;
using System.Xml;
using System.Xml.Xsl;

public class XML
{
    // an atom 0.3 transformation style sheet
    public static string AtomXsl =
            @"http://manalang.com/wp-content/atom03.xsl";
   
    // transform xml using a transformation document
    public static string Transform(string xmlDoc, string xslDoc)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(xmlDoc);
       
        // transform
        XslTransform transform = new XslTransform();
        transform.Load(xslDoc);
       
        StringWriter writer = new StringWriter();
        transform.Transform(doc, null, writer, null);
       
        return writer.ToString();
    }  
}

Then replace the print(feedAsXML) line at the bottom of gmail.vb with the following code ...

' transform the atom xml feed to html
feedAsHtml = XML.Transform(feedAsXml, XML.AtomXsl)

' write the html to a temporary file
tempOutputFile = Path.GetTempFileName() & ".htm"
writer = new StreamWriter(File.Open(tempOutputFile, FileMode.Create))
writer.Write(feedAsHtml)
writer.Close()

' display file in browser
System.Diagnostics.Process.Start(tempOutputFile)

Now if you add xml.cs to the command line, your unread gmail should be displayed in your web browser e.g. ...

ax[w]script [username] [password] gmail.vb xml.cs

For the record, here is the gmail.vb file in C#

// gmail.cs - gets unread mail from a gmail account as an atom feed
// for Alintex Script - www.alintex.com
// usage: ax(w)script [username] [password] gmail.cs

using System;
using System.Diagnostics;
using System.Net;
using System.IO;
using System.Text;

#region Script

// check commandline arguments
if (args.Length < 2)
{
   print("gmail.cs - gets unread gmail as an atom feed");
   print("Usage: ax(w)script [username] [password] gmail.cs");
   return;
}

WebClient client = new WebClient();
byte[] bytes = Encoding.ASCII.GetBytes(args[0] + ":" + args[1]);
client.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(bytes));
 
const string gmailURI = @"https://gmail.google.com/gmail/feed/atom";
StreamReader reader = new StreamReader(client.OpenRead(gmailURI));
string feedAsXml = reader.ReadToEnd();
reader.Close();
 
// transform the atom xml feed to html
string feedAsHtml = XML.Transform(feedAsXml, XML.AtomXsl);

// write the html to a temporary file
string tempOutputFile = Path.GetTempFileName() + ".htm";
StreamWriter writer = new StreamWriter(File.Open(tempOutputFile, FileMode.Create));
writer.Write(feedAsHtml);
writer.Close();

// display file in browser
Process.Start(tempOutputFile);

#endregion

Posted Thursday, October 14, 2004 5:43 PM by Alex Hoffman | 2 comment(s)

Getting Unread Gmail as an Atom Feed in VB.NET

Gmail currently provides a list of unread emails in a subscriber's inbox as an Atom feed. While that may change in the future, the following Alintex Script code will retrieve and print the returned XML given a username and password.

Update: see also |this post| which shows how to display the xml as html in your browser, and also provides a C# version of gmail.vb

Run the script as follows:

ax[w]script [username] [password] gmail.vb

Paste the following into a file named gmail.vb and run it as shown in the line above.

' gmail.vb - gets unread gmail as an atom feed
' for Alintex Script - www.alintex.com
' usage: ax(w)script [username] [password] gmail.vb

imports System
imports System.Net
imports System.IO
imports System.Text

#region "Script"

' check commandline arguments
if (args.Length < 2)
   print("gmail.vb - gets unread gmail as an atom feed")
   print("Usage: ax(w)script [username] [password] gmail.vb")
   return
end if

' connect to gmail and retrieve the atom xml feed
client = new WebClient
bytes = Encoding.ASCII.GetBytes(args(0) & ":" & args(1))
client.Headers.Add("Authorization", "Basic " & _
   Convert.ToBase64String(bytes))

gmailUri = "https://gmail.google.com/gmail/feed/atom"
dim feedStream as Stream = client.OpenRead(gmailUri)
reader = new StreamReader(feedStream)
feedAsXml = reader.ReadToEnd()
feedStream.Close()

print(feedAsXml)

#end region

Note:

  • the code above doesn't need to handle exceptions as the script shell does it for you by default.
  • the password is not transmitted in plaintext.
  • if your username includes a '.' character, Alintex Script will think your specifying a file on the commandline. In that case use the /a[rgument] switch instead i.e. /a:my.name,password.

Posted Thursday, October 14, 2004 4:28 PM by Alex Hoffman | with no comments

More Posts