Apolon's Software Torq

Action Events in .NET

2008-12-05T09:29:00.010+09:00

The Async Pattern used in .NET 1.x and 2.0 code always annoyed me because of the excessive coding noise it introduced. The new support in .NET 3.x in relation to lamdas (convenient delegate or callback syntax) and the generic representation of Actions, Functions and Predicates opens up some possibilities for writing asynchronous oriented code without all that cruft. Check out the IStreamReader class below. It defines a series of events related to the stream reading functionality. Each of these is defined as an event that calls the subscriber back via an Action definition. Each Action type is parameterized based on the needs of the event callback functionality. The beauty of this is that the application code is subsequently much more readable as can be seen by the automated test segment at the end of this blog post.

/// <summary>
/// An object that asynchronously reads bytes from a data stream.
/// </summary>
public interface IStreamReader
{
 /// <summary>
 /// Occurs when a block of bytes has been read by this reader. The data
 /// bytes buffer that were just read and the number of bytes placed in
 /// that buffer are supplied to the event callbacks.
 /// </summary>
 event Action<byte [], int> BytesRead;

 /// <summary>
 /// Occurs when progress is made by this reader. The event call back
 /// provides the number of bytes read to date and the number of bytes
 /// expected to be read in total. If the total number of bytes in the
 /// stream is unknown then the total count supplied is -1.
 /// </summary>
 event Action<int, int> ProgressMade;

 /// <summary>
 /// Occurs when an error stops the read process from proceeding.
 /// </summary>
 event Action<Exception> ErrorOccurred;

 /// <summary>
 /// Occurs when the read action is complete. This event provides no
 /// additional information so is only practically usable when the
 /// <see cref="BytesRead"/> event was subscribed to.
 /// </summary>
 event Action ReadCompleted;

 /// <summary>
 /// Occurs when all data bytes have been read from this stream. The
 /// entire data block that was read is supplied to the event callback
 /// along with the number of bytes that was read. This event should only
 /// be used where the files read can practically fit in memory. If this
 /// is not the case, then a combination of the <see cref="BytesRead"/>
 /// and <see cref="ReadCompleted"/> events can be used instead to process
 /// the large file in manageable chunks.
 /// </summary>
 event Action<byte [], int> EntireFileRead;

 /// <summary>
 /// Initiates a read of the entire stream.
 /// </summary>
 void ReadAll();

 /// <summary>
 /// A convenience method for when this asynchronous oriented class is used
 /// in a synchronous manner. This method waits for the read actions to
 /// complete or fail before proceeding.
 /// </summary>
 void WaitForCompletion();
}

In the following test code segment, an error is not expected to occur so rather than handling the error callback we throw the exception object supplied to fail the test. If the entire file is read successfully a lamda is used to set the text that has been read. In typical applications, the WaitForCompletion method would not be used but it useful in test code and single action applications to wait for the read functionality to complete.

[ Test ]
public void Disk_Stream_Reads_Entire_File_Successfully()
{
 string text = null;
 IStreamReader reader = GetTestReader( "MartinLutherSpeech.txt" );
 reader.ErrorOccurred += ex => { throw ex; };
 reader.EntireFileRead += ( data, length ) => text = Encoding.ASCII.GetString( data, 0, length );
 reader.ReadAll();
 reader.WaitForCompletion();

 Assert.IsNotNull( text );
 Assert.AreEqual( 9190, text.Length );
 Assert.IsTrue( text.StartsWith( "I am happy to join" ) );
 Assert.IsTrue( text.EndsWith( "we are free at last!\"" ) );
}

The new functional aspects of the .NET 3.x functionality really changes the way we develop with the .NET framework. Practically speaking its going to take some time to get use to the new ways of thinking and applying them to this multi-core world we find ourselves in.

Torq FxCop Setup

2008-12-04T18:13:00.002+09:00

FxCop is a static analysis tool from Microsoft that checks software source code for conformance to the Microsoft .NET framework’s design guidelines. Static analysis is performed on either the source code files that define the software program or on the compiled software files. It is analysis that is performed before the program is run. This contrasts to dynamic analysis tools which act while the program is running. Both have their place in working towards improving software quality.

The name FxCop is derived from “Framework Cop”, so it represents a tool that polices a programmer’s software development so that it meets the .NET framework’s design guidelines. Fortunately the FxCop rule set is configurable so that a software developer can change the static analysis rules to match their internal policies. This is in fact what we are doing with FxCop within our software development processes.

FxCop performs checks on .NET assemblies (dll or exe files) and doesn’t work on the source code directly. There are commercial static analysis tools available including those in Visual Studio Team System and other third parties such as NDepend and CodeIt.Right. As we use Visual Studio Professional and FxCop is appropriate for our needs, we’re going the free static analysis tool route. The goal is to increase code quality and in particular highlight obscure and difficult to remember design rules during the development process.

At the time of writing FxCop isn’t as integrated into Visual Studio as the commercial offerings. Regardless, with some adjustments to our development environment and processes it has been neatly integrated. The approach taken is to add another configuration type to our Visual Studio projects in addition to the defaults of Release and Debug. The additional configuration type has been called Analyse and is intended to be used for any static analysis functionality we choose to add in the future and as such is not limited to FxCop.

The Analyse configuration can be added to a solution in Visual Studio by displaying the Configuration Manager using the “Build-Configuration Manager” menu. Once the Configuration Manager form is displayed, choose the New option in the “Active Solution Configuration” drop down. Once the configuration has been added to the solution, a few more steps are needed as we’re using the Analyse configuration in the same way as the Debug configuration but with additional static analysis actions after every build action.

To make the Analyse configuration operate in a similar fashion to the Debug configuration we do the following for each project that needs static analysis support:

Set the “Defined DEBUG constant” checkbox in the Build tab for the project.
Set the Debug Info setting to “Full” in the Advanced Build settings form that is also available from the Build tab for the project.
Add a call to the AnalyseAssembly batch file to the post build step of the project. A batch file is used to keep the post build step code short and allows us to modify the analysis actions in one location within our development build environment. This then requires the batch file directory to be in the executable path of the development machine.

The AnalyseAssembly batch file is fairly simple, it just runs the command line version of FxCop with the custom dictionary and rule set that we’ve configured.

With the Analysis configuration in place, a developer can easily flip to the Analyse configuration option in Visual Studio and compile to see the static analysis results. In addition, the continuous integration system can include the analysis steps in the automated build process. We’ve just recently started using FxCop and are in the process of updating our Visual Studio projects to use the approach documented here. An involved part of this process is choosing which FxCop rules to use and which ones to disable as some of them are certainly too restrictive for our needs.

Modbus Driver and Rewrite Decisions

2008-09-29T15:10:00.002+08:00

There’s an informal definition for Legacy Software that comes up time to time that cuts to the core of the matter: Legacy software is software that actually works. Its been installed, deployed and run against real world situations. As such its a major decision to rewrite any substantial item of legacy software and should typically be resisted. Regardless, there are many situations where doing a rewrite is the best long term decision to make.

Sentient Computing and Torq had to make a rewrite or maintain decision with respect to the mqe driver back in 2004. The mqe driver is an abbreviation for the Modbus Quantum Ethernet driver. It is a MacroView communications driver that implements the Modbus Ethernet TCP protocol. We ended up taking the rewrite route and developed the modbusdrv communications driver. This same technology was then used to develop a Modbus Server implementation for MacroView and some internal Modbus protocol based utilities.

Many of the MacroView installed sites have moved to using the newer modbusdrv communications driver since it was first developed in 2004. Regardless many sites still run the mqe driver which was originally developed in 1996. Recently there was a need to identify the advantages of upgrading to the modbusdrv driver when the mqe had been operating at a site for many years. The question came up because ostensibly there is little functionality difference between the two. From a maintenance perspective, we much prefer the modbusdrv implementation as the source code and internal structure is much cleaner and better organized. So bottom line, the functionality difference is that modbusdrv a better quality communications driver. This translates directly to customer cost savings when any support is needed.

Its interesting that Wikipedia actually has a dedicated page for the word Rewrite with respect to programming. In that article various web pages are referenced with strong opinions on the subject. Its an emotional issue for developers because the cost of a rewrite is significant. There is a preconception that developers will lean towards rewriting software instead of extending it. It is often attributed to a variation of the Not Invented Here syndrome. The Wikipedia article lists the following possible reasons for a software rewrite:

When the source code to be able to extend an existing program is not available.
When the source code is available under an incompatible license.
When the code cannot be adapted to a new target platform.
When the existing code has become too difficult to handle and extend.
When the task of debugging the existing code seems too complicated.
When the programmer finds it difficult to understand the source code.

The last three were the reasons behind effectively rewriting the mqe driver and developing a new from scratch Modbus TCP driver which we called modbusdrv. The approach taken was to implement portions of the mqe functionality as needed on a project by project basis. It was impractical to attempt a total replacement in one go. We added functionality to the modbusdrv implementation over the years such that now they are now on par in terms of functionality. The rewrite was definitely the right decision as the result is that we have a Modbus driver implementation and technology base that is much easier to maintain and extend. Aspects of the modbusdrv implementation and its advantages over the mqe implementation are summarized in the remainder of this blog post.

Leveraging Common Libraries

The modbusdrv implementation leverages a series of common MacroView libraries that Sentient and Torq have developed since taking over the ongoing MacroView maintenance and development. The mqe driver has its own driver specific Modbus protocol and socket communications code. The advantage of using common libraries include:

Issues are resolved for multiple applications when they’re resolved in the common libraries
Services based on these core libraries can be applied to multiple applications without the need for additional application specific code.
Developers don’t have to learn how a particular driver implements a particular aspect of its functionality as there is a common mechanism.

Serialization Library

Newer MacroView drivers and communication utilities leverage the same core Serialization framework. It’s the same serialization library used in drivers such as the Allen Bradley PCCC driver, Simatic 505 driver, Symax ethernet driver, the Modbus server implementation and the MacroView metaserver infrastructure. In all of these implementations, communication messages are modelled as objects. This approach separates out the data structures from the protocol implementations. It makes it easier to add support for additional packet types and Modbus communication layer variations as needed. Note that the diagram below has only the fields of the classes displayed and excludes the class functions to highlight the data structure.

Modbus Protocol Library

A standalone Modbus protocol library was developed and that is used by multiple applications (the driver itself, the Modbus Server application and a general Modbus utility). The protocol library is session type agnostic in its design and currently supports either serial communications or Ethernet TCP scenarios using the same code base.

Debug Logging Library

The debugging and logging options for the modbusdrv driver use a standard MacroView library and leverage the Serialization debugging functionality to provide clear debug logs that show the packet structures in an organized manner. The detailed debug log shows a Modbus request-reply interaction and the associated serialization and deserialization activities. Each structural layer of an object serialization is indented so that the structure of a packet can easily be seen.

Automated Testing

The modbusdrv development included automated unit tests and integration tests. The integration tests can be run against either a physical PLC or a Modbus simulator.

Unit Testing

Within MacroView application programs that we’ve developed, the unit tests are compiled into the Debug versions of executables and can be run with a –test command line option. It is based a unit testing framework built to work with the MacroView C++ classes but inspired by the xUnit family of unit testing frameworks. The following screen cast shows a run of the modbusdrv unit tests. These are all in-memory tests designed to executable quickly and provide developers with rapid feedback of whether any functionality modifications have adversely affected existing functionality.

Integration Testing

The modbusdrv integration tests are script based and exercises the drivers interaction with a Modbus device through a series of get/set actions with confirmation tests run during the test cycle. Both the unit tests and the integration tests are also run within a Purify session to identify and resolve any memory issues.

General versus Special Case Tension

2008-09-20T08:46:00.002+08:00

One of the blogs I subscribe to is by Reginald Braithwaite. He was recently interviewed on InfoQ and part of the conversation related to the development process of generalizing in programming:

……so again I apologize for digressing, but I found this to be an important point in my own programming, and I don't know if that's a general point but quite often we see something and we are very tempted to say "Oh, this is a special case of a more general thing", and then we solve the general thing. However that is an infinite recursion, it's always the special case of something more general. And if you are always climbing up the tree into the more general thing you will eventually wind up with a PhD in computer science and no code.

However on the other hand, if we just scrabble around the Earth, and we never sort of poke our head around to see the more general thing. We are constantly resolving the same problems, we are not even recognizing that two different things we solved are both aspects of the same thing. So what I try to do is I always try to recognize what the general case is and then discipline myself not to solve the general case until it's really an imperative, but not to be ignorant of the general case. So coming back to your question, at the moment I am aware that it is a general case, and I am fighting on an almost daily basis not to make it too general

This is such a fundamental decision that comes up time and time again in software development. I think Reginald is spot on in his approach of not going down the generalization rabbit hole everytime, but never forgetting that there’s an incredible amount of waste associated with always working on just the specialized case. Sentiments such as YAGNI are great guiding principles but can be damaging if they preclude doing any generalization work at all.

dynamic_cast and accessible base classes

2008-06-06T10:04:00.002+08:00

We recently upgraded to using Visual Studio 2008 for compiling our MacroView source code on Windows. Previously we had used Visual Studio 2003 so there was a jump over the 2005 compiler version. The same version of IDE is now being used across all of our C, C++ and C# code on Windows. The move went fairly smoothly but one of the porting tasks that I didn’t anticipate was the change in the implementation of dynamic_cast and how it relates to a multiple inheritance hierarchy. A problem occurred where a dynamic_cast failed with a VS2008 compiled executable while it didn’t with the VS2003 compiled version. The inheritance hierarchy of the class in question is shown in the diagram. The diagram is my first use of the C++ class diagram support in VS2008 which is quite nifty. I’m not sure how well it will work with collection relationships in C++, but for quickly creating an inheritance diagram it was very nifty.

I suppose some developers will recoil in horror at the use of multiple-inheritance, but it has actually worked well and well across multiple platforms. The multiple inheritance of IMetaMessageProcessor, IConversationMessageSink and IHandleEventProcessor are all in aid of supporting the interface concept in C++. Each of these interface “classes” have all abstract methods and absolutely no data. The DebugTool class is a convenience class which provides a series of logging functions to any class inheriting from it. This is the aspect of the inheritance hierarchy that feels a bit “dirty”. This approach was taken to minimize the amount of typing needed in a class to call a logging function. This could have also been achieved through composition and some macros to reduce the typing footprint. Regardless, this is the design that was chosen and it has worked well. Purists be damned :^)

Back to the dynamic_cast issue. Testing the VS2008 compiled application showed a dynamic_cast<OpcMetaBridge *>( processor ) where processor is an IMetaMessageProcessor failing. Cracking open the Annotated C++ Reference Manual lead me to the following statement:

The result of a dynamic_cast<T>(v) is of type T. The type T must be a pointer or a reference to a defined class or void *.
If T is a pointer type and v is a pointer of a type for which T is an accessible base class, the result is a pointer to a unique sub object of that class.

So the dynamic_cast was returning a null pointer because MetaCommsServer inherits from IMetaMessageProcessor with protected inheritance. It worked before because VS2003 and all of the other older Unix C/C++ compilers we’re using weren’t matching the standard. VS2008 improves Microsoft’s compliance with the definition of the C++ language.

DSXP OPC DA 2.0

2008-03-13T10:45:00.003+09:00

Man I hate OPC. It just feels like software plumbing gone overboard in the COM based architecture it uses. The term “software plumbing” is used to describe software thats forms the basis of software that people (realy people, not developers) actually see. Software plumbing is important as it needs to be establish for the rest of the structure gets built, though I’m sure the analogy is being taken too far here.

I’m currently working on an OPC application that leverages the Technosoftware C++ API that sits on top of OPC to simplify the OPC development somewhat. It does this, but because of leaky abstractions, there is need to delve into the library code where it interacts with the OPC interfaces directly. It just seems the combination of COM and C++ result in butt ugly hard to do understand code. You hear/read old Microsofties talking about the wonderful COM architecture (COM is love and all that sort of thing) and wonder what the hell were they smoking? It reminds of the STL in that some developers think its a paragon of API design, but to me its difficult to use and difficult to read. Anyway, I’m heading off into bile blog territory here. So back to why I started this blog post…

The Technosoftware OPC C++ Client API treats OPC DA 2.0 and 3.0 servers differently and runs different portions of it’s implementation depending on the OPC version. Its difficult to get access to many OPC servers which require entire systems to practically operate e.g. Yokogawa EXA. Hence there is a need for OPC simulation servers. The one simulation server I’ve found that delivers solely a OPC DA 2.0 interface and sufficiently functional to use in development/testing is the OPC simulator found at http://www.dsxp.com.

Fedora Core 7 and VMWare

2008-01-10T09:53:00.001+09:00

Here’s a quick tip that I kicked myself when I eventually figured out – and then felt subsequently quite thick. After installing Fedora Core 7 within a VMWare host on Windows, the screen resolution couldn’t go above 800x600. I worked with that for a while using an X windows package to interact with FC7 to get around the low resolution. Today I found out that if you change the display monitor type to be an LCD panel of a particular resolution, lo and behold you can then choose a whole bunch of screen resolutions. The performance of the latest VMWare tools and Fedora Core 7 combination is great. Its now as good as a Windows guest running VMware tools.

Real Men Don't Sleep

2007-09-22T08:50:00.001+08:00

There’s a new MSDN show called Striking Pixels that is a “goofy” look at Microsoft’s designer offerings such as Silverlight. There was one excerpt that just cracked me up. Its shown below. The two hosts are playing two sets of characters. The first set of characters are the customers who have a very dodgy set of accents (and dodgy moustaches). The second set of characters are the designers that are providing design services to the customers. I found it so funny because earlier in the week I had a similar experience. A business partner sent over a rough set of functionality requirements for a product extension. It was only on my second pass at reading the documents that I realized the expectation was to have something ready by October 1^st which was just 6 working days away at the time. So I totally get the exasperation and stunned silence shown by the designer characters in the following excerpt:

Now often as developers we can pull out all stops and do some amazing things in a short time. The problem is that this makes a rod for your own back. In other words, if the client or business partner doesn’t understand the intricacies and details of what goes on to achieve the results, their expectations are then set higher than is realistic. Bottom line: we are going to do whatever we can to meet the business needs of the business partner for their deadlines, but… I’m going to need to successfully communicate the compromises and development follow up that will be needed in the following month.

Inside the Agility Cube Excerpt

2007-09-12T17:12:00.001+08:00

I was listening to the Javapolis Inside the Agility Cube session and snorted at the following excerpt:

I know of a project that went into a kind of death march chaos and all kinds of other things. The project that I guess you could have.. probably take twenty to twenty five people to develop. At the last count there was something like seventy people involved. So.. slightly off the objective there. And they had originally instituted a two week cycle. And what happened.. eventually the management decided to shut down the agile process pump and one of the reasons was they said they didn’t like hearing bad news every two weeks.

I have a four year old boy who is just learning the trick of putting his fingers in his ears and saying I can’t hear you, I can’t hear you, I can’t hear you. He hasn’t learned it too well but that is very much what went on at this company. “I don’t want to hear your feedback. Your feedback is not good. I thought that you guys said you would do Agile development and give us this feedback that it was always going to be good news”. No news is good news. This is not what it is about. The whole point of an agile process. The whole point of an iterative and incremental – or in their case decremental – development is you fail fast. If you’re going to get it wrong you may as well find out sooner rather than later. And you have to be prepared for that.

Its tough working with a business partner or customer that expects to hear “good news” all the time. Its just not workable. To guarantee “good news” all the time, the performance bar needs to be set really low – and that’s not in anyone’s best interest.

MacroView Excel Addin V1.3.0

2007-09-01T17:10:00.001+08:00

We’ve released V1.3.0 of the MacroView Excel Add-in software product just this week. Its a package that we’ve developed for Sentient Computing who are one of our business partners. Sentient sell the software as part of their suite of MacroView SCADA products. It allows an end user to get access to both current historical information from their manufacturing, process control or other such industrial plant from within the Excel spreadsheet environment. Being “head-down bum-up” (i.e. really busy) most of the time developing software I don’t talk about our successes or what we can do for business partners enough. Its something thats on the cards to rectify in the coming months.

Back to the Excel addin release. The updated documentation can be found over here. The main feature addition in this release is native support for the Excel 2007 ribbon. Check it out below. I personally find the ribbon approach in the Office 2007 product range to be a huge improvement for the most part. It is frustrating occasionally when a feature you remember from Office V-Previous just “can’t be found” in the ribbon UI. Fortunately the command needs for the MacroView ribbon tab are manageable in number and fit easily within a single ribbon tab:

I particularly like the Value and Table buttons. By default, mouse clicks on these will initiate the most common Value and Table data query respectively (an entity value and a historical trend data table). Its only if the advanced query types are needed does the user need to click on the drop down arrow and select from all the different query types available for that category:

The value queries allow you to associate a MacroView value with a cell and then update the value from the “real world” on demand or in a continuous update mode. You can use these live values in other calculations or as inputs to a graphic visualization such as a pie chart:

The product user can also access MacroView historical data and similarly perform calculations and display charts using that data. Sentient sell the Excel addin as part of the product range. If your business is interested in developing a software product that extends any of the Microsoft Office software then contact me to discuss the possibilities. Similarly if your business would benefit from automating part of your workflow with custom software its worth us talking.

TorqObject Database Decoupling

2007-08-15T17:42:00.001+08:00

We use an in-house framework for building applications and the subject of how we decouple business domain classes from a particular data source recently came up. This blog post provides a quick overview of the core Torq framework classes/interfaces and how they are decoupled from particular database implementations. A business domain class that is to leverage the framework needs to implement the ITorqObject interface. The properties and methods of this interface include functionality related to a Torq specific reflection extension, authorization, property change events, list events, a parent object in the case of object composition scenarios and most importantly the concept of an object source and an object mapper. Every ITorqObject instance is associated with an ITorqObjectSource which defines where it is “stored” and an ITorqObjectMapper instance whose responsibility is to map between the in-memory object world and the object source. In addition there is an ITorqList<T> list interface that extends the standard IList<T> definition with Torq specific reflection knowledge.

An example of an implementation of the ITorqObjectSource and ITorqObjectMapper interfaces is where a Matisse object database is used in deployment. Fresher have their own Matisse specific API and means of generating .NET classes from an ODL definition or a running database. The problem with using that approach is that the application code is then strongly tied to that API and also the representation of list relationships in the generated code is spread across multiple methods (get, add, remove etc). The approach taken with the Torq framework is to provide an implementation of the ITorqObjectSource and ITorqObjectMapper interfaces that is Matisse specific. The diagram below indicates the main classes involved. Fortunately the Matisse API provides the MtObjectFactory class that can be overridden to provide application specific object creation during interaction with an MtDatabase instance. The MatisseObjectMapper class is-a MtObject and it will create an associated domain object (an ITorqObject instance) as needed. It then provides the data mapping functionality for the ITorqObject instance via its set of Get/Set prefixed methods for various core and parameterized types. Since Matisse is an object database, the mapping is fairly trivial when compared to the mapping needed to an RDBMS.

The ITorqObject interface is used where-ever the concept of a “torq domain object” is needed. This allows any base class to implement this interface to work with the framework. Practically all our domain classes are derived from the TorqObject class which provides a default implementation of ITorqObject. This default implementation provides a heap of protected convenience methods for interaction with the ITorqObjectMapper and ITorqObjectSource associated with the domain object.

In the domain classes, there is a small bit of coding overhead needed for every property or relationship. There is the static definition of a Torq specific reflection object. It is uninitialized in the source code, but the framework initializes these static properties automatically when a business domain assembly is loaded. A private field is then used to store the results of any Get/Set methods. The TorqObject base class then forwards Get/Set method calls onto its ITorqObjectMapper instance to get data from the object source and update the object source. The following example extract shows how this is achieved for a string property. Note that the GetProperty and SetProperty methods provide an interception point for the framework to insert functionality related to authorization, logging and persistence. Note that the Torq specific reflection information (TorqProperty in the example) provides a useful mechanism for accessing strongly typed class level information in the code. An example is in databinding, where you can use say Party.NameProperty instead of a string literal in defining what property a UI control is being bound to.

        public static TorqProperty NameProperty;

        private string name;

        public string Name 

        {

            get { return GetProperty( NameProperty, ref name );}

            set { SetProperty( NameProperty, ref name, value ); }

        }

Here’s an example of the implementation of a list property on a business domain object. Note that the ITorqObjectSource will define the type of the list. Each source can provide its own ITorqList<T> implementation to handle object source specific needs.

        public static TorqListProperty ContactMechanismsProperty;

        private ITorqList<IContactMechanism> contactMechanisms;

        public ITorqList<IContactMechanism> ContactMechanisms 

        {

            get { return GetProperty( ContactMechanismsProperty, ref contactMechanisms ); }

        }

The Torq framework will evolve over time and it would be handy to reduce the small coding overhead associated with each class property. The use of a private field as an intermediate in memory storage could go and it would be great to be able add more of this code automatically either at run time or as a post compile step. A significant advantage of the current approach is its much easier to use a debugger and just step through the source code. Fancier approaches such as runtime code generation make it conceptually more difficult to debug at run time.

This blog post provided a quick dip into the foundation of the Torq framework we use for developing business domain products. The framework is intended purely for in-house use. I decided to put these details up to provide an overview of how you could leverage an OO database such as Matisse but not tie your application code to it. Note that I am an advocate of the Matisse database and do recommend you check it out. Regardless its also beneficial in many scenarios to not tightly couple application code to a specific data store.

New Development Machine

2007-08-11T12:34:00.001+08:00

I upgraded to a quad-core Q6600 based system with two Raptor 10K rpm drives and 4GB RAM this last week. The problem with being my main Windows development machine is that there so many packages to install and configuration to re-setup that it takes a day plus some residue to finish the changeover. The decision was made to stay with Windows XP with this upgrade as I just don’t want to spend the time chasing down compatibility issues with Windows Vista and the myriad number of software packages that I depend upon on different software projects.

Apart from taking a day to do the full changeover, things went pretty smoothly. Having the “old” AMD X2 based system there and available to confirm the package list and configuration settings helped a lot though. I also took the opportunity to get another 22 inch monitor and move to a dual monitor development set up. It’s not quite symmetrical but the cost differential for going to another 24 inch monitor wasn’t justifiable at the current point in time. My long term goal is to have 3 24 inch or 30 inch monitors.

The quad core and 10k rpm combination has definitely made a difference to my workflow. The system is a lot more responsive when lots of tasks are happening at the same time e.g. developing in visual studio with Resharper, running automated tests, running virtual machines needed for the tests, going back and forth to Outlook etc. I actually thought that compile times hadn’t actually changed much but flipping back to the old dev machine showed me that there was a clear improvement. Its amazing how quickly you get used to improvements and forget what it was like before the change.

Take a squiz at a couple of photos of my work environment. I like to keep things pretty sparse, but this would be the cleanest it will get normally. The desk is an electric desk that can be repositioned at different times of the day so my back varies its position regularly. The first photo is in the seated position, whilst the next is in the standing position. The electric desk was from Ergomotion and while expensive has been worth it for me.

Blogger FTP Frustrations

2007-05-31T17:15:00.000+08:00

I haven't been able to publish a blog post for a three or so weeks now because of a problem in the Blogger FTP publishing operation. The last post was queued up in the Blogger database wasn’t able to be written to the web site. The Blogger error output had lots of repeated lines similar to the following (after a long timeout period)

/blogger_ftp/archive/2007_05_01_archive.html java.net.ConnectException: Connection timed out
/blogger_ftp/2007/04/silverlight-based-on-microsoft-net.html java.net.SocketException: Broken pipe
/blogger_ftp/2004/06/microsoft-developer-target-profiles.html java.net.SocketException: Broken pipe

There’s a bunch of FTP related problem descriptions on the Blogger group pages, but no real consistent solutions. There were entries like “created another FTP account and then it just started working”. I sent a couple of submissions to the black hole that is Blogger support. In the end I decided to set up a Linux FTP server using dynamic DNS and then reconfigure Blogger to transfer to that temporarily. All the FTP transfers succeeded, so attention moved to the web hoster.

At first the hoster response was something along the lines of “document step by step how to reproduce the problem”. Sometimes it seems that support staff and software or software service companies don’t actually read the first couple of emails you send them. I do get incredibly frustrated when support people ask for a step-by-step instruction set on how they can reproduce the problem even when the contact email explicitly indicates that the problem can’t be reproduced at will by the support person and the reason why.

In an effort to resolve the problem, I quickly looked at alternative blogging platforms. Wordpress was very promising. It was easy to import all the Blogger posts, but the big problems for me were the inability to embed flash content in posts or import third party themes. I had a quick look at Community Server and dasBlog, but didn’t really want to go through the setup and ongoing maintenance hassle. Wordpress hosting solutions were an option, but they cost as much as my existing web site. In the end, the approach taken was to user Blogger custom domains. Yes Blogger is a dog of a blogging platform that is moving glacially considering the resources that Google has available. Regardless its a pain to move the blog elsewhere.

ObjectDisposedException closing Form in click handler

2007-05-19T13:08:00.001+08:00

Okay here's a weird .NET Windows Forms error scenario. One of the applications had a scenario where an ObjectDisposedException was occurring, but for only one of the users. The other users that worked that the particular application functionality involved did not experience the error. I finally managed to reproduce the problem in the office by initiating the application task, clicking the “Create Job” button and then immediately going to another application and flipping between other windows that have nothing to do with the application. My guess is that the user that experiences the issue interacts with the system in a particular GUI manner that uncovers the problem.

The stack trace when the ObjectDisposedException looks like this:

  System.Windows.Forms.dll!System.Windows.Forms.Control.CreateHandle() + 0x1ff bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.Handle.get() + 0x77 bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.PointToScreen(System.Drawing.Point p) + 0x38 bytes
  System.Windows.Forms.dll!System.Windows.Forms.Button.OnMouseUp(System.Windows.Forms.MouseEventArgs mevent = {X = 36 Y = 7 Button = Left}) + 0x79 bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.WmMouseUp(ref System.Windows.Forms.Message m, System.Windows.Forms.MouseButtons button, int clicks) + 0xf2 bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.WndProc(ref System.Windows.Forms.Message m) + 0x544 bytes
  System.Windows.Forms.dll!System.Windows.Forms.ButtonBase.WndProc(ref System.Windows.Forms.Message m) + 0x151 bytes
  System.Windows.Forms.dll!System.Windows.Forms.Button.WndProc(ref System.Windows.Forms.Message m) + 0x2b bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.ControlNativeWindow.OnMessage(ref System.Windows.Forms.Message m) + 0xd bytes
  System.Windows.Forms.dll!System.Windows.Forms.Control.ControlNativeWindow.WndProc(ref System.Windows.Forms.Message m) + 0xd6 bytes

The Button.MouseUp method attempts to identify where on the screen the mouse up event occurred when the button has already been disposed. Being able to reproduce the problem in the office, at least allowed me to identify which button was involved. The button click handler code is pretty standard for a button that does some work then closes the form:

private void HandleCreateClick( object sender, EventArgs e )

{

// Application specific processing goes here in the real code.

Close();

}

After much experimentation using the debugger and Reflector, it looks like under normal circumstances the Close() causes a side effect of the button losing focus, which then clears internal System.Windows.Forms.Control flags which ensure that the OnMouseUp method doesn’t attempt to do any mouse-up event handling. For some reason, in my particular application scenario, the OnLostFocus method is not called and OnMouseUp processing attempts to get the mouse coordinates which then causes the ObjectDisposedException to be thrown. No matter what I tried, I could not reproduce the problem in a simplified project that could be forwarded onto Microsoft to look into. The following workaround was used to stop the problem happening in the application:

private void HandleCreateClick( object sender, EventArgs e )

{

// Application specific processing goes here in the real code.

// The following line is a workaround for a problem where the createButton's

// MouseUp event was throwing an ObjectDisposedException. In most scenarios

// where a button click event handler Closes the Form, a LoseFocus event

// resets the internal flags which causes the MouseUp event processing to

// skip any attempts to access button information. For some reason this

// createButton scenario would occassionally not get the LoseFocus event

// and cause an exception to be thrown. Setting the Enabled flag to false

// is a workaround which clears internal button flags so that no

// MouseUp processing occurs. This works around the problem.

createButton.Enabled = false;

Close();

}

Silverlight: Based on the Microsoft .NET Framework

2007-04-16T14:18:00.001+08:00

I came across a blog post from Brightcove which made my day. It indicated that Microsoft’s new name for WPF/E was Silverlight and that Brightcove would be looking at using the technology. So I hopped over to the supplied links and did a few searches. Some useful web pages on the subject include:

http://www.microsoft.com/silverlight/

http://www.microsoft.com/presspass/press/2007/apr07/04-15WPFEPR.mspx

http://blogs.msdn.com/somasegar/archive/2007/04/15/silverlight-the-next-generation-web-media-experiences.aspx

The main Silverlight web site contains these wonderful words:

“Based on the Microsoft .NET Framework”

Man that’s good to hear. The last CTP of the WPF/E technology had no CLR functionality at all and I was starting to worry. The .NET CLR functionality opens up a whole world of functionality to Torq Software business partners (my customers). I was surprised to see news of any of this sort of announcement until the Mix07 conference started. It will be good to start seeing some technical details of the Silverlight CLR functionality presumably by next month.

The only disappointing aspect is that there is absolutely no mention of Linux support. This would make the claim that it is “cross platform” much more reasonable instead of being limited to Windows and Mac. We’ll have to see how things pan out, but I’m hoping Microsoft “sees the light” and either provides a Linux version or at least not hamper the open source versions of the technology that will likely result.

The Fallacy of Local Optimization

2007-04-03T09:25:00.001+08:00

Scoble has an interview with the founders of Fog Creek. I smiled at this quote from Joel Spolsky:

That’s the big joke inside of Microsoft. Developers are rewarded for writing a lot of code and fixing a lot of bugs. So the incentive is to write a lot of code and write it very quickly.. Churn it..piles of code… buggy as all hell and then you get a bunch of bug reports and you fix them all and you will look a lot better than a slow methodical developer that gets from point A to point B in the same amount of time or even in less time because of the funny way that that metric might be used.

This is an example of “the fallacy of local optimization” which I first came across as a concept in the Poppendieck’s Lean Software Development book. Basically if you try and optimize locally (increase software development and reduce software faults/bugs) then you are likely to be far less effective and even introduce unwanted second order effects than if you optimized the whole. Lean principals are based on optimizing the whole and not optimizing a portion of your system (whatever it is). So basing incentives and on measuring some aspect of your business/process one level higher than you would expect is more effective for the business as a whole. Providing incentives or penalizing developers based on source code output and bug fix counts can potentially move developers to produce much more buggy code rather than the end goal of better quality software at an acceptable development cost. What I love about the lean principals is that they are “truisms” that apply to more than just software development.

Office 2007 UI Licensing Bull

2007-03-07T10:11:00.001+09:00

I just upgraded to the Infragistics 2007 Volume 1 release which includes support for a ribbon based user interface. It was annoying to come across this dialog during the installation:

I consider myself a pragmatist and don’t think Microsoft is the evil empire or anything, but… when they pull this sort of thing, it peeves me off. The implication is that software developers need to request for the right to create a user interface that is similar to the Office 2007 ribbon user interface – not the same, just similar. In my opinion, the ribbon UI is a great improvement on previous Office user interfaces with respect to browsing through commands but its not revolutionary. Breaking it down, its just a bunch of tabbed command windows each with a controls grouped together in associated panels. Tabbed windows have existed for ages in windowing systems. So have panels, icons, buttons etc. Given this I don’t think Microsoft have any IP ownership of this style of UI except for the very specific layout/graphics used in MS Word, Excel etc. Now the question for me is if I use the Infragistics ribbon implementation, do I have to ask permission of Microsoft? Do I ignore this unreasonable request and if so is there a risk of being bullied by Microsoft’s legal machine. All in all, it sucks.

CentOS Linux

2007-02-17T18:06:00.001+09:00

We’ve been developing MacroView on Linux since Redhat Linux 7.2 and have deployments on RH 7.2, 7.3, Fedora Core 1 and Fedora Core 5. After RH Linux 9.0, Redhat changed their distribution strategy and effectively their business model by moving all community efforts into the Fedora project and all commercial efforts into RedHat Enterprise Linux (RHEL). Their Enterprise Linux is protected somewhat from business competition by trademark law and not directly by copyright as the distribution is to my knowledge all GPL code. You can’t copy and distribute/sell RHEL because it would violate their trademarks. RHEL is also somewhat protected from business competition by being the defacto standard for commercial applications where source code isn’t provided.

Sidetrack: I’m not lawyer, so don’t treat this blog post as legal advice… yada yada yada…

Anyway, back to the point. Fedora releases are good stable releases but man do they come at a fast pace for an OS e.g. every six months or so. Its tough to plan product support around such a quickly moving target. This was obviously part of Redhat’s grand plan and it looks like it works pretty well. So Fedora is a good platform for MacroView systems, but the pace of releases makes it difficult to support as easily as an operating system with a slower release cycle. The problem with RHEL is the yearly subscription fees which I think are quite high given that its based on an open source free-as-in-beer base. Some MacroView customers would not have a problem with RHEL fees, but some would. The approach we have been taking is to stagger the support for Fedora Core versions i.e. skipping some version numbers.

As part of an investigation into an alternative Linux OS support approach, I’m checking out the CentOS distribution. CentOS stands for the Community ENTerprise Operating System. It is built from the RHEL source code but with Redhat trademark information removed. So its a reasonable basis for future potential use with MacroView. Customers that want Redhat support can go the RHEL route, whilst other customers can use CentOS. Both will have a longer release cycle than Fedora releases i.e. 6 months compared with 18 months to 2 years. Note that this all just experimentation at this stage, so nothing is written in stone.

Check out some of the screen shots from the CentOS install process. Feels familiar doesn’t it:

Linux Mini PC MacroView Demo

2007-01-23T17:47:00.000+09:00

I was preparing for a demo scenario today where MacroView Windows Desktop needs to connect to a Linux or Unix system to show X windows connectivity and integration. Because of this, just a straight Windows laptop wasn't enough. I also didn't want to have to depend on Internet or even Intranet access to proceed with any demonstrations. The hardware I'm going to use is a Linux (Fedora Core 5) server running MacroView and a Windows laptop running the various client side software packages that are going to be demonstrated. A Linux server was borrowed from Sentient Computing. Thats the Linux server on the left in the pictures. Its a sweet little unit and is made up of a 1.5GHz Pentium M processor, 1GB RAM and an 80GB hard disk. Man ... I can remember when PSTN modems were way bigger than the Linux box in question.

The laptop is a Toshiba tablet with 512MB RAM and a 1.6MHz Pentium M. They're connected by a cross over ethernet cable. A nice aspect of the Fedora+mini-pc combination is that it boots without stopping even if no monitor, keyboard or mouse is connected. This means demo set up is quite easy. There is an external power supply which is a bit of a pain but all in all, the unit is quite nifty. The first picture below shows MacroView Windows Desktop with a VNC session running the KDE desktop. The second picture shows the MacroView XAML module running. The photos of the Toshiba screen are average and this is probably due to the nature of tablet pc screen surfaces.

Ranorex and Screenscraping/Automation

2007-01-23T11:49:00.000+09:00

After many web searches looking into screen scraping technologies for automating legacy Windows applications, I came across a testing automation product from Ranorex. It's oriented towards the development process, but technically could also be used to script/automate interaction with a legacy Windows appplication. Check out this screencast where interaction with a Nokia DB2 Manager windows program was automated.

xops3 Command Line Arguments

2007-01-17T10:44:00.000+09:00

I recently received a request from a customer for information on all the command line options for the MacroView xops3 executable. This post is a quick summary of the command line options:

-checkMemory	Runs xops3 in a memory buffer checking mode. This mechanism was included in the original MacroView Version 3 development from ~1992 as a means of chasing down memory faults in C++ applications. It is rarely used these days as tools such as Purify provide a more effective memory debugging approach. When used, every dynamically allocated memory segment is logged in a memory manager and header/footer segments surround the memory allocation. A memory manager then checks for allocation/deallocation pairs and memory overruns. It reports on any memory corruptions found and detects memory leaks. Note that program execution speed is of course much slower when run in this mode.
-file <dgtfile>	By default xops3 displays the base.dgt file in the configuration directory. This command line option allows a different startup graphic dgt file to be used.
-updateRate <seconds>	Sets the default scan rate for graphic updates in the xops3 session. This can be over-ridden by individual graphic metafiles in the dgt header.
-reportTimes	Reports on graphic dgt file load and display times. It is useful for measuring draw time performance.
-edit	Puts xops3 in EzEng configuration and editing mode.
-highlight	Displays dynamic graphic objects with a rectangular highlight box to allow an engineer to see the bounds of the object at run time.
-processEvents <n>	The metascript variable management system in xops3 will automatically inform all graphic objects that reference it that the variable has changed. The graphic objects can then immediately update their graphic state. The process events count defines how many of these events are process in a cycle. Note that a graphic object display update can potentially cause the variable to be set again. The event processing limit stops this potential recursion from continuing indefinitely. A zero value turns off the variable change event processing which means that graphic display updates occur at the dgt page's update rate. The default is that all events in the variable set event queue are processed.
-olderr	The xops3 error processing system handles each internally generated error message and either stores the error in an internal (table variable based) list or sends the error as a system alarm to the system message queue. Previous versions of xops3 sent all internal errors to the system message queue and didn't keep an internal list. The -olderr command line option reverts operation to this older message processing implementation.
-noConfig	Runs the xops3 session with no configuration directory i.e. the entities, sources and type attribute databases are not read.
-lastGoodValue	By default, xops3 expects a shared memory driver to update an entity.attribute value on a regular basis and will display -999 values if it is not updated regularly. The determination of "regular" is data source specific and is based on the requested update rate configured in that data source. The -lastGoodValue command line option turns this check off so that the last good value is displayed even if the communications driver is failing to meet the configured update rate for that entity.attribute. This functionality is not supported in the Windows version of the executable.
-consoleSet	A defunct command line option for an xops3 feature called "Console Sets" that is no longer supported.
-letScript <filename>	Instructs xops3 to run a metascript from the supplied file every time a LET command is executed on a PLC or sorted image data source entity.attribute. The metascript is run with 3 arguments in the following order: entity name, attribute name and a value string. This allows xops3 to perform LET action side effects across a whole graphic configuration instead of having to embed calls throughout a graphic configuration.
-iocount	Reports the IO count for the current configuration. This is the number of entity.attribute instances derived from the configuration. It is also the value used for IO count licensing checks.
-dlm	A defunct command line option for an xops3 feature for logging database changes that is no longer supported.
-metascriptProgramTime <seconds>	Sets the maximum amount of time a metascript can take to run within the xops3 GUI environment before it is automatically terminated. The default is 10 seconds which is also the minimum setting. A value of -1 turns of the maximum execution time checks.
-startMaximized	Starts xops3 in a maximized window state rather than the default window size.
Xt command line arguments	xops3 on Unix/Linux also supports standard Xt command line arguments such as -geometry.

Weird ImageListStreamer InvalidOperationException

2007-01-11T15:00:00.000+09:00

One of our MacroView Studio customers sent a strange stack trace from an application crash yesterday. It's strange in that the standard Windows Forms ImageListStreamer class is where the exception occurs. The exception being thrown is a TargetInvocationException wrapping an InvalidOperationException and occurs as a result of very basic form constructor code which is run many times in the application and hence many users will run that code during normal operation. As is typical with tough to resolve faults, I can't reproduce it in the office and will wait for more information from the customer if it occurs again. Regardless the symptoms and some results of web research into the problem has been posted here for any other poor souls that encounter it and also for my own benefit as a record. Here's the stack trace:

Exception Details: System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.InvalidOperationException: Loading of the ImageList did not succeed. at System.Windows.Forms.ImageListStreamer..ctor(SerializationInfo info, StreamingContext context) --- End of inner exception stack trace --- at System.RuntimeMethodHandle._SerializationInvoke(Object target, SignatureStruct& declaringTypeSig, SerializationInfo info, StreamingContext context) at System.RuntimeMethodHandle.SerializationInvoke(Object target, SignatureStruct declaringTypeSig, SerializationInfo info, StreamingContext context) at System.Reflection.RuntimeConstructorInfo.SerializationInvoke(Object target, SerializationInfo info, StreamingContext context) at System.Runtime.Serialization.ObjectManager.CompleteISerializableObject(Object obj, SerializationInfo info, StreamingContext context) at System.Runtime.Serialization.ObjectManager.FixupSpecialObject(ObjectHolder holder) at System.Runtime.Serialization.ObjectManager.DoFixups() at System.Runtime.Serialization.Formatters.Binary.ObjectReader.Deserialize(HeaderHandler handler, __BinaryParser serParser, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream, HeaderHandler handler, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) at System.Resources.ResourceReader.DeserializeObject(Int32 typeIndex) at System.Resources.ResourceReader.LoadObjectV2(Int32 pos, ResourceTypeCode& typeCode) at System.Resources.ResourceReader.LoadObject(Int32 pos, ResourceTypeCode& typeCode) at System.Resources.RuntimeResourceSet.GetObject(String key, Boolean ignoreCase, Boolean isString) at System.Resources.RuntimeResourceSet.GetObject(String key, Boolean ignoreCase) at System.Resources.ResourceManager.GetObject(String name, CultureInfo culture, Boolean wrapUnmanagedMemStream) at System.Resources.ResourceManager.GetObject(String name) at Syncfusion.Windows.Forms.Edit.FindReplaceDlg.InitializeComponent() at Syncfusion.Windows.Forms.Edit.FindReplaceDlg..ctor() at Syncfusion.Windows.Forms.Edit.EditControl..ctor() at MacroView.Script.MetascriptEditControl.InitializeComponent() at MacroView.Script.MetascriptEditControl..ctor() at MacroView.Script.MetascriptEditor.InitializeComponent() at MacroView.Script.MetascriptEditor..ctor()

Some links that are relevant:

Loading ImageList from resources fails in long test run

Exception: Failed to load ImageList

Threading Issue

It appears from web searches on the problem is that it is likely to be caused by accessing winform controls from other than the GUI thread and/or the visual styles functionality. This theory is re-enforced by looking at the code for the System.Windows.Forms.ImageListStreamer class serialization constructor using Reflector. The constructor includes native platform theming calls and synchronization support. I don't what goes on to cause the fault but it's very subtle and is rare. At first I suspected the Syncfusion (legacy) edit control of perform winform control actions across threads but the debugger showed that although the thread code was there, it shouldn't ever be called in the MacroView Studio application scenario.

IntPtr ptr1 = UnsafeNativeMethods.ThemingScope.Activate();

try

{

MemoryStream stream1 = new MemoryStream(this.Decompress(buffer1));

lock (ImageListStreamer.internalSyncObject)

{

SafeNativeMethods.InitCommonControls();

this.nativeImageList = new ImageList.NativeImageList(SafeNativeMethods.ImageList_Read(

new UnsafeNativeMethods.ComStreamFromDataStream(stream1)));

}

finally

{

UnsafeNativeMethods.ThemingScope.Deactivate(ptr1);

}

if (this.nativeImageList.Handle == IntPtr.Zero)

{

throw new InvalidOperationException(SR.GetString("ImageListStreamerLoadFailed"));

}

Line Margin Selection Edit Control Request

2007-01-05T11:38:00.000+09:00

This post is a request to Syncfusion for an additional feature in their Edit Control functionality. The blog was just a convenient place to put a screencast related to the feature request submitted on their site. Showing a concept rather than describing it in text can often be a better way to communicate.

ADX.NET V2.7 and V2.8 Registry Comparison

2006-12-14T16:55:00.000+09:00

We’re just going through some versioning relating development hassles with the MacroView Excel Addin functionality. This blog post is just a means of placing some images in a public location for reference in the Addin Express forums. It appears that in Version 2.7 of ADX.NET the addin dll’s assembly version number was encoded into the registry as part of the COM component’s .NET load info. See the Assembly registry value below:

In addition, there was a child key whose name matched the DLL version number below the InprocServer32 key:

Now in V2.8 of ADX.NET, there doesn’t appear to be a sub-key and no version number in the Assembly value. This is probably better as there will likely be fewer deployment version issues in the future. Regardless, we are encountering hassles moving from V2.7 to V2.8 – probably because V2.8 can’t handle registering over the top of or unregistering the V2.7 registry info.

WPF/E Linkfest and thoughts

2006-12-06T09:48:00.000+09:00

Yesterday a whole bunch of beta and CTP versions of new Microsoft software was made available. Included was the first CTP (Community Tech Preview) of the WPF/E functionality that was mentioned in my talk on MacroView directions from the recent user group. Its an exciting time with lots of opportunites and pitfalls depending on which direction Microsoft takes this functionality in. This blog post contains a summary of a useful links relating to the recent Microsoft Expression and WPF/E releases. It also includes some thoughts at the end that relate to the MacroView product direction.

First here’s a bunch of videos and screencasts on the new Expression and WPF/E functionality:

A series of official Microsoft links relating to the release:

A series of blog posts from the Expression development team:

A bunch of posts from bloggers (both Microsoft and others):

Check out all of the samples that have been made available. Clicking on the samples will prompt for the download of the WPF/E plugin for IE or Firefox which doesn’t take long to install.

Downloadable Microsoft Sample Pack

My overall impression is that the functionality released is absolutely fantastic and sits well with the direction we have taken MacroView in the last few years. Regardless there are a number of areas of concern. These include:

Microsoft’s interpretation of what the E for “Everywhere” in WPF/E stands for! There has been regular mention of WPF/E being made available by partners on Linux which would be great. The concern is that Joe Stegman didn’t mention the L word once in the recent Channel 9 video even in sections which related to cross platform availability. Together with the recent shannigans/rumblings with Novell and patents gives me cause for concern.
There is too much of an emphasis on separating the designer and developer roles in the Microsoft releases. I personally believe that the world isn’t that black and white.
A seeming side effect of the designer/developer separation is the lack of Expression tools in MSDN offerings: Expression and MSDN Subscriptions. I have been subscribed to an MSDN Universal package for a number of years. Even though Microsoft have changed the product names to protect the guilty, I feel that a top level MSDN subscription should include every Microsoft product that could be construed to be useful to a developer. The universe is certainly getting small these days if the expression suite isn’t available to developers.
The lack of .NET integration at this point in time. There is a firmly stated direction for the integration of .NET byte code functionality so it will happen. The concern is more related to what they have to leave out and how interchangeable code that is used with WPF and WPF/E can practically be. We definitely don’t want a totally separate C# code base for WPF and WPF/E applications.

I am particularly impressed with:

The ease of integration between WPF/E and javascript in the browser.
The small size (just over 1MB) of the plugin at this stage. Though having a small download is important for adoption rate, I am hoping Microsoft don’t go myopic on the download size and make some compromises for getting as much .NET environment functionality in as possible.
The media player functionality included.
The Microsoft Design (previously Graphic Designer) WPF makeover. Its an amazing technical feat given the product GUI just a couple of months ago in the September CTP.
The inclusion of an extension API in the Microsoft Blend product (previously Interactive Designer). This will be particularly useful in being able to edit XAML files for use within a MacroView environment.

All in all the releases open up a bunch of functional possibilities for MacroView development. The key of course will be the .NET support that is slated for around a February release.