Amit Chawla DotNet: All and Sundry

The last time I did any significant Java was in 2001 when I wrote an object bridge to integrate Microsoft COM+ technology with CORBA objects. Back then I was purely a Java guy. It was a rather sweet feeling to be able to accomplish the task. I used the combination of VJ++, IDL2Java compiler and Remote Method Invocation (RMI) technologies to accomplish that. It wasn’t straightforward.

Cut to 2008. The technology world has moved on. The way we do B2B today is by using Simple Object Access Protocol (SOAP). The key is the word, Open. Open, as in Interoperable. Interoperability is not that difficult to achieve, but it is still easier said than done. 

Read more »

Filed under: Technology | 2 Comments »

Just the other day I overheard my friend Amigo having a little technical discussion with his colleagues. His colleagues hang together and sing on similar tunes in great harmony. Therefore, for the purpose of this post I will refer to them as a single entity: ‘peers’.  The subject of discussion was the same as the subject of this post. Here’s how the discussion went:

Peers: Hey Amigo, why have you coded the Web Services layer the way you have?

Amigo: What do you mean? Is there something wrong with that?

Peers: Yes. Why don’t you return DataSets from your Web Methods?

Amigo: Why?

Peers: Don’t you know that they are so functionally rich? They give you a perfect relational view in memory. They have awesome FindBy, GetChildRows style methods. You almost have to do nothing in order to manipulate them.

Amigo: But, they are not very ‘interoperable’!??

Peers: Laughs, giggles, chuckles (in unison)

Amigo: (With great tenacity) And they produce a lot larger payload size.

Peers: More laughs, giggles, chuckles (in unison)

That’s when Amigo agreed to disagree, gave up and went back into his box. After all, Amigo does not care that much.

However, I do. So I have decided put together an example on this blog to explain what Amigo was referring to a little more. Read on if you care…

Read more »

Filed under: Technology | No Comments »

Often you need to employ OO patterns when solving integration problems using XML.

Inheritance is especially useful when you are looking to abstract commonality within a base type. Thus ensuring less redundant code and reuse…

The W3C XSD syntax allows you to create complex types (complexType), import schemas (import), refer to imported schemas using namespaces and inherit types from other types.

Here’s a sample XSD that contain two types, one that derives from the other.

Note that both the Person and Company derive from Entity, using <xs:extension> within the <xs:complexContent> tag.

1. In the specialised schema, use the <xs:import>to import the base schema as follows:

<xs:import id="BaseTypes" namespace="http://somedomain.com/BaseTypes.xsd" schemaLocation="BaseTypes.xsd" />

2. Specify a logical namespace for the imported schema so that it can be reference from code as follows:

<xs:schema xmlns:bt="http://somedomain.com/BaseTypes.xsd"/>

There’s one caveat to having related complex types in separate xsd files. The Microsoft .Net xsd code generator craps out while creating transport classes for these types.

Let me know if you figure that out!

Filed under: Technology | No Comments »

Through 2001 - 2004 timeframe, I used the Web Service Studio 1.0 and 2.0 from gotdotnet.com to great effect. It was the magic tool I needed to inspect/debug soap packets/web services without having to sniff network packets. I could hit breakpoints at will. It was like a dream come true.

While I was working on some middle tier SOAP implementation earlier this year, I went looking for the Web Service Studio 2.0. I could not find it. The gotdotnet.com does not exist anymore. Microsoft formalised its content and made it part of the MSDN! This little tool however, fell through the gaps and seized to exist.

Recently however, I chanced upon Storm. Storm meets the same end. It is an open source project. You can download the Storm here. Storm does what Web Service Studio used to do, except the screens are much more pleasant and configurable.

However, to my astonishment, at the time of writing this post, Web Service Studio has been republished on MSDN. So if you are missing it like did, you can download it here.

Filed under: Technology | No Comments »

I have been using VOIP (PennyTel) now for nearly a year. Initially, this was only my outbound ISD solution. However, recently, upon changing my ISP and moving homes, I decided to pilot this as a primary telephone service for all needs:

1. PennyTel to local/interstate/international PSTN (outbound)
2. Local/interstate/international to PennyTel (incoming)

#1 was tried and tested, so I had absolutely no trouble with that. #2 was where I had one problem.

People had to make several attempts to get through to our PennyTel VOIP line. And when they did get through, the line was unreliable, and had long silence patches

After spending numerous hours with PennyTel technical support and going through my VOIP gateway, Linksys/SPA3102-5.1.5(GWa), configuration options, I figured out the following:

The “PSTN Line” option was not configured properly.

On this tab, I selected the following options:

Enable PSTN Line = yes
Detect VOIP Long silence = yes
Preferred codec = G711a

G711a is the non-USA codec that translates the traditional analouge voice to a 8khz/8bit or 64kbps voice channel.

Voila, the incoming PSTN phone calls have never had a problem since!

Filed under: Technology | 2 Comments »

Let me get this clear first. Unlike rouge traders, a rouge coder is not driven by fear and greed. It is not about allure of boodle. Nobody wants to be a rouge coder. You do not become one suddenly. They either happen to be one, or become one over a period of time. Mostly, they are unaware of their relative rouge-ness.

Here are a few traits that set these people apart:

When asked to analyse, they write code. When asked to design, they write code. When asked to code, they write code. This personality type just jumps head-first in a sincere effort to solve problems. Wether the problems are actually solved, is a completely different story.

As a result of that extreme and instant desire to ‘help out’, these pros end up using the most complex solution imaginable. There are reasons:

• They spend little time on understanding requirements
• Ask questions? Not the ones that matter
• All their tasks are generally 85% complete
• Have just finished fixing ‘the last bug’
• Procrastination is an integral part of their personality. If the software development world was ‘The Ecosystem’, then the rouge coder would be its ‘Koala’ equivalent. For example, they do not modify the code they borrow from other people. Copy database queries from documents/samples straight into stored procedures… ‘Fix’ bugs while doing little or no impact analysis…
• Always have hypothesis on the technology, problem, solution, design-element or a business rule. For example, many years ago I was informed by someone (Verbatim):

In .Net, the global assembly cache is an architecture responsible for compiling assemblies at run time. It is not part of the computer’s file system, but is something that exists solely in memory. It also solves the problem of JIT.

I stopped short of adding:

GAC also solves the larger world problems, such as: population explosion, poverty, and global warming.

Rouge Coders come in handy during the build phase of developing a minefield system.

Do you know one?

Filed under: Humor, Blogroll | 1 Comment »

There are computer systems, and then there are minefields.

Minefields are programs that defy common sense. They are huge, monolithic, untouchable pieces of program logic. Nobody dares to poke around in that space. Once a minefield is established, it lives on for a long period of time. A typical minefield lifecycle has following phases:

Analysis: During this phase stakeholders, combined with the lead-runners from the technology space spend numerous hours in meeting rooms. They discuss everything. All trivial and complex software requirements are analysed. The following formula sums up the principles:

Where E is effort and C is complexity. The effort involved in analysing each problem is inversely proportionate to its complexity. As a result of applying this arcane logic, many problems end up in the ‘too-hard-basket’. This basket sits in a lonely corner and does not find any guardians.

Read more »

Filed under: Humor | 5 Comments »

In my years doing software development for companies, I have seldom come across a place that wasn’t mad.

Wether you are a bunch of rookies, have a flavour of ISO 900x or SEI CMM 1…5 or you eat documentation for breakfast, nothing seems to be able to bring method to madness.

Read more »

Filed under: All in Day's Work, Humor | 4 Comments »

Well, I had been well and truly blogstipated for a while. Most of the past few months were spent being held hostage behind my corporate firewall, Windows Live Writer Installation crapping out permanently, and procrastinating.

Thanks to ScribeFire, I now have a blog writer that actually installs!

Now that all that is out of the way, I am back. I will start posting about:

• patterns
• anti-patterns
• organisational malarchy
• empires and feudal warlords
• idiosyncrasies of software development
• dumbing down of workforce

It might be interesting!

Filed under: All in Day's Work | 2 Comments »

After doing some basic Google searches, I realised that there weren’t enough samples out there that would demonstrate WCF how-does-it-hang-together conceptually. Therefore, I decided to put together one such sample.

Hardly production / best practices compliant, the aim of this article and adjoining sample is to familiarise readers with the key classes and semantics involved in:

• Creating WCF web services
• Hosting WCF web services within IIS
• Hosting WCF web services within a custom server application
• Creating WCF web service clients

Read more »

Filed under: Technology | No Comments »