This one is the latest of my poems, written recently for my daughter’s first birthday in the beginning of the year.

No translation yet to English so only the Hebrew version for now. The English name for this poem would be “Your Journey”. I’ll try to publish the translation soon.

Without further ado:

~ המסע שלך ~

זוג רגלים קטנות

זוחלות והנה

כבר הולכות

תכף רצות.

התחלת מסע,

גדול הוא ממך

וממני

אך את התחלת.

זכרי שתהיה לך תמיד

עצה ויד חמה

עזרה ותמיכה

ביקורת ותובנה

האמיני בדרך

ובאבנים לרגליך

גם בחדות שביניהן

האמיני בשיר

ובמנגינה

האמיני באהבה

היא לנצח שלך.

עשי.

האמיני בך.

הקשיבי ללבך

ולמילים שברוח

שמעי לרזים שמספרת

זכרי זריחה

זכרי תמיד תקווה

רסיסי מראה שנשברה

ישרטו כפותייך

אך סודות יגלו

אם עינייך תפקחי.

הסופה תקפיא עצמותיך

אך גם תשטוף הפצעים.

השלט בתחילת הדרך

לא תמיד מספר סיפורה

האור מבעד לחלון

לא בהכרח השמש

ודלת סגורה

לאו דווקא נעולה.

השמרי נא

מפרחים צבעוניים

שלרגליהם אין אדמה

התרחקי ממלכים

של דקה

מאלה המציעים עזרה

בעוד שידם שבורה.

אמצי אליך הטיפה

בין אם דמעה

או מזיעה

חבקי את הדרך

והמלאכה

שכן ארוכה היא

ומרובה

אך לא בודדה

אני שם איתך

תמיד

במסע,

שלך.

Written: 23/11/2012, Gi’vat Shmuel, Israel.

Back in July of 2011 (has it been that long ago?) I published what was my latest poem in Hebrew Eich Nifradim (How to Part).

I revisited that poem recently and decided to take a crack at translating it to English and I think it actually turned out quite nicely.

This poem holds a dear place in my heart as i read it in my grandfather’s funeral in the summer of that year…

So here it is:

~ How to Part ~

How to part

How to say goodbye

When there is no another-time to hope for

Which word to choose for last

How do you part and just walk away

Which touch to embrace, what caress to savor

Which tear immortalize

How do you part?

The stump that stood so tall

Now the wind shakes without rest

The stump that stood once and protected

That held experience of years and knowledge

Now left lost and frail

The one that showed the way

Now fumbles in the dark

When the time of sunset is past

And the red turns black.

How to part

When to release thy hand

How to leave and not look back

Which heartbeat you just let skip

How to stay standing and go on

How do you part?

Perhaps with a new life

A tiny grain of hope you promise

When its time for sunrise again

The colors return in bloom

joy and pain coalesce inside

perhaps a new beginning can be hoped

a new blossom aspired

maybe that is how,

you part.

Translated: 15/02/2013, Israel.

Here’s an excerpt:

4,329 films were submitted to the 2012 Cannes Film Festival. This blog had 21,000 views in 2012. If each view were a film, this blog would power 5 Film Festivals

Click here to see the complete report.

In the first part of this article I showed how I’ve been testing code using MEF and a generic base class that is in charge of wiring up the dependencies.

In this part I will focus on how I got WCF to wire up my web service using MEF in what I think is quite an elegant way.

My first requirement was to be able to write a web service that will use dependencies (imports) but that wouldn’t require me to write the composition code in the service class itself. Most of the examples I saw online didn’t provide me with a good way to do that unfortunately.

Until I came across this excellent post by Tim Roberts which shows how to tap into the WCF pipe-line and have your services composed automatically instead of having to do it per service or including wire-up code in your classes.

While the code Tim provided was a great start I thought it wasn’t just right for me. Specifically it was the fact that it required custom code in the Global.asax file which for me was not as elegant as it should be.

So I’ve done a bit more digging into the WCF pipe-line and discovered that I could achieve an elegant, completely configuration-based solution by implementing my own endpoint behavior.

In the end I needed to only create 3 classes to achieve this: EndpointComposedElement, ComposedEndpointBehavior and ComposedInstanceProvider.

By the way, if you’re interested in the WCF pipe-line in general there is a nice diagram here: http://andrewtokeley.net/archive/2008/07/31/wcf-simplified-to-a-single-diagram.aspx.

Now, onwards to the code:

EndpointComposedElement

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Configuration;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition.Hosting;
using System.Reflection;
using System.ServiceModel.Configuration;

namespace SampleApplication.Web.ServiceModel
{
    public class EndpointComposedElement : BehaviorExtensionElement
    {
        [ConfigurationProperty("assemblies")]
        [ConfigurationCollection(typeof(NameValueConfigurationCollection))]
        public NameValueConfigurationCollection ConfigAssemblies
        {
            get
            {
                return (NameValueConfigurationCollection)this["assemblies"];
            }
        }

        public override Type BehaviorType
        {
            get { return typeof(ComposedEndpointBehavior); }
        }

        protected override object CreateBehavior()
        {
            ComposablePartCatalog catalog = null;

            var configTypes = ConfigAssemblies;

            if (configTypes != null)
            {
                var assCatalogs = new List<AssemblyCatalog>(configTypes.Count);

                assCatalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); //first add the current assembly

                foreach (NameValueConfigurationElement nvce in configTypes) //add any additional assemblies from the configuration
                {
                    assCatalogs.Add(new AssemblyCatalog(Assembly.Load(nvce.Value)));
                }

                catalog = new AggregateCatalog(assCatalogs);
            }
            else //no configuration, only use the current assembly
            {
                catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            }

            var container = new CompositionContainer(catalog);

            return new ComposedEndpointBehavior(container);
        }
    }
}

This class creates my custom behavior and passes to it the initialized CompositionContainer with the assemblies it found configured(see configuration) and the assembly its running in (GetExecutingAssembly()).

ComposedEndpointBehavior

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Channels;
using System.ComponentModel.Composition.Hosting;

namespace SampleApplication.Web.ServiceModel
{
    public class ComposedEndpointBehavior : IEndpointBehavior
    {        
        private readonly CompositionContainer container;

        public ComposedEndpointBehavior(CompositionContainer container)
        {            
            this.container = container;
        }

        public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
        {}

        public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
        {}

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
        {
            ComposedInstanceProvider provider = ComposedInstanceProvider.CreateProvider(endpoint.Address.Uri.ToString(), 
                endpoint.Contract.ContractType, container);

            if (provider == null) throw new InvalidOperationException();

            endpointDispatcher.DispatchRuntime.InstanceProvider = provider;                            
        }

        public void Validate(ServiceEndpoint endpoint)
        {}        
    }
}

This custom behavior’s role is to attach the ComposedInstanceProvider to the configured end-point. This behavior class which was initialized by the EndpointComposedElement already received the initialized container and therefore can create the custom Instance Provider with the container it received.

ComposedInstanceProvider

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ServiceModel.Dispatcher;
using System.ComponentModel.Composition.Hosting;
using System.ServiceModel.Channels;
using System.ServiceModel;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition;

namespace SampleApplication.Web.ServiceModel
{
    /// <summary>
    /// from: http://www.timjroberts.com/2011/08/wcf-services-with-mef/
    /// </summary>
    public class ComposedInstanceProvider : IInstanceProvider
    {
        private static Dictionary<string, ComposedInstanceProvider> providers = 
                new Dictionary<string, ComposedInstanceProvider>();

        private readonly CompositionContainer container;

        public Type ServiceType { get; private set; }

        private ComposedInstanceProvider(Type serviceType, CompositionContainer container)
        {            
            ServiceType = serviceType;
            this.container = container;
        }

        public static ComposedInstanceProvider CreateProvider(string address, Type serviceType, 
                                        CompositionContainer container)
        {
            ComposedInstanceProvider provider = null;

            if (providers.ContainsKey(address))
            {
                provider = providers[address];
            }
            else
            {
                provider = new ComposedInstanceProvider(serviceType, container);
                providers.Add(address, provider);
            }

            return provider;
        }

        public static ComposedInstanceProvider GetProvider(string address)
        {
            if (providers.ContainsKey(address))
            {
                return providers[address];
            }

            return null;
        }

        public object GetInstance(InstanceContext instanceContext, Message message)
        {            
            return GetInstance(instanceContext);            
        }

        public object GetInstance(InstanceContext instanceContext)
        {            
            Export export = GetServiceExport();

            if (export == null)
            {                
                throw new InvalidOperationException();
            }

            return export.Value;
        }

        public void ReleaseInstance(InstanceContext instanceContext, object instance)
        {
            throw new NotImplementedException();
        }

        private Export GetServiceExport()
        {
            var importDefinition
              = new ContractBasedImportDefinition(AttributedModelServices.GetContractName(ServiceType),
                                        AttributedModelServices.GetTypeIdentity(ServiceType),
                                        null,
                                        ImportCardinality.ZeroOrMore,
                                        true,
                                        true,
                                        CreationPolicy.Any);

            return container.GetExports(importDefinition).FirstOrDefault();
        }
    }
}

Finally, the custom Instance Provider provides the WCF pipe-line with the instance of the service class already initialized and with imports fulfilled because the provider received the initialized composition container from the custom behavior.

Web Service & Configuration

To be able to tie these things together I used the system.serviceModel configuration section like this:

<system.serviceModel>
    <extensions>
      <behaviorExtensions>        
    <add name="endpointComposed" type="SampleApplication.Web.ServiceModel.EndpointComposedElement, SampleApplication.Web"/>
      </behaviorExtensions>
    </extensions>
    <behaviors>
      <endpointBehaviors>
        <behavior name="jsonBehavior">
          <enableWebScript/>
      <endpointComposed>
        <assemblies>
            <add name="sampleApplication" value="SampleApplication"/>
        </assemblies>
          </endpointComposed>
        </behavior>                
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="SampleServiceAspNetAjaxBehavior">
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug httpHelpPageEnabled="true" includeExceptionDetailInFaults="true"/>         
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <services>
      <service name="SampleApplication.Web.Services.SampleService" behaviorConfiguration="SampleServiceAspNetAjaxBehavior">
        <endpoint address="json" binding="webHttpBinding" behaviorConfiguration="jsonBehavior" contract="SampleApplication.Web.Services.ISampleService"/>
        <endpoint address="" binding="basicHttpBinding" contract="SampleApplication.Web.Services.ISampleService"/>
      </service>
    </services>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true"/>
  </system.serviceModel>

First, I declared my custom behavior extension under the <extensions> element. Then I defined the extension’s contents under the <endpointBehaviors>/<behavior>/<endpointComposed> section and provided the assembly name I wish to have used as part of the composition.

Finally I linked all of this behavior to my service’s endpoint using the behaviorConfiguration attribute on the endpoint element.

What of all of this allowed me to do is the ability to create a service class without any kind of wiring code as well as write tests for my service using the same exact process I’ve explained in the first part of this article. I am now able to take this code to existing and new projects alike and not have to write any custom code for the composition anew each time.

Here is my service class:

public class SampleService : ISampleService
{
    [Import]
    private ISampleSentenceService sentenceService;

    public string GetHelloWorld()
    {
        string response = null;

        try
        {
            response = sentenceService.GetSentence();
        }
        catch (Exception ex)
        {
            response = "ERROR!";
        }

        return response;
    }        
}

No composition or wiring code here…

And here is a test I’ve written for it:

[TestClass]
public class SampleServiceIntegrationTest : AutoTestBase
{
    [Import]
    private ISampleService service;

    [TestMethod]
    public void TestGetHelloWorldSuccess()
    {
        string expectedResponse = "Hello World";

        string response = service.GetHelloWorld();

        Assert.IsNotNull(response);
        Assert.AreEqual(expectedResponse, response);
    }
}

Here is the test configuration XML I used for my SampleApplication.Web.Test project:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="testConfiguration" 
        type="SampleApplication.Test.Base.Configuration.TestConfigurationSection, SampleApplication.Test.Base"/>
    </configSections>

    <testConfiguration>
        <Assemblies>
          <add name="sampleapplication" value="SampleApplication"/>
          <add name="sampleapplicationWeb" value="SampleApplication.Web"/>
        </Assemblies>        
    </testConfiguration>
</configuration>

Naturally, The web service itself works just fine and can be accessed by an HTTP request:

Conclusion

I was very happy to reach my goal of easily creating web services and tests alike without going through the hassle of managing dependencies manually or having to write a lot of wiring code just so my objects can play together.

While I have found this approach to work in several small applications this is not tested in Production or in large scale applications so if you plan on using this please thoroughly test and I’d of course love to hear feedback.

Code

Ive uploaded the code sample to BitBucket here: https://bitbucket.org/yoavniran/wcf-mef-and-testing-sample-code

This article will focus on how I’ve adopted unit testing in .NET using MEF and how to also apply this to WCF web services.

I haven’t been dedicated to unit testing for a long time but once I started I couldn’t stop. There are many great benefits to doing unit tests, I wont list them here but a good article to read is at: Agitar.com

What made me build something on my own? I wanted something light that I could also integrate into existing code without making too many changes. So I focused on a couple of things: Testing and Dependency Injection. I wanted an elegant solution that didn’t rely on external libraries or that will require a steep learning-curve.

In this article I will focus on these topics and how I solved it for myself. I’m not going to dive into other topics such as The SOLID principals, TDD, Dependency Injection, Mocking, etc. If these terms are not familiar to you, I suggest you read up on them first.

I’m actually going to divide this article into two parts, to keep them shorter and to the point:

• This first part will discuss how to do testing with MEF.
• The second will discuss how to use MEF and test for a WCF service.

Sample Solution

The entire code sample (in C#) for this article is available through here.

The solution I’ve created to demonstrate the concepts is a simple one that includes a project with the “business logic”(SampleApplication) which is in charge of retrieving words from a file and then concatenating them into a sentence. I’ve separated the tasks involved into different objects to demonstrate the composability and separation of concerns that will typically take place in a real project.

On top of the BL I’ve included a web application project(SampleApplication.Web) that contains the WCF service which exposes the functionality through a web service.

Of course, I’ve also added the test projects that test that everything is working as it should.

Testing

The testing library I’ve chosen to use is the one built into .NET and Visual Studio, not because it’s the best, its actually alright to use (definitely not great), but because it’s the only one that has a somewhat decent integration with Visual Studio.

I’ve tried using NUnit but there is no good integration with the IDE, the ones I found were quite awful.

Next, being able to test your code effectively relies a lot on the way you write your code and whether you follow concepts like Inversion of Control and Cohesiveness. The closer you follow the best practices the easier it becomes to test your code and really makes a difference in whether you can create specific unit tests that test a very limited scope of functionality as they should.

Managing dependencies between objects is therefore very important and while you can do it yourself there are frameworks dedicated to achieving just this. I’ve been following MEF(Managed Extensibility Framework) for a few years now, well before it became part of the official .NET framework and I find it very simple yet powerful to use.

Small note: The MEF version I’m using for the samples in this article is the one that shipped with .NET 4 and not any of the newer previews available on the codeplex site.

I’m not going to go into how MEF works or how to use it in any detail, you can read more about that here. The following piece of code shows how an object makes itself available as an export (the Export attribute):

[Export("spaceConcatenator", typeof(IWordConcatenator))]
    public class SpaceWordConcatenator : IWordConcatenator
    {
        ...
    }

The following code shows how that object can be imported (the Import attribute):

public class HelloWorldSentenceService : ISampleSentenceService
{
    [Import("spaceConcatenator")]
    private IWordConcatenator wordConcatenator;

    ...
}

While I was looking for examples on how to use MEF in a real application many of them show the composition taking place inside the application’s objects. Many examples show constructors that either define the CompositionContainer and/or accept it as a parameter. To me this looks wrong. I don’t want my plain objects to be aware of MEF any more than they should and I don’t want composition logic in my objects. I want these separate so there is less dependency on MEF and if needed, that I could replace MEF with another framework without having to gut half of my code.

Because of this requirement I came up with the structure where for my test projects the composition is done by using a test base class all tests inherit from and for my web application the composition happens in the WCF pipeline (second part).

I wanted a way to create tests without having to keep writing wire up code. For that purpose, i wrote a test base class that will take care of everything. I also wanted a simple way to pass to it the assemblies needed for the composition. So i chose to create a small configuration section that allowed me to configure the assembly names:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="testConfiguration" 
        type="SampleApplication.Test.Base.Configuration.TestConfigurationSection, SampleApplication.Test.Base"/>
    </configSections>

    <testConfiguration>
        <Assemblies>
            <add name="sampleapplication" value="SampleApplication"/>
        </Assemblies>        
    </testConfiguration>
</configuration>

I’ve divided my tests into two main types: those that test functionality without mocking and those that test functionality while mocking out the dependencies.

No Mocks

The tests that don’t need any mocking can inherit from my AutoTestBase abstract class. This class calls the AutoWire function of the TestBase class in its constructor without any parameters. The AutoWrite function looks at the XML configuration and passes the assemblies to the CompositionContainer.

So when my test methods are called any import should already be fulfilled and the tests can be carried out.

Here’s an example of a test class like that:

[TestClass]
public class WordProviderTest : AutoTestBase
{
    [Import]
    private IWordProvider wordProvider;

    [TestMethod]
    public void TestGetWordsSuccess()
    {
        IEnumerable<string> words = wordProvider.GetWords();

        Assert.IsNotNull(words);
        Assert.AreEqual(2, words.Count());
        Assert.AreEqual("Hello", words.First());
    }
}

Notice that there isn’t even a single line of wire up code in this class which is what my goal was.

Yes Mocks

My mocking tool of choice is Moq. It’s a great library with excellent support for Linq and Lambda expressions.

For tests that do require mocking, there is a bit more work to do but not much.

This part of the solution took me probably the most time to figure out and I couldn’t have done it without the code sample I found here: http://pastie.org/467842. I adapted it a bit but basically what it allowed me to do was to create an ExportProvider which is filled with the mocked objects. This provider is passed into the container first so the mocks will be the ones used to satisfy the imports and not the real implementations.

Here’s an example test that is in charge of testing my HelloWorldSentenceService, here I’m not interested in testing its dependencies so I mock them and pass the mocks to my MockExportProvider in the constructor, I then call base.TestSetUp(provider) to initiate the composition:

public class HelloWorldSentenceServiceUnitTest : MockTestBase 
{
    [Import]
    private ISampleSentenceService service;

    private Mock<IWordProvider> wordProvider= new Mock<IWordProvider>();
    private Mock<IWordConcatenator> wordConcatenator = new Mock<IWordConcatenator>();

    public HelloWorldSentenceServiceUnitTest()
    {
        var provider = new MockExportProvider
        (
            GetExport<IWordProvider>(wordProvider),
            GetExport<IWordConcatenator>(wordConcatenator, "spaceConcatenator")
        );

        base.TestSetUp(provider);
    }

    ...

How it Works

The code in the TestBase class is pretty straightforward and below is the main AutoWire function that ties everything together:

protected void AutoWire(MockExportProvider mocksProvider, params Assembly[] assemblies)
{            
    CompositionContainer container = null;

    var assCatalogs = new List<AssemblyCatalog>();

    foreach(var a in assemblies)
    {
        assCatalogs.Add(new AssemblyCatalog(a));
    }

    if (mocksProvider != null)
    {
        var providers = new List<ExportProvider>();

        providers.Add(mocksProvider); //need to use the mocks provider before the assembly ones            

        foreach (var ac in assCatalogs)
        {
            var assemblyProvider = new CatalogExportProvider(ac);                    
            providers.Add(assemblyProvider);
        }

        container = new CompositionContainer(providers.ToArray());

        foreach (var p in providers) //must set the source provider for CatalogExportProvider back to the container (kinda stupid but apparently no way around this)
        {
            if (p is CatalogExportProvider)
            {
                ((CatalogExportProvider)p).SourceProvider = container;
            }
        }
    }
    else
    {
        container = new CompositionContainer(new AggregateCatalog(assCatalogs));
    }

    container.ComposeParts(this);        
}

What it does is to collect the assemblies passed to it in an AggregateCatalog and pass it into the composition container. If a MockExportProvider is passed, it will be pushed into the container first so the mocks will be used to match any relevant import. Once the container is set I call ComposeParts on the test class so any of its dependencies and their own dependencies are fulfilled by MEF.

Thats it for now. In the second part of this article I discuss how to set up a WCF service using MEF.

Code

Ive uploaded the code sample to BitBucket here: https://bitbucket.org/yoavniran/wcf-mef-and-testing-sample-code

LivePerson UK is heavily involved with Naomi House and has been working with the hospice for several years to raise money and volunteer to help make it a better place.

Just a few weeks ago I had the opportunity to visit Jacks Place which is an extension of Naomi House dedicated to young adults who come to stay there with their families to get some relief, assistance and comfort. Before arriving I had a picture in my mind of a rundown shack, a place perhaps out of Oliver Twist’s story but I was greatly mistaken. Jacks Place is a modern and fully equipped hospice with vast grounds and gardens. Beautiful and spacious rooms for the teens who come to stay there.

It was really inspiring and moving to have had the chance to spend a few hours and help with the gardening of Jacks Place. An activity I plan on doing again soon.

In the meantime, This June LivePerson is having its 4th Dawn to Dusk challenge where we will walk in the mountains of North Wales in order to raise funds for this amazing and important place.

Please help reach our goal of £8,000.00 by going to this page: LivePerson Dawn to Dusk 2012 and giving whatever you can. Just so you know, every amount counts.

For example:

• £5 could provide art materials for life-limited children and young people to create treasured memories during their short break at Naomi House
• £25 could fund our music room for a day, so that children and young people, regardless of their ability, can enjoy the pleasure of creating and experiencing music
• £50 could run our sensory room for a day, enabling children and young people from across our region to enjoy having their senses stimulated
• £100 could fund one day in our end of life suite, where a child or young person can stay after they die and where their family can be close by until the funeral

Thank you!

The site was first released about a couple of weeks ago in a very limited, invite only mode and a few lucky participants have gotten to use it and I have received some excellent feedback that to the greater part I’ve managed to incorporate in this release. Others will be added later as well as more features and improvements I already have in mind.

Let me start by saying that your feedback is  crucial for the site to succeed so please keep it coming in any form you can. I can be contacted here through comments, on Twitter at @important_t_com and by email.

This new release is packed with new features, improvements and some bug fixes. Below is a list of the major ones to notice:

Chronological Mode

Now it is possible to switch from the Important Tweets mode to Chronological mode so you can see tweets on your home timeline just like on Twitter or in your preferred client (thanks @nunolinhares). Simply click on the clock tab at the top of the column:

Auto Refresh

From now on the site will automatically refresh the stream every once in a while. This can be managed through the settings dialog which you see when you right-click on the refresh button in the top panel or by tapping and holding the button on touch devices (hold until the dialog is shown):

You can turn off the auto refresh completely or set the interval you prefer (between 30 and 999 seconds).

Signing Out

An important feature, especially if you’re on a public or shared computer, the Sign Out button will ensure that a re-login is necessary before being able to use the site on that device again:

Invite a Friend

Now that the site has been running for a little while with no major problems I believe its time more users should get to use and enjoy it, therefore the first users that are already invited will be able to invite a few friends themselves. Those friends will be able to invite more friends of their own. If you do have the option to invite people please do so for the site to get more recognition and continue to grow:

More…

The new release contains many more improvements such as performance tuning and additional logic for the relevancy engine so hopefully you should be seeing even better results.

In the meantime, if you’re an invited user go ahead and continue using the site and keep up the feedback communication. If you haven’t received an invite and would like one just let me know and i’ll send it.

You can keep up with the site on the Twitter account: @important_t_com.

I am very happy to announce that today I’m officially making my project named ImportanTweet available on the web!

The idea behind ImportantTweet is to show the tweets that are important to you so if you follow a considerable number of accounts on Twitter and it becomes difficult to keep track and you feel like you miss on tweets you find interesting, IT is the tool for you.

IT uses an engine that evaluates the latest tweets in your home stream and through its algorithm attempts to display tweets in the order it thinks will be most important to you rather than by chronological order, allowing you to quickly find the tweets the matter most to you.

If you’re like me, and follow over a hundred accounts on Twitter, it becomes very difficult to read every single tweet that passes through your stream. Even with your favorite Twitter client open at all times it’s not always possible, you may be in a meeting or on a plane or changing your daughter’s diaper and those important tweets will simply go by never to be seen again…

That is why I built ImportanTweet, so I don’t miss as much on Twitter as I have up until now. Of course IT is not perfect (yet) and it is going to be a learning experience both for me and the tool as I will be working on improving it.

BETA

Today I am releasing IT in beta (version 0.1) and in limited trial mode so it will not be open for everyone just yet. I will be sending invites to a few people to begin testing and collecting feedback and hopefully  soon will be able to improve and make it completely open for everybody.

Browser Compatibility

To make the tool as useful as possible I’ve made sure it works well on all major browsers: Firefox, Chrome, IE as well as on mobile devices such as iPhone, iPad (iOS 5) and Android (2.3). so you can use it on your prefered device at all times.

Looks

This is how the site looks like:

I’ve attempted to give it a clean and simple design so the focus remains on the tweets and nothing else.

Teach IT

The bar at the top of the page contains a few options, click or hover over it to show them. Click the button to show the information which contains explanations about these.

The most important option is the word-selection mode which lets you click on any word within the tweets and store it as an “Important Word” which will let the engine know that you are interested in future tweets that contain these words.

You can also click on the avatar photo  of each user displayed in the list of tweets to promote or demote that user, this will tell the engine to make tweets from this user more relevant or less.

Getting Started

So ImportanTweet is starting out today and will continue to evolve. There are plenty of things I plan on adding and improving so make sure to come back here for updates and check out ImportanTweet.com and let me know what you think. You can comment here or send me an email at contact@importantweet.com.

I looked online and found a pair of very nice white-gold earrings that I had hoped she will like on Overstock.com,  a site I had heard good things about and thought is a reputable brand that I could trust. The fact that they had online chat on their site bolstered that feeling as I’m a LivePerson employee I can now recognize and appreciate the value of live chat on a retail site. Overstock is not a LivePerson customer by the way (perhaps that should have tipped me off).

I have ordered the earrings on December 23rd, 2011 and of course I knew they will take some time to arrive, after all it was just before Christmas but that was fine with me, I had hoped they will arrive a few days after the new year.

After they did not arrive for a while I looked at the confirmation email I received and used the tracking link they provided, this took me to the DHL tracking site which very “usefully” told me it couldn’t find the details for the tracking number. I thought to myself, alright, I will try in a few more days, surely it will appear soon.

So I have waited some more and still nothing, so a few days ago I contacted Overstock through their online chat. They kindly told me to wait 7 days (!) longer before contacting them again if the earrings hadn’t arrived by then. So I’ve waited a few more days until yesterday when the DHL site still couldn’t find the tracking details. I had resolved to contact Overstock again today even though it wasn’t 7 days yet and demand some explanations. Luckily, this morning the package with the earrings arrived.

Oh joy! I thought to myself, finally, the earrings arrived and even before its time for my daughter to attend college. Gladly I opened the package and was very (very) surprised to find that they have sent me the wrong earrings, the ones I ordered were suppose to have a clear stone, what they sent were (disgusting) lime green!

So, I patiently waited for the overstock.com reps to come online today so I can demand they replace the earrings at once and hopefully give me some kind of compensation after such a terrible shopping experience.

This afternoon I started the chat and after apologizing the representative told me that all he could do for me is send me instructions on how to send the earrings back and receive a refund, if I wanted to actually receive the earrings I wanted I would need to order them again. When I told the rep that I was surprised they don’t offer any kind  of compensation he told me that they simply can’t offer anything to an international customer. So they can take orders from international customers but not compensate them when the blunder horribly.

So to summarize:

• Ordered earrings 3 weeks ago
• Paid a lot more for shipping costs because I’m an international customer
• Waited for 3 weeks for earrings to arrive
• While waiting had no proper information on when they will actually arrive (not sure whos fault that is, overstock or DHL)
• Overstock when contacted couldn’t tell me more than wait for more days, 7 days!
• When finally earrings arrived they were the wrong ones!
• I need to ship them back and get a refund (that for some reason is 70 pence less than what I paid)
• If I want the earrings I actually paid for I need to go through the whole process again

In short, I will never shop at overstock.com again, not because they’ve made a mistake with the product they sent, although that’s already infuriating but these things happen. It’s because their customer care is seriously lacking. The reps I chatted with were friendly and sympathetic enough but hardly went out of their way to help and as an international customer I feel I’ve been completely neglected by their customer care that apparently doesn’t value me the same as an American customer.

Throughout the overstock site and even the chat they refer to me as “Valued Customer” but its one thing to say it and quite another to actually mean and behave like you mean it! As far as im concerned, they have done the bare minimum and nothing more, this is not a brand I would like to have any more dealings with.

Just for comparison, a couple of weeks ago I returned a jar of Pesto sauce to Sainsbury’s  (UK Supermarket) that costs around 2 pounds because it went bad too quickly, not only did I receive my money back, I also received a 5 pound voucher! More than 200% compensation on top of the refund…

Very interestingly I just received an email asking me to fill in a survey to help Overstock advance their “worldclass customer care“. I think they need to advance quite a lot before they can call their service that. Dont worry, I will let them know!

Below is the full transcript from my last chat with overstock:

Cody: Hi, my name is Cody. How may I help you?

Valued Customer: hi

To do that I need to call the fadeIn and fadeOut jQuery methods in sequence. This can be done easily because fadeIn accepts a callback as a second parameter which will be called when the animation completes.

Easy as it is to do I still find it annoying that i have to call two separate methods for an action i wish to be done as one so naturally since it is so easy to extend jQuery I wrote a little extension that does just that.

Here is the code:

(function ($)
{
	/*
 This is a shortcut method for jQuery that does a fade In and then a fadeOut on the selected element(s)
 It accepts the length of the In animation, the length of the Out animation and a handler to be called when both animations completed 

 Yoav Niran (http://wordpress.yoavniran.com)
 */
	var defaultDur = 1000;

	$.fn.fadeInOut = function(inTime, outTime, callback)
	{
		var setDefaults = function()
		{
			inTime = outTime = defaultDur;//set a default 1 second for animation
		};

		if (arguments.length == 0)
		{
			setDefaults();
		}
		else if (arguments.length == 1)
		{
			if (typeof( arguments[0]) === "number")
			{
				outTime = inTime;
			}
			else
			{
				callback = inTime;
				setDefaults();
			}
		}
		else if (arguments.length == 2)
		{
			if (typeof( arguments[1]) !== "number")
			{
				callback = outTime;
				outTime = inTime;
			}
		}

		var c = this;

		this.fadeIn(inTime, function()
			{
				c.fadeOut(outTime,
					function()
					{
						if (callback && typeof(callback) === "function")
						{
							callback.apply(c);
						}
					})
			});
	};
} (jQuery));

To use it you just need to add this code somewhere on your page or (preferably) in a separate JS file as long as its after the inclusion of jQuery and before you intend to use it.

Once you’ve added this code using the function is the same as using any jQuery method.

The new method that will be added to jQuery is called: fadeInOut and it accepts 3 (optional) arguments: inTime, outTime and callback.

The inTime is the duration of the fadeIn animation.

The outTime is the duration of the fadeOut animation.

The callback is a function to be called when both animations complete.

A few examples of using the fadeInOut method:

$("#myElement").fadeInOut(); //use 1 second default

$("#myElement").fadeInOut(500); //use half a second for fade in and out

$("#myElement").fadeInOut(500, 1500); //use half a second for fade in and a second and a half for fade out

$("#myElement").fadeInOut(500, 1500, function () { alert("finished"); }); //set in and out durations and a callback method

There are 4 ways you can call the method:

1) No arguments – The fade in and out will both be called with a default duration of 1 second.

2) One argument – If its a number it will be used as the duration for both in and out animations, if its a function it will be used as the callback and the 1 second default will be applied.

3) Two arguments – If both are numbers they will be used for the duration of the in and out animation respectively. If the second is a function it will be used as the callback and the first number will be used as the duration for both animations.

4) Three arguments – first two arguments will be used for the animations in and out duration respectively. The 3rd argument will be used for the callback.

You can easily change the default duration time by changing the value passed to the “defaultDur” variable.

Hope you find it useful.