Code to Live, Live to Codefavicon.ico2008-07-03T07:53:00.5208750-04:00Randy PattersonRandy Patterson's BLoghttp://randypatterson.com/DasBlogTop Developer Podcasts Part IIhttp://randypatterson.com/PermaLink,guid,64914677-63f2-4e00-8459-4df93414beb1.aspx2008-06-27T17:21:25.7311250-04:002008-07-03T07:53:00.5208750-04:00
It's been six months since my previous article "10
Podcasts Every Developer Should Listen To" so I thought I would do a follow up
article outlining some of the new quality podcasts available to developers.
Despite the unhealthy name of this podcast it covers a healthy variety of IT Topics.
If I've missed any developer related podcasts that you find helpful please let me
know.
I am Speaking at the Next IASA Meetinghttp://randypatterson.com/PermaLink,guid,4126183c-4443-4927-bf3c-5b28d9d282c2.aspx2008-06-25T09:30:20.6146250-04:002008-06-27T14:08:57.3580000-04:00
The Microsoft Unity Application Block is a lightweight Dependency Injection Container
that is currently being incorporated into the latest releases of Enterprise Library
and the Composite Application Library (Prism). This session will give an introduction
to Dependency Injection and Inversion of Control concepts and a brief overview of
how to use the Unity Application Block to build loosely coupled applications.
My goal is to finish by leading a discussion on the pros and cons of Dependency Injection,
Loosely coupled and Tightly coupled components. When we leave I hope everyone will
have a deeper understanding of these principles and how and when to apply them.
When & Where:
Thursday, June 26, 2008 from 06:30 PM - 08:30 PM (ET)
Microsoft Corporation
3000 Bayport Drive
Suite 480
Tampa, FL 33607
View
a map View
1-Click Directions
Please be aware that the outside doors lock and the elevators need a security key
after 7:00 PM.
The goal of the Alt.NET podcast is
to release a new episode every week or two. The first episode is a talk with Mike
More, David Laribee, Jeremy
D. Miller, and Chad Myers about
continuously improving yourself, your code, and your team. Great episode, give
it a try!
Add this to my previous
post of developer podcasts you should listen to.
]InBetween[ Microsoft Community Summit 2008 - Free Weekend of Traininghttp://randypatterson.com/PermaLink,guid,8623a115-af05-48f7-8edf-15d04242ea4d.aspx2008-05-07T17:48:30.6762500-04:002008-05-07T17:48:30.6762500-04:00
The Orlando Convention Center was not being used between TechEd Developer week and
TechEd ITPro week. Microsoft has graciously donated the convention center to
be used by the Florida Developer Community! There are 9 large conference rooms
that will be filled for 2 days with presentations from Local, Microsoft and
TechEd Speakers. In addition to the full day tracks listed below there will
also be discounts
on MS Certification Exam Tests, an MCSA/MCSE:
weekend upgrade bootcamp, a Developers
Weekend Exam Cram and Train
the Trainer sessions. ALL FOR FREE!!!
Saturday, June 7th Activities - 830a to 530p
Full Day Tracks
Description
SQL Saturday
Best of the SQLSaturday events with some special product team reps attending.
Open Space
Four corners of a room with whiteboards. Sign up for a 30 minute talk on whatever
topic you want
our corners of a room with whiteboards. Sign up for a 30 minute talk on whatever topic
you want
ToolShed
Russ Fustino and Stan
Schultes come together with encores of "Its all about the Tools" episodes 1 and
2, plus all new episodes 3 and 4
OCS University
OCS MVP Keith Kabza and Tom
Cross will get you up and running on Office Communication Server in a day
.NET University
Doug Turnure's flagshihp series of structured
courses geared to bring you up to speed on a particular topic. Three separate
all day courses are being offered, including Sharepoint, Service Oriented Development
in .NET 3.5, and BizTalk. Something for almost everyone!
VSTS University
Tentative - Doug Seven and the Redmond guys hang around to teach you VSTS. Learn from
the VSTS team themselves.
This is an incredible opportunity for learning with enough variety for everyone.
A special thanks goes out to our local Microsoft Developer Evangelist, Joe
Healy for organizing the event and creating the effective but very ugly web site.
The Unity Application BlockIoC
Container comes with a little know extension for creating loosely
coupled events called the Simple Event Broker. The Unity Event
Broker supports multiple publishers and multiple subscribers to the same event name.
The decoupled model prevents subscribers from knowing about publishers and publishers
from knowing about subscribers.
The Event Broker source code can be found under the Unity Quick Starts normally located
here
This gives you two new Attributes recognized by Unity, [Publishes(eventName)] and [SubscribesTo(eventName)] where eventName is
a string that uniquely identifies the loosely coupled event.
The attribute [Publishes] is applied to an event and lets the event broker
know that when this event is raised, any methods that are subscribed to eventName are
called.
For Example:
[Publishes("event://Transaction/Complete")]
public event EventHandler TransactionComplete;
Best Practice:
It is recommended that you not hard code the Event Name parameter. Instead use
a class that contains the event names as public string constants.
This prevents typos in the event name string and also allows a Usages Search in Visual
Studio to quickly locate all Publishers and all Subscribers of an event.
The event broker will create a loosely coupled event named "event://Transaction/Completed"
[1] and link the .NET event TransactionComplete [2]to it. The
following subscriber code
informs the Event Broker that method TransactionCompleteHandler [3] needs to be called
whenever the loosely coupled event named "event://Transaction/Completed" is published.
Notice that neither the publisher nor the subscriber is aware of the other.
Conclusion
The ability for your application to communicate between controls without resorting
to directly linking one class to another increases the reusability of your code.
The Unity Event Broker is, as it's name implies, a rather simple implementation of
loosely coupled events but it is a good start none the less. for example,
I would like to see a way for subscribers to indicate that methods should be called
on a background thread instead of always on the Publisher's thread. In future posts
I will show how to register events for publication when you cannot add the [Publishes] attribute
directly to an event declaration (useful for Button and Menu Click events or third
part controls)
I use the URL style string to name the decoupled events purely out
of habit. Obviously, any string will do but I find the URL format to be clean
and easy to read.
Events must be scoped public in order for the Event Broker to detect
the Publishes attribute
The subscription method must be scoped public in order for the Event
Broker to detect the SubscribesTo attribute
Lazy Instantiation with Unity Application Blockhttp://randypatterson.com/PermaLink,guid,90df538c-feee-483d-b914-ed2dd54ef119.aspx2008-03-29T20:48:37.0568750-04:002008-03-31T17:59:12.8065854-04:00
Out of the box, Unity does not provide a way to configure your dependencies so that
they are resolved only if needed. Lazy Instantiation would be desirable if your
dependency is and required only under certain circumstances or you would like to delay
object creation of a resource intensive dependency until needed.
For Lazy
Instantiation, the first obstacle to overcome when using IoC
Containers like Unity,
is to have your components get a reference to the container so the dependency creation
can be delegated to it when the need arises. My first inclination was to wrap
Unity in a Singleton and
have the component reference this in order to resolve the dependency.
Container.Instance.Resolve<IProductService>();
Singleton's are, however, notoriously difficult to test and very rigid in design.
Used in this manner, a Singleton is nothing more than a global variable wrapped
in a buzzword. so I wanted a different approach. Since we are using a Dependency
Injection Framework, why not have the container inject a reference to itself into
our components.
1. First, configure the Unity container so that it can return a reference to
itself.
2. Next, create a property on your class to get a reference to the Unity container
that created it.
3. Finally, have the container resolve the dependency the first time it's referenced.
Unit Testing
Testing is straight forward as well. You could have your unit test use
reflection to reach in and set the private field (_productService) to your mock object.
However, giving your Unit Tests access to private members violates the "Use
the Front Door First" Test Automation Principle and should be avoided if possible.
Alternatively, you could create a mock object for IUnityContainer and have it return
a mock object for IProductService when the Resolve method is called.
Using RhinoMocks,
the Unit Test would look something like this:
MSDN Article on Dependency Injectionhttp://randypatterson.com/PermaLink,guid,efd6bd04-951e-4c16-9a8c-745434a4847e.aspx2008-03-24T19:16:10.7336250-04:002008-03-24T19:16:10.7336250-04:00
The FREE Orlando Code Camp will be on Saturday, March 22, 2008. Last year's Orlando
Code Camp had 481 registered attendees, 52 sessions, and 38 speakers. If you are looking
for free .NET developer training by hardcore .net developers in the Florida community,
mark your calendar for this year's Orlando Code Camp.
Beginning Test Driven Development
In this session I will discuss Unit Testing Goals, Principles and Philosophies
such as Test First, Test Last and the dreaded, Test After. Learn what creating good
unit tests mean and how it will help improve the quality of your applications.
The Unity Application Block
The Unity Application block is a lightweight, extensible dependency injection container
with support for constructor, property, and method call injection. Microsoft has finally
developed an Inversion of Control (IoC) container that will appear in the Enterprise
Application Block. In this session I will introduce the basic concepts of Dependency
Injection and review how the Unity Application Block is used.
Tampa Bay International Association of Software Architects Newsletter - January 2008http://randypatterson.com/PermaLink,guid,e97c00c2-a59b-4de0-8378-4ad92ef5841e.aspx2008-01-29T18:13:40.8652832-05:002008-01-29T18:30:26.1437756-05:00
This Month's Meeting
When:
1/31/2008 6:30 PM - 8:30 PM
Topic:
The Perfect Pattern Storm, where TDD meets UX and MVP.
As host of ARCast.TV, Ron Jacobs has a front row seat to observe the constantly shifting
architectural landscape. In this session we will consider what happens when the force
of test driven development (TDD) collides with the demand for better UX.
Speaker:
Ron Jacobs is an Architect
Evangelist in the Microsoft Architecture
Strategy group based at the company headquarters in Redmond Washington. Since
1999 Ron has been a product and program manager on various Microsoft products including
the .NET Framework, Windows Communication Foundation and
COM+. A top-rated conference speaker, author and host of the podcast show ARCast.TV,
Ron brings over 20 years of industry experience to his role of helping Microsoft customers
and partners to build architecturally sound and secure applications.
Design Pattern Overview:
David Hayden will be presenting an overview
of the Factory pattern
Unit Testing Principles and Goalshttp://randypatterson.com/PermaLink,guid,96f4180b-f6ff-46f0-8d53-8c96786af4e7.aspx2008-01-12T20:37:54.6150469-05:002008-01-18T21:00:42.6721432-05:00
I'm giving a presentation at the Lakeland
Users Group this Tuesday, January 15, 2008 from 6:30 PM - 8:30 PM entitled
"Unit Testing Principles and Goals".
I will discuss Unit Testing Goals, Principles and Philosophies such as Test First,
Test Last and the dreaded, Test After. Learn what creating good unit tests
mean and how it will help improve the quality of your applications. Learn to
leverage to power of Test Drive Development and, when necessary, how to write Unit
Tests for existing code.
Location:
2525 Drane Field Road, Suite 10
Lakeland, FL 33811
Martin Fowler has a Podcast!http://randypatterson.com/PermaLink,guid,0a6e16d7-e41f-4f19-80c6-62c7d6488eec.aspx2007-12-11T22:00:26.0000000-05:002007-12-12T13:13:22.1478750-05:00
ThoughtWorks has
a new IT
Matters Podcast that discusses the business and technology issues facing the IT
Industry. The First topic is on Domain Specific Languages Part 1 of 2. A panel
of ThoughtWorks employees including, Martin
Fowler, Dr.
Rebecca Parsons, Neal Ford and Jay Fields; all participate in a discussion around
domain-specific languages (DSLs).
Topics include:
1. How to build effective DSLs
2. When to use a DSL
3. What pitfalls to avoid
4. Some real-world examples of DSL best practices.
10 Podcasts Every Developer Should Listen Tohttp://randypatterson.com/PermaLink,guid,3f5ba0f3-4b7e-47ae-93f5-deec4d3d8b14.aspx2007-12-04T19:23:05.2922206-05:002008-06-27T17:27:27.6061250-04:00
One of the best ways that I've discovered to keep up to date with the constant change
of technology is to listen to podcasts. I find this a great way to learn during
my daily commute and exercise regiment (refilling my coffee AND getting the mail).
One thing I would encourage is to attempt to listen while coding. If you can
listen to music while you code you can probably listen to podcasts with little effort.
Everyone is different but here is what I've discovered about myself.
If both ears are listening to a podcast I get too distracted and cannot concentrate
enough on coding.
If I listen using my right ear, I grok almost
nothing of the podcast content.
If I listen with my left ear, it seems to be a good balance between listening and
doing.
I've heard of some who code while listening to a podcast in double speed to save time.
I can't do that but, apparently, some can.
Here are the podcasts I find invaluable as a developer
Craig Shoemaker brings insight into software development in the .NET platform along
with interviews with industry luminaries. Good content, good quality but an inconsistent
schedule.
.NET Rocks! is a weekly talk show for anyone interested in programming on the Microsoft
.NET platform. The shows range from introductory information to hardcore geekiness
The ASP.NET Podcast brings a technology focus to the area of podcasts. This
podcast is geared towards developers with applications that scale to a large amount
of data and users.
I would like to hear what others are listening to and what software you use to manage
your podcasts. I have a love/hate relationship with ITunes.
Get SnagIt and Camtasia for FREE!http://randypatterson.com/PermaLink,guid,68de0328-baa6-4a5a-bdbb-c0efccaf9eb2.aspx2007-11-26T20:56:53.4522688-05:002007-11-26T20:56:53.4522688-05:00
Right now Techsmith is offering Camtasia and Snag-It for
free. You download the demo then register for a free license key. These
are previous versions of the software but they are still feature packed and will solve
most of your screen capture needs.
Visual Studio 2008 Express Releasedhttp://randypatterson.com/PermaLink,guid,6668dfc0-88d0-4c88-b63d-a3ca3da6ad91.aspx2007-11-24T09:57:43.2450779-05:002007-11-24T09:57:43.2450779-05:00
If you don't have an MSDN subscription and you can't wait to try out the new Visual
Studio 2008 features you can download the express edition and learn the new features
while you wait for the professional edition to be available in stores.
Tampa Bay International Association of Software Architects (IASA) Monthly Meetinghttp://randypatterson.com/PermaLink,guid,cedd2d04-d3e0-409a-a961-073576dc9574.aspx2007-11-12T18:14:04.9810340-05:002007-11-12T18:19:30.7039532-05:00
When: 11/28/2007 6:30 PM - 8:00 PM
Abstract: You can run, you can switch jobs, and you can write unit
tests, but invariably at some point you will run into legacy code. Legacy code hides
in many forms - sealed classes, spaghetti and big-ball-of-mud code, data in disparate
data sources (or incompatible schemas). As an architect, there are steps you can take
to get ahead of these issues and begin to make your codebases something you actually
want to change. In this talk, we will discuss concepts from Michael Feathers' work
on Working Effectively with Legacy Code as well as Scott Ambler's work on refactoring
databases. You'll see tips and tricks to model your legacy code and data, and hear
about ways to begin to turn your legacy code into a usable base."
Speaker: Cory
Foy is an agile developer passionate about languages such as C# and Ruby. He currently
works for Microsoft as a Premier Field Engineer, has been a developer on the NUnit
team, and is known to speak at code camps and user groups across the country. He lives
just north of Tampa with his wife and 2 daughters.
Tampa User Group Meeting for Octoberhttp://randypatterson.com/PermaLink,guid,5b552ac1-5784-4d2c-acc7-7d5d8ae282bc.aspx2007-10-02T18:26:40.1000000-04:002007-10-06T09:22:23.7221250-04:00
Speaking in Tampa on October 18th - Repository Factory, Enterprise Library, Guidance
Bundles
The focus is on the new Repository
Factory, which is a software factory from Microsoft Patterns & Practices that
will generate a data access layer for your winform and web applications in minutes.
It generates business entities, stored procedures, and repository classes from an
existing database within Visual Studio. In addition he will also be showing off the
following:
How to design a Fluent Interfacehttp://randypatterson.com/PermaLink,guid,7b10ffdb-58f4-4ec0-bbe6-714cdc92e864.aspx2007-09-26T13:25:09.5120000-04:002008-05-06T12:11:36.7009592-04:00
Martin Fowler coined
the term "FluentInterface"
to describe objects that expose an interface that flows, and is designed
to be readable and concise. The cost of this fluency is additional effort required
to design the interface for your object and the slight increase in complexity.
These types of interfaces are often utilized to create configurations for your objects
but can progress into an internal Domain
Specific Language or DSL.
Configuration Fluent Interface Example: (sometimes called Method Chaining)
Order
.AddFreeShipping()
.IncludeItem(10)
.SetQuantity(2);
Fluent interfaces are best explained by showing some code examples, so I'll take the
rather prosaic Person object and create a fluent interface for it.
Take a common Person object and write some code to instantiate and Initialize
the object
public class Person
{
private string _firstName;
private string _lastName;
private int _age;
public bool _isActive;
public Person(string firstName, string lastName, int age, bool isActive)
{
_firstName = firstName;
_lastName = lastName;
_age = age;
_isActive = isActive;
}
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
public string LastName
{
get { return _lastName; }
set { _lastName = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
public bool IsActive
{
get { return _isActive; }
set { _isActive = value; }
}
}
This is a common pattern where the constructor is used to quickly set the properties
of the class. The initialization code would look something like this.
Person person = new Person("Frank", "Pat",
30, true);
Although this code is concise it is not very readable. Is "Frank" the first name or
the last name? What does the value true represent? The
readability issue becomes more problematic as the number of construction parameters
increase. One solution, and the point of this post, is to write a Fluent
Interface for our Person class. The idea here is to allow each property
to be set through a method call and then have that method return a reference to itself
so you can continue on with next method call (often called method chaining).
person.SetLastName("Frank").SetFirstName("Pat");
This makes our code concise and far easier to read, we now know that "Frank" is the
last name. However, an obvious issue with this pattern is that we are now cluttering
up our class with methods that, when taken out of context, make little sense.
We have a FirstName property and a SetFirstName method
defined on our class that obfuscates the intent. A better approach is to create an
internal class that is accessed through a Set property
and exposes only the Fluent
Interface.
public class Person
{
public Person()
{
_set = new PersonFluentInterface(this);
}
private string _firstName;
private string _LastName;
private int _age;
private readonly PersonFluentInterface _set;
private bool _isActive;
public PersonFluentInterface Set
{
get { return _set; }
}
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
public string LastName
{
get { return _LastName; }
set { _LastName = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
public bool IsActive
{
get { return _isActive; }
set { _isActive = value; }
}
public class PersonFluentInterface
{
private readonly Person _person;
public PersonFluentInterface(Person person)
{
_person = person;
}
public PersonFluentInterface FirstName(string firstName)
{
_person.FirstName = firstName;
return this;
}
public PersonFluentInterface LastName(string lastName)
{
_person.LastName = lastName;
return this;
}
public PersonFluentInterface Age(int age)
{
_person.Age = age;
return this;
}
public PersonFluentInterface IsActive()
{
_person.IsActive = true;
return this;
}
public PersonFluentInterface IsNotActive()
{
_person.IsActive = false;
return this;
}
}
}
Now the code is clean, concise and quite readable.
Person person = new Person();
person.Set.FirstName("Pat").LastName("Frank").Age(30).IsActive();
Conclusion
This pattern for fluent interfaces is often seen in object configuration and setup.
It's fairly easy to design and the objects configuration options are readily discoverable
using intellisense. As the complexity of an objects setup increased, a fluent
interface becomes a more attractive option to ease the initialization burden.
International Association of Software Architects, Tampa Chapterhttp://randypatterson.com/PermaLink,guid,642f10c8-0c1c-4a45-980a-6c68577696fa.aspx2007-09-23T10:52:56.6790000-04:002007-10-06T09:35:28.5971250-04:00
This is the inaugural meeting for the Tampa chapter of IASA. In this meeting
we will discuss a number of topics about the group and what to expect going forward.
We are also fortunate to have a Microsoft Architect Evangelist coming into town to
speak.
Speaker: Jeff Barnes, Microsoft Architect Evangelist
Topic: The Role of the Software Architect
Abstract: This session will explore the role of the Software Architect -
from defining what the job role actually entails, what it takes to be successful at
it, and what steps you can take to become a software architect (or a better one) today.
This session will be highly interactive and should lead to lively group discussions
and audience participation.
Useless Unit Testhttp://randypatterson.com/PermaLink,guid,d7f0c7ab-fb1a-49c0-9639-925472f53184.aspx2007-09-21T08:10:15.4274295-04:002007-09-21T08:10:15.4274295-04:00
This is one of the most useless unit tests I've encountered
/// <summary>
///A test for GetByLegalCaseID (int)
///</summary>
[TestMethod()]
publicvoid GetTicketByLegalCaseID_Test()
{
TicketEntityModel target = new TicketEntityModel();
int ID = 1;
TicketDataSet actual = target.GetByLegalCaseID(ID);
Assert.IsNotNull(actual, "TicketDataSet was
not returned.");
Assert.IsNotNull(actual.Citation, "No Citation table was
returned.");
Assert.IsTrue(actual.Citation.Rows.Count > 0, "No
Citation rows were returned.");
Assert.IsNotNull(actual.Ticket, "No Ticket table was returned.");
Assert.IsTrue(actual.Ticket.Rows.Count > 0, "No
Ticket rows were returned.");
}
Unit tests in the Entity Model should concentrate on testing business logic, not Data
Access Layer (DAL) logic. Unit
tests for DAL objects test
data access issues. Furthermore, this Unit Test simply checks to
see if the current database has a record with an ID of 1 and, therefore, is non-deterministic.
It can fail for many reasons that have nothing to do with the business
logic. If GetByLegalCaseID has any business logic in it then unit tests should
to be written to test that logic and the dependencies on the DAL would
be mocked so a previously setup DataSet is returned with known values. This falls
under the "What Burns Me" category.
The Power of the Predicate<T>http://randypatterson.com/PermaLink,guid,2c56cd60-9195-4ed8-b3b5-2dab2a6721a7.aspx2007-09-18T20:40:57.9490000-04:002007-09-23T17:14:26.8998805-04:00
The very flexible generic collection List<T> contains
several methods that take a predicate as
it's parameter. Coupled with Anonymous
Methods this provides powerfully concise code for filtering, searching and sorting
your collections.
List<Person> People = new List<Person>();
People.Add(new Person("Randy", "Patterson",
40));
People.Add(new Person("John", "Smith",
15));
People.Add(new Person("Caity", "Johnson",
13));
People.Add(new Person("Jody", "Patterson",
39));
People.Add(new Person("Chloe", "Dog",
30));
People.Add(new Person("Corey", "Patterson",
18));
For Example, to filter the collection and display only my family members requires
a single line of code
Sorting requires a Comparison<T> delegate
instead of Predicate<T> but
operates in much the same fashion.
For example, sorting by last name requires this single line of code:
People.Sort(delegate(Person x, Person
y) {return x.LastName.CompareTo(y.LastName) ;});
a slight modification will sort the list in descending order:
People.Sort(delegate(Person x, Person
y) { returny.LastName.CompareTo(x.LastName);
});
To sort by Last Name then First Name would look something like this:
People.Sort(delegate(Person
x, Person y)
{
if (x.LastName == y.LastName)
return x.FirstName.CompareTo(y.FirstName);
else
return x.LastName.CompareTo(y.LastName);
});
Conclusion
I've just scratched the surface on what the generic List collection is capable of
providing. There are several other generic methods that take delegates as parameters,
such as ForEach and ConvertAll,
that open up interesting possibilities in your code. Overall I find the
Anonymous Method syntax a bit kludgy but
C# 3.0 promises to reduce the syntactical noise and give us true (almost) Lambda
Expressions.
Free Conference Calls in less than 60 secondshttp://randypatterson.com/PermaLink,guid,51d7f112-1fe4-4d36-9995-7d35f8e63bfc.aspx2007-09-15T19:50:29.9627920-04:002007-09-17T09:01:58.9482295-04:00
Not really related to software development but Instant
Conference is one of those gems occasionally found while surfing the tubes.
You just give them an email address and you get back a conference number and an access
code........that's it! The dial in number and access code are dedicated to you and
never expire. While in the conference there are many advanced features such
as Conference
Recording and Presentation
Mode.
I've used my number several times and found the quality to be pretty good and the
features easy to use. If you record your conference you'll get an email in an
hour or so that will allow you to download an MP3 file.
A nice feature for verifying your notes.
Welcome back to my Blog.
I've had a blog for awhile but, due to a heavy work load, I haven't posted anything
in over a year. In the past year I've implemented many of the principles of GTD to
better manage my professional, personal and online time. This will, hopefully,
allow me to Work, Live and Play without the stress involved in miss-managing time.
I've also removed my previous Blog and
blog postings and started fresh with a new version of DasBlog and
new postings. It was a pleasant surprise to see the maturity of the blog engines as
well as the software to help you post your content. I am currently using Windows
Live Writer for content publishing, which has a very active community for Plug-in's.
