p u b l i c v o i d . d k

Links for 2010-07-06 [del.icio.us]

Wed, 07 Jul 2010 00:00:00 PDT

Grand Perspective
Disk space analysis

Querying Products by Custom Properties in uCommerce

S�ren Spelling Lund — Fri, 28 May 2010 13:07:28 GMT

One of the questions I’ve come across a couple of times with uCommerce is using the LINQ API to query products by custom properties added to a product definition.

Here’s how:


            var q = from product in Product.All()
            
              where product.ProductProperties.Where(property
=> 
            
                (property.ProductDefinitionField.Name == "MyProperty" && property.Value ==
"MyPropertyValue") 
            
                || (property.ProductDefinitionField.Name == "MyOtherProperty" && property.Value ==
"MyotherPropertyValue")).Count() == 2
            
                && product.ParentProductId == null
            
              select product;

Deleting Purchase Orders and Baskets from the Database in uCommerce

S�ren Spelling Lund — Tue, 25 May 2010 20:55:00 GMT

One thing you might want to do before putting a new uCommerce solution into a production environment is remove any test baskets and orders you might have placed during development. The schema gets a little complicated with the rich functionality found in the uCommerce Transaction Foundation requiring the objects to be removed in a certain order.

Here’s how you go about deleting them.

*** WARNING! HERE BE DRAGONS! ***

Please be aware that running the following script will remove any baskets and orders found in the system with no way to get them back unless you have a database backup handy.


            --DELETE PURCHASEORDERS AND ASSOCIATED DATA
            
              BEGIN
              TRAN
            
              UPDATE uCommerce_PurchaseOrder SET BillingAddressId
= NULL
            
              DELETE
              FROM uCommerce_Shipment
            
              DELETE
              FROM uCommerce_OrderAddress
            
              DELETE
              FROM uCommerce_OrderProperty
            
              DELETE
              FROM uCommerce_OrderLine
            
              DELETE
              FROM uCommerce_Payment
            
              DELETE
              FROM uCommerce_OrderStatusAudit
            
              DELETE
              FROM uCommerce_PurchaseOrder
            
              DELETE
              FROM uCommerce_Address
            
              DELETE
              FROM uCommerce_Customer
            
            --COMMIT

As an added precaution I uncommented the commit statement in case you were wondering why the data isn’t being deleted :)

This post was written for uCommerce 1.0.3.1 (schema version 14).

Links for 2010-05-19 [del.icio.us]

Thu, 20 May 2010 00:00:00 PDT

48GB FileMate SolidGO ExpressCard
48GB FileMate SolidGO ExpressCard 34 mini USB Ultra Solid State Disk

Integrating uCommerce with a Payment Provider

S�ren Spelling Lund — Wed, 19 May 2010 10:52:18 GMT

You will learn how to create a Payment Method Service, which integrates uCommerce with an online payment processer such as Sage, DIBS, PayPal, Cyber Source, or another processor used during checkout. This information is based onuCommerce 1.0.3.x and 1.0.3.2.

Create Visual Studio Project

Create a new Visual Studio solution and choose Class Library for your project type.

Add References to Your Project

uCommerce.dll

uCommerce.Infrastructure.dll

Subsonic.Core.dll

Import Namespaces

Import the UCommerce.Transactions.Payment and UCommerce.Entities namespaces in you class file

Implement interface IPaymentMethodService on your class

The IPaymentMethodService interface gives you full control over the behavior of the service. Alternatively you can inherit from AbstractPaymentService, which gives a default implementation for ProcessPaymentRequest, which will give you a properly initialized Payment.

Implement Name property

The name property is used to uniquely identify your Payment Method Service. It is read from configuration and set on your service at runtime.


              public
              class MyPaymentService
: IPaymentMethodService
            
            {
            
              public
              string Name
{ get; set; } 
            
            }

Implement RequestPayment(PaymentRequest)

RequestPayment can be used in one of two ways: 1) Either to redirect the customer to the remote server handling payment information there, e.g. credit card information, or 2) to simply send payment information received on your server directly to the provider.


              public Payment
RequestPayment(PaymentRequest request) 
            
            { 
            
              //
Package up information for the backend service, 
            
              //
in the form of a http request 
            
              //
Redirect customer to backend service with 
            
              //
the needed information 
            
              //
Payment would be set pending authorization status (the status will have to be added
to the uCommerce_PaymentStatus table) 
            
            }


              public Payment
RequestPayment(PaymentRequest request)
            
            {
            
              //
Processing is happening synchronously so we just
            
              //
call the backend service with ProcessPaymentRequest
            
              return ProcessPaymentRequest(request);
            
            }

Implement ProcessPaymentRequest(PaymentRequest)

ProcessPaymentRequest is used to handle any processing before or callbacks from the remote server in the case of a payment processing being handled exclusively by a remote party.

1) In the case of a callback scenario you use ProcessPaymentRequest to handle the callback and do any needed processing like updating order status. To receive the callback an endpoint needs to be exposed to the remote party such an http handler or a module. The handler or module will call ProcessPaymentRequest to complete the payment.


              public Payment
ProcessPaymentRequest(PaymentRequest request)
            
            {
            
              //
Update payment according to received status from remote 
            
              //
party, e.g. Accepted, Declined
            
              //
Grab any transaction ids and put them on the payment before 
            
              //
returning the Payment
            
            }

2) For a synchronous scenario ProcessPaymentRequest would be used to perform the query to the backing system and create a new Payment according to the result received.


              public Payment
RequestPayment(PaymentRequest request) 
            
            { 
            
              //
Package up information for the backend service, 
            
              //
in the form of a http request 
            
              //
Redirect customer to backend service with 
            
              //
the needed information 
            
              //
Payment would be set pending authorization status 
            
            }

Implement AcquirePayment(Payment)

For legal reason you sually can’t withdraw money from the customer until you actually ship their order. AcquirePayment is ment for this very scenario where you first authorize the payment and later withdraw from their account.

AcquirePayment(Payment) is used for capturing the payment from the customer.


              public Payment
ProcessPaymentRequest(PaymentRequest request)
            
            {
            
              //
Send request to remote party
            
              //
Update payment according to received status from remote 
            
              //
party, e.g. Accepted, Declined
            
              //
Grab any transaction ids and put them on the payment before 
            
              //
returning the Payment
            
            }

Implement CancelPayment(Payment)

If you wish to cancel af payment with your payment method service you need to implement CancelPayment, and have it reach out the remote payment processor. Typical scenarios for cancelling a payment includes a customer return, cancelled order and typically requires you to handle two scenarios: Payment authorized but not capture and payment authorized and captured.


              public Payment
CancelPayment(Payment payment)
            
            {
            
              //
Update payment according to received status from remote 
            
              //
party, e.g. Cancelled
            
              //
Grab any transaction ids and put them on the payment before 
            
              //
returning the Payment
            
            }

Implement CalculatePaymentFee(PaymentRequest)

If applicable, used for calculating the fee associated with the payment method.


              public
              virtual Money
CalculatePaymentFee(PaymentRequest request)
            
            {
            
                var order = request.PurchaseOrder;
            
                var paymentMethod = request.PaymentMethod;
            
                var fee = paymentMethod.GetFeeForCurrency(order.BillingCurrency);
            
              if (!order.SubTotal.HasValue)
            
              return
              new Money(0, 
            
              new CultureInfo(Globalization.CultureCode),
order.BillingCurrency);
            
              return
              new Money(order.SubTotal.Value 
            
                    * (paymentMethod.FeePercent / 100) 
            
                    + fee.Fee, 
            
              new CultureInfo(Globalization.CultureCode),
order.BillingCurrency);
            
            }

Optionally Implement IPaymentFactory Interface on Your Provider

With uCommerce 1.0.3.2 the option for deferred payment requests was introduced meaning that you can create a payment placeholder for the choices made by a user and then later perform the actual payment request to the backend service.

If you need this functionality your PaymentMethodService should implement the interface IPaymentFactory (new for version 1.0.3.2), which will be used for creating the new Payment.


              ///
<summary>
            
              ///
Creates a new payment fully initialized
            
              ///
</summary>
            
              ///
<param name="request"></param>
            
              ///
<returns></returns>
            
              public Payment
CreatePayment(PaymentRequest request)
            
            {
            
                PurchaseOrder order =
request.PurchaseOrder;
            
                var payment = new Payment
            
                {
            
                    TransactionId = Guid.NewGuid().ToString(),
            
                    OrderId = order.OrderId,
            
                    PaymentMethodName = GetPaymentName(request.PaymentMethod),
            
                    Created = DateTime.Now,
            
                    PaymentMethodId = request.PaymentMethod.PaymentMethodId,
            
                    Fee = CalculatePaymentFee(request).Value,
            
                    FeePercentage = request.PaymentMethod.FeePercent,
            
                    PaymentStatusId = 1, //
Status new
            
                    Amount = request.Amount.Value
            
                };
            
              return payment;
            
            }

Copy Your Assembly to Your Umbraco Site

Copy MyUCommerceApp.Library.dll to the /bin folder of your Umbraco site.

Add Your Payment Method Service to web.config

Configure your new Payment Method Service in web.config of your Umbraco site. In the <paymentMethodServices> element of you web.config add the following xml:

Configure Payment Method to Use Your Service

Configure Payment Method to use your new service in uCommerce Backoffice.

Execute Your Payment Method Service from Commerce XSLT Library

You have two options when you need to carry out your payment request: Either create and request a payment in one go by or do a two step request whereby you create a payment, but defer the actual request of the payment to backend service to a later time.

Please note that the two-step request is only available with uCommerce 1.0.3.2 or newer.

Typically the two step approach is used when you’re dealing with a redirect scenario in which part of the payment authorization happens on a remote server.

For a single step request, you'll use this XSLT extension:


            <xsl:variable name="result" select="CommerceLibrary:CreatePayment($paymentMethodId,
-1, true(), true())"></xsl:variable>

or the version with no amount argument, which will default to the SubTotal of the PurchaseOrder, i.e. use this if you only accept one payment per purchase order.

If you need the two step version you’ll use a couple of extensions. First the one which creates a payment for you and second an extension, which performs the request. Please note that your PaymentMethodService must implemention IPaymentFactory for this to work.


              //
-1 is a convenience which will tell uCommerce to grab the total of the order for the
payment
            
              //
The first bool parameter indicates whether to perform the payment request
            
              //
The second bool parameter will overwrite existing payments if set to true (a way to
avoid duplicates)
            
            <xsl:variable name="result" select="CommerceLibrary:CreatePayment($paymentMethodId,
-1, false(), true())"/>

The uCommerce Store executes CreatePayment in the macro called UpdatePayment[XSLT].

To perform the payment request you’ll execute:


              //
Perform request payment for all payments associated with the basket
            
            <xsl:variable name="paymentResult" select="CommerceLibrary:RequestPayments()"/>
            
            - or -
            
              //
Perform request payment for a single payment
            
            <xsl:variable name="paymentResult" select="CommerceLibrary:RequestPayment(paymentId)"/>

Execute Your Payment Method Service from .NET

To execute your Payment Service directly from .NET code you use the following snippet:


              public
              void ExecutePaymentMethodService(PaymentMethod
paymentMethod, 
            
                PurchaseOrder purchaseOrder, decimal amount)
            
            {
            
                var cultureInfo = new CultureInfo(Globalization.CultureCode);
            
              //
Create a new payment request to 
            
                var paymentRequest = new PaymentRequest(
            
                            purchaseOrder,
            
                            paymentMethod,
            
              new Money(
            
                                amount,
            
                                cultureInfo,
            
                                purchaseOrder.BillingCurrency)
            
                                         );
            
                Payment payment = paymentMethod
            
                                .GetPaymentMethodService()
            
                                .RequestPayment(paymentRequest);
            
            }

Links for 2010-05-16 [del.icio.us]

Mon, 17 May 2010 00:00:00 PDT

Burn
There are a lot of ways to approach burning discs. Burn keeps it simple, but still offers a lot of advanced options.

Links for 2010-04-06 [del.icio.us]

Wed, 07 Apr 2010 00:00:00 PDT

smtp4dev
Dummy SMTP server that sits in the system tray and does not deliver the received messages. The received messages can be quickly viewed, saved and the source/structure inspected. Useful for testing/debugging software that generates email.

Links for 2010-04-02 [del.icio.us]

Sat, 03 Apr 2010 00:00:00 PDT

Free SMTP Server

Links for 2010-03-18 [del.icio.us]

Fri, 19 Mar 2010 00:00:00 PDT

Links for 2010-02-03 [del.icio.us]

Thu, 04 Feb 2010 00:00:00 PST

Eagerly loading entity associations efficiently with NHibernate
Eager loading entities with multiple one-to-many associations efficiently.

Multi-Currency for Commerce Server 2009 Revisited

S�ren Spelling Lund — Wed, 03 Jun 2009 12:21:57 GMT

Back in 2007 I was faced with designing a multi-currency catalog solution for Commerce Server. I knew from previous experience that we would need a general purpose solution, which we could employ for many clients.

Back then Commerce Server 2007 was new thus performance characteristics were new territory as well. I ended up designing a solution based solely on virtual catalogs. Basically one catalog for each price group/currency. You can read the details on multi-currency/price groups, which we’ve employed successfully numerous times since then.

Since 2007 we’ve gotten a new version of Commerce Server though no significant new features were added in the catalog system, and we’ve gained valuable new knowledge on both the pricing scenarios and limitation of the Commerce Server catalog system. With that information in hand I’m going to try my hand at redesigning the original multi-currency catalog structure from 2007 to both address performance issues and increased flexibility.

Virtual Catalogs are Slow

Virtual catalogs are slow and so they make a poor choice to expressing essentially a single piece of data. You might say that virtual catalogs perform perfectly well if you materialize them and you would be right. You gain in the order of 10x performance by materializing a virtual catalog but lose the ability to make any changes in them in the process.

Basing my original multi-currency solution on virtual catalogs seemed to make perfect sense, but with the added requirement of changing the category hierarchy two levels of modifiable virtual catalogs were needed, thus the ability to materialize was lost.

To make matters worse we rarely deal with clients who are inclined to go with an Enterprise license for their Commerce Server solution, so we don’t see very many full fledged staged solutions, which would take care of the challenge handily.

Virtual Catalogs Two Levels Deep

Virtual catalogs are by nature limited to two levels, i.e. you can have a total of three levels of catalogs, one with base catalogs and two with virtual catalogs. Are we to use one of these levels of virtual catalogs for pricing we lose it for other purposes, and gain very little other than the ability to store another price group per catalog.

Pricing is a Separate Issue

What I’ve come to realize over the years is that product pricing is a completely separate issue from the product itself. While the two might seem like one and the same; in reality they aren’t. Sure the customer needs to be told a certain price, but more often than not the price is determined by context surrounding the product, rather than the product itself.

An example would be a seasonal business, which is highly dependant on calendar time, the product would probably sell for a higher rate at specific times of the year and lower rates the rest of the year, e.g. ChristmasTreesOnline.com. The context in this particular instance is time.

Now for business to business scenarios the context might be especially convoluted as you might go for pricing granularity, which allow organizations, groups within the organization, even individual people in the organization to have specific prices, e.g. memberships to the gym provided by your company or framework agreements made between supplier and customer. The context deciding the price is who you are in this case, not the product itself.

Pricing is a Service

To handle the separate issue of pricing we need something akin to a service in domain driven design parlance. The service is responsible for looking up the right price based on whichever context is present for a given customer request.

Of course we need some sort of structure to maintain the pricing for individual price groups, and catalogs come in handy to solve this as I’ll show you next.

The Product Catalog

Our product catalog would in the new scheme continue to exist as we know and love it with one minor exception. The list price of the product is either to be ignored or used only to get an idea of what the pricing is like. The list price will not be picked up from the product catalog, which contains the marketing data for a product. Please note that I define marketing data in this instance as data used to display to potential customers, but other than that serve no purpose to the system.

The Pricing Catalog

In Commerce Server we have the notion of different types of catalogs, i.e. the product catalog and the inventory catalog. I’m going to introduce a third kind called the Pricing Catalog. As you might imagine a pricing catalog concerns itself only with price and as such contains only the bare minimum of data to identify a product.

The pricing catalog will have metadata to indicate that it is in fact a pricing catalog. Each pricing catalog reflects a single price group such as “Internet Users”, “Gold Customers”, whatever makes sense for the particular scenario.

Having pricing split out like this means that we can price products based on the calendar time context as a standard Commerce Server catalog has dates associated with it to allow us to display it within only a given period of time.

For a pricing catalog these fields are used to determine whether a price is valid or not, so you could have the seasonal pricing expressed as two different pricing catalogs for our ChristmasTreesOnline.com, one for holiday pricing and one for the rest of the year. The pricing service would then grab the pricing from the proper Pricing Catalog and display it to the customer.

Pricing Definitions

Finally I propose a new kind of definition called the Pricing Definition. What this is is a specialized Product Definition used for creating Pricing in the Pricing Catalogs for advanced scenarios, e.g. complex pricing matrices defined in external systems such as an ERP.

Products, i.e. Prices, created based on a Pricing Definition would contain at least the SKU, name, description, and of course the list price. These specialized products go into a Pricing Catalog as we discussed in the previous paragraph.

Tying it All Together

Another context we discussed in a previous section is the organizational context, which might also influence product pricing. Fortunately Commerce Server comes with CatalogSets as a neat way of bundling catalog together. CatalogSets leveraged with our Product Catalogs and Pricing Catalogs would allow us to do multi-currency and, incidentally, a bunch of even more interesting scenarios.

Imagine if you will a scenario where our online retail outlet would like to give Internet customers access to only currencies, which make sense for their particular region, e.g. here in Denmark Euro and our national currency Kroner would make sense, while UK customers should be enabled to shop in either Pounds or Euro.

Simple! Create two catalog sets one called Denmark and one called UK. For the Denmark catalog set select our one product catalog containing all products or the one which reflects the range available in Denmark and select the two Pricing Catalogs Kroner and Euro. For the UK catalog set select Euro and Pounds Pricing Catalogs.

By way of the metadata on the catalogs we’re now able to display the same range for both UK and Danish customers, but in three different currencies with Pound being available to the British and Kroner available only to the Danish customers.

Blogging on the Mac

S�ren Spelling Lund — Mon, 30 Mar 2009 10:37:30 GMT

So I've been migrating my life over to the Mac that I bought late last year and briefly mentioned in my summary post of 2008. Mostly I'm there but one aspect keeps tripping me up: Which blogging tool to use for posting to the couple of blogs I maintain?

On Windows I'm very happy with Windows Live Writer and I figured that with all the creative writing people of the Mac it wouldn't be an issue at all to find a nice comparable tool on the other side.

Boy was I ever wrong in assuming that. For some reason there isn't really a very good tool which has feature parity with Live Writer on the Mac. The most prevalent tool out there is MarsEdit, which to me doesn't fit the bill. It does everything right in the technical department but lacks in one key area: The editor.

Over the years I've grown accustomed to having a couple of features which really help out in the process of writing a new post:

The tool must be desktop based. Web interfaces are handy but too cumbersome to work with
WYSIWYG editor
Auto creation of image thumbnails with links to the original
Image formatting tools like alignment and custom margins
Support for BlogEngine.NET and DasBlog (categories, upload images via MetaWeblog API)
Ideally rich image formatting features like drop shadow

MarsEdit 2
I don't know about you but I expect to be able to edit my posts in the WYSIWYG interface, which might occasionally require me to drop into HTML view to do some of the more tricky stuff (read: I've done this maybe four time in the five years I've kept a blog). MarsEdit, however, is built on the notion that the writer should have complete control of the HTML and thus provides nothing but raw HTML editing, even billing it as a feature, not a bug. I'm sorry but in 2009 I expect so much more from a tool like that. A tool which even requires me to spend $29,95.

I read a review which describes MarsEdit as being very windowy. I think you'll agree when you take a look at the screenshot below. Basically you've got a window for displaying previous posts, a windows for the raw HTML editor, and a preview window to display what your HTML looks like. Nastylicous!

Qumana
Qumana was my second attempt at reaching a blogging solution on par with what I have on Windows. It was even free so I was off to a great start. Qumana looks like Live Writer enough that I thought I was home free and stopped looking any further. Qumana is a pretty good tool which gets the job done. However, it lacks polish which turned me away from it in the end. No support for picture thumbnails was a huge point for me.

As far as windoyness it's far better than MarsEdit and it does provide a WYSIWYG editor, which was sorely lacking from MarsEdit 2. To sum up Qumana comes close but lacks thumbnail support.

Blogo
Now Blogo is a relatively new tool on the Mac as I understand it. I came across Blogo while listening to Leo Laporte's excellent Macbreak Weekly podcast in which he's got a segment where the panel picks their favorite tool. Blogo was in there and I decided to check it out.

My first encounter with Blogo was a nice one to a certain point when it failed one of my requirements miserably. Read on to find out how.

Hopes were not exactly high when I started using the tool the first time around but that quickly changed as I set out to create my first blog post. Sure image preview was sort of a strange feature in the sense that you get a little standard placeholder which shows you that an image is there. As for actual image preview you're out of luck.

Unfortunately Blogo doesn't support BlogEngine.NET 1.4.5 fully. It seems like it's almost there but posting doesn't happen when categories are in the mix. Editing a post after it's posted to BlogEngine.NET also presents some problems. Blogo "sees" the post but when it's pulled down no content is present inside it. Too bad it's really the only piece of puzzle missing for me to start using Blogo on the Mac instead of Live Writer inside my Fusion virtualized Windows 7 install.

A particularly nice feature of Blogo is its fullscreen editing, which basically allows Blogo to take over the entire screen to focus your attention on the blog post and nothing else. Love it!

All in all I'm not quite there yet. I'm hoping for support for BlogEngine.NET in a future release of Blogo, although I'm not holding my breath in that one. I already contacted the good folks at Drink Brain Juice (yeah I know :)) but nothing has happened as of yet. Crossing fingers and toes as it would see and end to that particular dilemma of my migration.

FeedBurner Migration Broke My Feed

S�ren Spelling Lund — Wed, 28 Jan 2009 14:27:26 GMT

In case you’re wondering why you’re not receiving any updates from my blog in your favorite feed reader, wonder no more. First a little background.

Google last year acquired FeedBurner without much fanfare and everything has pretty much been quiet since then with the minor exception that some paid feature became free.

This all changed recently when the great FeedBurner migration onto the Google platform started, which screwed people up in a number of interesting ways.

My first attempts at migration were unsuccessful due to the fact that one of my feeds did get migrated in the first go, not completely, mind you, just a little bit, leaving me with my feed both at the old FeedBurner site and at the new Google FeedBurner site.

Of course it’s gets quite tricky to determine automatically what to do when someone tries to migrate a feed onto a new platform where another feed with the same name exists. Luckily I figured out what was going on, and being in control of both ends of the equation I removed the duplicate feed and tried again…

Now for the reason why you’re not receiving anything from this blog in your feed reader. The second time around the migration was successful, only Google for some reason can’t access my original feed URL at my ISP, which means that the FeedBurner URL gets a nice HTTP 502 error whenever you, dear reader, tries to access it.

Until this gets resolved between my ISP and Google (like in a million years) I’ve turned FeedBurner off for the site. Once it’s fixed you will automatically received the new feed. The down side is that you’ll have to update your reader to use the old feed URL in the meantime: http://www.publicvoid.dk/SyndicationService.asmx/GetRss

I think this illustrates nicely why you should be weary of the cloud computing trend. Indeed it’s a fine proposition; supposing that everything works as it should. It’s quite another matter when the cloud turns out to be filled with hot air and starts failing. All you can really do is sit back and wait for someone, somewhere to do something.

O as in Open to Change Closed for Modification

S�ren Spelling Lund — Tue, 27 Jan 2009 11:19:30 GMT

Today I read a nice post by Brian Rasmussen in which he describes how to set up Visual Studio to generate class definitions which are sealed by default. I had to post my own point of view in the matter although it is going to be awkward. Not in the teenage, “define me”-sense but in my choice of language as I can’t really quote him effectively, so you’ll have to make do with me paraphrasing his post :)

Now I’d like to put myself in the I-could-not-disagree-more camp. The default choice in my humble opinion should be to leave classes open and have all members be virtual if you want to take it to the extreme. This would leave the system open for change just as the SOLID principles state. Java got it right in my opinion.

To be able to make the decision on whether a class should be open for inheritance you’d have to travel to the future to see what the class might be used for. If you’re anything like me you’re probably challenged in the time travelling department, and so I postulate that you can’t really make a good decision in the matter. More often than not closing the system for change will be the wrong choice as requirements and environments change.

I do agree with Brian’s statement that sealing a class would take away options thus creating a simpler API. I would, however, also like to state that there are better ways of achieving a simple API. How about not exposing the type all? Why not create a simple interface, which exposes only what is needed for the task at hand?

Please don’t make the default choice for your classes sealed. Go with open classes and live a happy life with a system, which is open for change. Trust me I’ve seen systems, which adopted a closed stance and it wasn’t pretty. The team kept hitting the wall in the changes they wanted to make, simply due to the fact that the original developer had no time machine, which enabled him to foresee the changes, which future members of the team needed to implement.

Twitter Inside Your Company

S�ren Spelling Lund — Sun, 25 Jan 2009 06:00:00 GMT

This is going to be the last post in which I mention Twitter… seriously. In fact I’m going to start right now by not talking about Twitter but instead I’m going to focus on a side effect of Twitter: Corporate Tweeting. (You would in fact be correct if you assume that I just made that term up :))

The Vertical Niche

Like Google Twitter has got the market for short public messages pretty much sewn up. Does that mean that there isn’t a market for short public messages anymore? As Google so clearly has shown sewing up the market does mean that others can’t compete in that same market. It’s all about the vertical niche, baby!

Yammer is the New Black

What IMDB is for Google. Yammer is for Twitter. Before I dive into what Yammer is let me start out with a challenge we have at Vertica: As we spread to different geographical locations how do we keep the company spirit going strong? How do we make the departments one coherent company with the same values and a sense of collectiveness?

We spent a couple of meetings debating that very issue and of course the good old ones like doing company outings, shared social events, wax eachother’s backs all came up but for me the most interesting one, aside from waxing eachother’s backs, was to try and use Twitter and also allow for the usual private chit chat which goes on inside a company. Some jokes are best kept inside the company… like you know that waxing one. You get my point right?

Yammer

Yammer has set up shop with a Twitter clone which is ideally suited for running private Twitter-like networks. Bascailly all you need are e-mail addresses on the same domain and you’re golden. Sign up is stupid easy: Enter your e-mail and you’re good to go.

From there is smooth sailed with a nice Adobe AIR client (surprise Adobe AIR is not just for Twitter clients!) which gives you the ease of posting new messages that you’re familiar with from that other netwokr which I won’t mention from here on in.

At Vertica Yammer is quickly turning into a questions and answer service which translates directly into increased productivity because A) You don’t have to know who knows what, you just ask the question and someone will chime in, and B) You don’t interrupt people who don’t want to be interrupted because if they’re not looking they won’t answer.

Now whether or not it will actually serve its original purpose remains to be seen. The new offices in Zealand is still under a month old and quite small so I guess we’ll just have to wait and see. What’s interesting though is that people at the first office were very quickly to adopt Yammer.

Tweet Me Right

S�ren Spelling Lund — Mon, 19 Jan 2009 10:58:14 GMT

In a previous post I wrote about Twitter and what it means to the Danish developer community. The real value of Twitter however does not come by visiting the site from time to time. You have to participate actively to keep the conversation going and that’s where the Twitter clients come into the picure.

I’ve been through a bunch of them and ultimately decided which one I liked the best. I’ll try and spare you from doing the same all over.

Digsby

Digsby gets honorable mention becayse it was my first Twitter client and because this program how I got started with Twitter and in no small way the reason why I still use it.

Digsby is labelled a social network client which gives you access not only to Twitter, in fact that’s the least of it, but also to Messenger, LinkedIn, Facebook, Yahoo Chat, Google Talk, the list goes on and on but you get the point. Digsby speaks with most social networks out there.

That was my reason for trying it out as I really didn’t feel that I needed a dedicated program to try out Twitter. I spent quite some time with Digsby and felt for a long time that it was the way to go. In fact the reason I dropped it was not so much Twitter related as it was Messenger related. It simply didn’t work as advertised, sending file for one was spotty.

As a Twitter client it performed admirably and for me at least it was a low cost to pay for trying out Twitter as I used it primarily as a Messenger client with the added benefit of being able to send out my tweets as well.

Twitterrific

Twitterrific is an interesting one as it didn’t start out on the desktop for me. It actually started out on my iPhone and went I got a Mac late last year it was the natural choice for the desktop as well as the iPhone experience with this thing is flawless as far as I’m concerned.

Now the application is pretty much the same on the Mac. Interestingly it turns out that the functionality doesn’t quite cut it on the desktop. Due to the nature of tweets messages need to be as compact as they can be.

Imagine that you’re posting a link which can easily be 50 - 60 characters; at that point you really want to be able to shorten a link easily and post the short version insteand. Unfortunately Twitterrific doesn’t support this which is fine on the iPhone where cut and paste is not to be found so you tend not to post links. On the desktop though links are thrown left and right so not having the feature is a real pain point – at least for me.

Thus Twitterric was evicted from the Mac desktop but remain on the iPhone as one of the first apps I ever installed on that thing.

twhirl

Before I delve into twhirl a word on Adobe AIR. Not so much because I find the platform interesting but because I find it interesting that as a platform a lot of the ecosystem is made up of … wait for it … Twitter clients. It’s interesting to me that a service like Twitter can drive a platform like AIR and not the other way around.

twhirl is pretty much like Twitterrific only the name is quite a bit easier to spell and it supports the link shortening feature I mentioned above. It being an Adobe AIR app also means that it’s cross platform for those us running cross ethnic platforms out there.

twhirl is like the girlfriend you can’t quite figure out if you want to spend your life with or leave for someone else. I left but ultimately came back so I guess it’s forever between us :)

And finally remember to follow me on Twitter once you get your favorite client up and running :)

Community Back Channel

S�ren Spelling Lund — Sun, 04 Jan 2009 12:41:19 GMT

Back in May 2008 I wrote a short note about me trying out Twitter. At the time I just wanted to know more about what Twitter actually was as I heard about time and again on podcasts, blogs, everywhere really.

Interestingly whenever people talked about Twitter it was due to the service being down but still I felt compelled to take it out for a spin.

Twitter of course is the service which enables you to post little notices about what you’re currently doing which doesn’t sound all that useful until you actually sit down and think about it. In reality it turns out that there are numerous applications for a service like that. The notices are limited to only 140 characters which means that you have to be really short and sweet in the stuff you send to the service.

Fast forward to January 2009 with the experiment done and my conclusion is in: Twitter is indeed a service worth paying attention to. Read on to find out why.

Now what prompted this post is a question I got from Brian Rasmussen when I suggested that he take a look at it. Basically he asked why he should use Twitter, a question I didn’t quite know how the answer with anything but, “it’s cool”. Since that time I’ve been wondering what makes Twitter worth my while and yours as well, dear reader.

Twitter is a lot of things to a lot of people. The value to me and our little community in particular lies in tying together everybody in a more coherent way than what is possible today. To me at least Twitter is a place where I get to keep in touch with a number of the Danish .NET developers in a far more personal way than what is possible at DotNetForum, ActiveDeveloper, etc. because the service is geared for throwing stuff out there without thinking too much about it.

Why do I call it the back channel of our community? Due to the nature of the messages you stick on Twitter it quickly becomes just little notices about what’s going on right now. For example Mads used it to get an idea of which IoC framework to go with, I recently got a Mac and had no clue where to start so I elicited suggestions for apps to use, Niels uses it for communicating with the Umbraco team from time to time, recently Jesper wanted to know what to include in his ASP.NET MVC presentation coming up in ONUG in January, and Rasmus had a memory leak which he needed some input for fixing.

Basically what you get is an inside look in the process leading up to a blog post, presentation, the solution to a giving issue, or whatever; something you don’t really get from reading the final product and often times much more interesting.

I would encourage you to go create an account with Twitter and follow a bunch a people from the Danish .NET community. Morten from DotNetForum was even kind enough to create a wiki with the Twitter names of a bunch of the Danish .NET guys which you can use as a starting point. You can follow me using my Twitter name publicvoid_dk.

Of course there are a number of people which I’d like to see get Twitter accounts like Brian Rasmussen, Søren Skovsbøll, Mark Seemann, Kasper Bo Larsen, and Martin Bakkegaard Olesen,