On the recent project we’ve put in place a messaging platform. Apparently my engineers had a vague understanding what that is. To save you the same trouble I’ve gathered a bunch of interesting resources that can help you get up to date:

Open source Service Bus implementations

• nServiceBux (NSB)
• MassTransit (MT)
• Rhino Service Bus

nServiceBus

• Udi Dahan and NServiceBus (Podcast)

MassTransit

• A First Look at MassTransit
• Producing and Consuming Messages using MassTransit and StructureMap
• MassTransit Endpoints
• MassTransit Samples (Ayende)
• Performance Counters Added to MassTransit

WCF (misc)

• A Developer’s Guide to the WCF REST Starter Kit
• WCF Templates and Tools

Just moved to Git on Windows. It gives me more flexibility for the local repositories and distributed development for my new team.

Found the following series very helpful for the beginners (my engineers never used Git before):

Git For Windows Developers – Git Series – Part 1

Git For Windows Developers – Git Series – Part 2

Git For Windows Developers – Git Series – Part 3

Take a look at Tortoise Git as well. Reduces all the command-line noise drastically:

Now I own the full deck of the Microsoft certifications and I can sit back and relax (beer is in order . Unfortunately, in the startup world that I operate most of the time, it’s not very recognizable achievement, but it’s nice to put these logos on my presentation slide decks and, especially now, I have a very powerful bragging rights – I have ALL of the Microsoft developers certifications !!!

It was a lengthy path and, I should add, a very confusing one. It wasn’t very obvious what certification is a prerequisite to which one and, I must add, I’ve made a couple of mistakes on the road until I’ve discovered a developer’s certification map by Jorgen Thelin that put everything in order and cleared all the confusions.

If you were wondering why there was a silence on my blog – I was preparing for a battle with the Prometric testing computer And I Won!!! Last week I’ve passed my LAST (for the near future) certification exam: Windows Communication Foundation. This gave me another MCT certification -

And finally enabled my long overdue certification MCPD Enterprise Application Developer.

To those who are looking into passing this certification you may use the following materials that I found very helpful (after the break):

MSDN Webcast: Windows Communication Foundation Top to Bottom

by Michele Leroux Bustamante, writer of the “Learning WCF” book by O’Reilly

Part 01: Overview (Level 100)
Part 02: Contracts (Level 200)
Part 03: Contract Versioning (Level 200)
Part 04: Exceptions and Faults (Level 200)
Part 05: Bindings (Level 200)
Part 06: Hosting (Level 200)
Part 07: Messaging Patterns (Level 200)
Part 08: Instancing Modes (Level 200)
Part 09: Concurrency, Throughput, and Throttling (Level 200)
Part 10: Security Fundamentals (Level 200)
Part 11: Federated Security (Level 200)
Part 12: Reliable Messaging (Level 200)
Part 13: Transactions (Level 200)
Part 14: Message Queuing (Level 200)
Part 15: Extensibility (Level 200)

Mike Taulty’s Screencasts: Windows Communication Foundation

Bindings

Type Serialization

DataContract Serialization

Message Encoding
Sessions
Instancing
Message Patterns
Exceptions
Concurrency
Typed and Untyped Messages
HTTPS Transport Security
Transactions
Message Security
Durable Services with WCF V3.5
Using HTTP, XML and JSON in WCF V3.5
Durable Services with WCF V3.5
Offering Syndicated RSS/ATOM Data from WCF V3.5 Services

and more …

Using Windows CardSpace with WCF by Dominick Baier

MSDN Webcast: RESTful Services with WCF 3.5 SP1

Part 1: Concepts and Introduction (Level 200)
Part 2: Security and Scalability (Level 200)

Great series of articles of fine-tuning WCF performance by Rick Rainey:

WCF Instancing, Concurrency, and Throttling – Part 1
WCF Instancing, Concurrency, and Throttling – Part 2
WCF Instancing, Concurrency, and Throttling – Part 3

and much much more … (hint: Google

Check out this great article about how the DinnerNow.net application was ported to Windows Azure – Article.

Don’t forget to listen to the DotNetRocks #471 podcast about this whole process.

Tremendously loved the 43folders podcast, delivered at Google,  about how to manage your Inbox and keep it empty. My advise – follow this religiously. It keeps your life easy, manageably and organized.

[Series 1] Inbox Zero – Google Tech Talk  (permalink is not really working, so use the link to MP3 directly)

43folders RSS Feed

Last week got my MCT certification.   Celebration is in order …

This is the phrase that Jeff Sutherland, one of the inventors of the Agile methodology Scrum, has ended his “A Practical Roadmap to a Great Scrum” presentation at Agile Bazaar meet up this Thursday. Couldn’t agree more. In our day and age of the developer’s ignorance and mediocracy we have to find ways to make them to improve. What is the best way to do this?

Developers love challenge. We breathe and eat challenge multiple times every day. So, why not to pose the general improvement as a challenge in front of a team and in front of each and every developer on the team? I, personally, love the idea.

“Non coding architects are fired”, said Jeff. Awesome! Would love to add to that one thing: in my eyes the non-coding architects are as real as Pegasus (as I’ve heard one of the attendees of the recent Norwegian Developers Conference has put on his t-shirt). All this resonates with the interview of Robert C. Martin (Uncle Bob Martin) by Scott Hanselman (Hanselminutes #171) when they’ve talked about developer’s professionalism.

Bob says that our industry is very young and we’re not yet developed our own professional rituals and discipline. He differentiates ritual from discipline by a simple fact that rituals has actions not backed up by science and explanations, but still very effective in what they provide as disciplines. He adds that Agile development, as a discipline, a great driver forward for the industry to mature and for developers to claim “professionalism”. In addition to that, mentoring should be added as a first class citizen into the expertise development at all levels of the organizations in the industry. The same way, as you don’t want to be in a plain flown by a junior pilot, you don’t want your medical record to be managed by a software developed by a junior developer.

Me, personally, is very happy that there are a lot of different factors from the industry itself and from the co-aligned ones that start to push developers and, hopefully, their management into the process improvement. Little by little we’ll change the industry into a mature one that can ensure professionalism at all levels and niches.

Last, but not least, Software Architects should not only code but be the first ones to learn new processes that improve the quality of the development teams and the processes they follow. They should be the ones to implement them and mentor the rest of their teams. They should hone their expertise and their teams as the Samurais hone their swords.

Push yourself and people around you to be better. Challenge everyone and yourself to be better and what you do. Mentor and transfer your knowledge.

I challenge everyone to participate in the community events. Let’s share our expertise and our knowledge.

Our company was mentioned at the press coverage by the TechTarget. Not everything was quoted correctly, but it’s still nice to be mentioned.

Thanks to all the attendees and organizers of the Cloud Camp!

Many times I’ve been asked to provide a set of Web Services interfaces where both JSON and XML clients can communicate with the server. Primarily it’s done for a set of reasons:

1. XML is very convenient to use for inter-service communication.
2. JSON is great for AJAX (web) clients. It’s perfect for GWT too.

In the recent project we’ve been using XStream for all serialization aspects and, since it can serialize both to XML and JSON, it was plugged into Jersey as a provider too. Following you can see XML and JSON providers implemented using XStream library.

XML Provider (annotated to be a default provider, it’ll be used if no Content-Type or Accept headers provided):

package com.igorshare.myserver.ws;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.HashSet;
import java.util.Set;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.Provider;
import com.sun.jersey.core.provider.AbstractMessageReaderWriterProvider;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.CompactWriter;

@Produces({ MediaType.APPLICATION_XML, MediaType.TEXT_XML, MediaType.WILDCARD})
@Consumes({ MediaType.APPLICATION_XML, MediaType.TEXT_XML, MediaType.WILDCARD})
@Provider
public class XStreamXmlProvider extends AbstractMessageReaderWriterProvider<Object> {
    private static final Set<Class<?>> processed = new HashSet<Class<?>>();
    private static final XStream xstream = new XStream();
    private static final String DEFAULT_ENCODING = "utf-8";

    // Static initializer
    {
        xstream.setMode(XStream.NO_REFERENCES);
        xstream.autodetectAnnotations(true);
    }

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType arg3) {
        return true;
    }

    @Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType arg3) {
	return true;
    }

    protected static String getCharsetAsString(MediaType m) {
        if (m == null) {
            return DEFAULT_ENCODING;
        }
        String result = m.getParameters().get("charset");
        return (result == null) ? DEFAULT_ENCODING : result;
    }

    protected XStream getXStream(Class<?> type) {
        synchronized (processed) {
            if (!processed.contains(type)) {
                xstream.processAnnotations(type);
                processed.add(type);
            }
        }
        return xstream;
    } 

    public Object readFrom(Class<Object> aClass, Type genericType, Annotation[] annotations,
            MediaType mediaType, MultivaluedMap<String, String> map, InputStream stream)
            throws IOException, WebApplicationException  {
        String encoding = getCharsetAsString(mediaType);
        XStream xStream = getXStream(aClass);
        return xStream.fromXML(new InputStreamReader(stream, encoding));
    }

    public void writeTo(Object o, Class<?> aClass, Type type, Annotation[] annotations,
            MediaType mediaType, MultivaluedMap<String, Object> map, OutputStream stream)
            throws IOException, WebApplicationException {
        String encoding = getCharsetAsString(mediaType);
        XStream xStream = getXStream(o.getClass());
        xStream.marshal(o, new CompactWriter(new OutputStreamWriter(stream, encoding)));
    }
}

JSON Provider (Note: it uses different formats for in-stream and out-stream to simplify the AJAX eval() structure):

package package com.igorshare.myserver.ws;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.HashSet;
import java.util.Set;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.Provider;
import com.sun.jersey.core.provider.AbstractMessageReaderWriterProvider;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
import com.thoughtworks.xstream.io.json.JsonWriter;

@Produces({MediaType.APPLICATION_JSON })
@Consumes({MediaType.APPLICATION_JSON })
@Provider
public class XStreamJsonProvider extends AbstractMessageReaderWriterProvider<Object>
{
    private static final Set<Class<?>> processed = new HashSet<Class<?>>();
    private static final XStream xstreamIn = new XStream(new JettisonMappedXmlDriver());
    private static final XStream xstreamOut = new XStream(new JsonHierarchicalStreamDriver() {
	    public HierarchicalStreamWriter createWriter(Writer writer) {
	        return new JsonWriter(writer, new char[0], "", JsonWriter.DROP_ROOT_MODE);
	    }
	});
    private static final String DEFAULT_ENCODING = "utf-8";

    // Static Initializer
    {
        xstreamIn.setMode(XStream.NO_REFERENCES);
        xstreamOut.setMode(XStream.NO_REFERENCES);
        xstreamOut.autodetectAnnotations(true);
    }

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType arg3) {
    	return true;
    }

    @Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType arg3) {
	return true;
    }

    protected static String getCharsetAsString(MediaType m) {
        if (m == null) {
            return DEFAULT_ENCODING;
        }
        String result = m.getParameters().get("charset");
        return (result == null) ? DEFAULT_ENCODING : result;
    }

    protected XStream getXStreamIn(Class<?> type) {
        synchronized (processed) {
            if (!processed.contains(type)) {
                xstreamIn.processAnnotations(type);
                processed.add(type);
            }
        }
        return xstreamIn;
    }

    public Object readFrom(Class<Object> aClass, Type genericType, Annotation[] annotations,
            MediaType mediaType, MultivaluedMap<String, String> map, InputStream stream)
            throws IOException, WebApplicationException {
        String encoding = getCharsetAsString(mediaType);
        XStream xStream = getXStreamIn(aClass);
        return xStream.fromXML(new InputStreamReader(stream, encoding));
    }	

    public void writeTo(Object o, Class<?> aClass, Type type, Annotation[] annotations,
            MediaType mediaType, MultivaluedMap<String, Object> map, OutputStream stream)
            throws IOException, WebApplicationException {
        String encoding = getCharsetAsString(mediaType);
        xstreamOut.toXML(o, new OutputStreamWriter(stream, encoding));
    }
}

Note: XStream is rapidly falling out of my favor and  many people I’ve recently talked too because of it’s quirks and a limited control over the serialized structure. Recently I’ve started using JAXB as a primary serialization mechanism. Stay tuned – I’ll post the JAXB examples too.

Reference: I’ve found another reference that covers the same topic – XML Provider on XStream and JSON provider on Json-lib.