CaseySoftware's biggest project right now involves the integration of numerous XML data sources into a single unified database. Each of the data sources consists of the same type of data, but each is in its own - sometimes proprietary - format. Please don't ask me how unencryped XML can be truly proprietary, but in the schema docs there are numerous "Confidential" and "Proprietary" warnings.

Therefore, I cannot find any examples of these documents online to do simple testing. I have dug deep into Google using the relevant terms and keywords and still nothing. The worst part is that there are actually a handful of public standards available in this domain, but nearly all of the big players have developed their own schemas. Therefore, you need a custom tool/process each and every schema.

I can't see the sense behind this.

XML is a powerful idea. Having a simple cross platform/language data structure that is human-readable goes a huge way towards making things simpler for everyone involved. This all goes out the window when you have every single player pulling in a different direction.

I worked at the Library of Congress and was involved in the creation of their XML Metadata Standards and they seem to have the right idea in terms of creating their XML Schemas by getting all of the major players together and attempting to address needs early in the process. Maybe part of this is because the LoC is the 300lb gorilla of the bunch, but sometimes someone must take the lead.

Otherwise you end up with more XML standards than there are developers to support them.

Q: What's Microsoft's biggest strength?
A: The fact that it is the defacto standard in desktop environments and has a fairly customizable yet standard user interface.

Q: What's Microsoft's biggest weakness?
A: I can't answer this one directly, but one of the arguments against Windows has been the issue of stability.

My answer for years was simple: Microsoft should build a windowing system that runs on top of the Linux kernel. There's nothing stopping them from doing it. It could *probably* still be proprietary - sorry, not a lawyer, it would allow them to keep their huge strength and they could completely kill the stability argument.

After all, isn't this essentially what OS X is?

Well, finally other people are starting to catch up with me. As found on Slashdot today, John C. Dvorak of PC Mag sees this as Microsoft's chance to kill Linux. He believes that this would allow MS-Linux to become the dominant distribution of Linux and eventually developers would drop away from Kernel development due to hatred of Microsoft.

While I think the first half is a plausible scenario, I believe the second half is completely wrong. Sure it would tick developers off, but the kernel hackers are not newbies who will simply roll over and find something else to do. They're a whole different breed.

These people will see Microsoft's involvement as an invasion and will treat it as such. It will turn into guerilla warfare at a code level. There will be active analysis of the API and entire groups to determine creative ways of "breaking" the output of the API for some windowing environments and not for others. After all, look at clauses 11 and 12 of the GPL:

NO WARRANTY

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Now, I can't say that this was the intention all along, but it sure seems like a shield to me.

After numerous different articles about the impending Venture Capital flood, I still had my doubt.

I don't see the same thing as in the 90's where nearly everyone who had a webpage was getting money thrown at them, but there's enough going around to give me pause.

CaseySoftware is a relatively small development house. We have a handful of sharp developers and a variety of clients, but we are definitely not a major player. Our clients are starting to see the funds roll in so more work, more projects, and more concepts are being floated now than there was just three months ago. Websites are being re-worked from asp to php, open source applications are being integrated, and our project management is well suited to handle it all.

Purely through connections and our involvement in open source projects such as dotProject, we have been invited to bid on a new project nearly every other day. This doesn't sound like much until you consider the fact that in the past two months, we've responded to 21 RFP's and they breakdown like this: Won: 14, Lost: 2, Undecided: 5

Personally, I think these numbers are stunning... and completely unsustainable. We need to start planning and expanding into areas where there is sustainable growth and not these pseudo-random spurts. Therefore, we are working to bring our asp-model of dotProject hosting online as soon as possible.

We can hope to always have more and more clients offering big name projects, but more realistically, I believe that the asp-model (as covered yesterday) is a much more reasonable, sustainable, and mutually beneficial way to go.

Now we just have to make the time to do it...

As a regular reader of Joel On Software and heading a group prepared to go into the ASP realm with dotProject and Mantis, I read this post with great interest today. It's a long post, but I'll summarize it here:

Software companies and software buyers have directly competing goals from the second the contracts are signed.

Essentially, once a contract is signed, the software company's goal is to continue improving the product or building the next product for the NEXT client, not you. They know you have already signed the contract and have committed to the upfront licensing fees, the annual fees, and it's unlikely that you'll back out. This creates a fundamental disconnect between these two groups that must be recognized.

Phil sees this problem and suggests that an ASP (Application Service Model) model can resolve it if applied correctly. Here are the pearls of wisdom that I've discerned.

First, instead of the standard monthly billing, he suggests a quarterly process. This allows time for problems to be addressed and resolved each cycle without constantly having to rush towards deadlines. Since many businesses work on Net-30 anyway, it makes quite a bit of sense.

Next, you must get buy-in from the client up front. Make them commit to using the tool and making it their own. During the initial deployment, training, documentation, and involvement are a must.

Next, since every customer must be satisfied, the entire entire selling organization has a goal to focus upon. The disconnect of always building the next version while simultaneously supporting old versions becomes a much more financially beneficial thing to do.

Next, it evens out the revenue flows. Instead of having "record quarters" of sales and nothing for months, this will create a more steady growth - as long as customers are satisfied.

Finally - and in my opinion - most importantly, it assures the customer that a huge upfront cost is not being risked for a tool that may or may not fit their needs. Instead of the $100k software going unused, they can simply stop paying for it after six months and only waste $20k.

This is the route that we'll be going with CaseySoftware. Our hosting packages of dotProject and Mantis will be coming on shortly and all monthly plans will have quarterly equivalents offering slight discounts. Hopefully this can assure our customers that the operation and maintenance of their systems are of the utmost priority to us. Towards this goal, we will be announcing strategic partnerships in the next few weeks.

If you haven't read KC's entry On Being "Thorough", go check it out and come right back. I'm addressing the same point from a different direction.

On Friday, I submitted an invoice for a huge amount of hours to our biggest customer. The contract is fixed price, but paid on an incremental basis depending on the functionality of the system, so the absolute number of hours was irrelevant.

KC has kept detailed logs such as:

The first version of the [xxx] table and the [xxx]DAO is almost complete. I have sketched out all of its interactions with the [xxx]. I believe that it would be the best to completely seperate these data structures from all of the interactions with the actual [xxx] themselves.

Therefore, the [xxx] and their evolving structures can be isolated from the table structure. So far, there seem to be atleast 5 xml structures that we will have to deal with along with one that looks suspiciously more like SGML instead of xml. This may cause difficulties.

KC simply uses dotProject as a running log throughout the day taking a few seconds every so often to jot down thoughts, concerns, and questions about the system. As billing time approaches, a bit of editting and cleanup happens to the entries, but they are submitted nearly verbatim.

I spoke with the Project Manager this morning and he said that he was stunned at the level of detail. He said that none of their vendors submit records as detailed as this, not even those who are working on a Time & Material basis. This stunned me.

I believe that if you're going to bill out your time, you must report what is done accurately and completely. Without a high level of detail, two problems arise:
1) the customer cannot know the status of the project and 2) future project estimation suffers.

If software developers and companies want to educate customers, a higher level of service is necessary. This is why all of our customers are granted limited access to our internal dotProject and Mantis deployments.

During the analysis of a codebase from a recent client, I noticed something quite odd...

The bulk of the codebase was of very low quality. Tabbing conventions for denoting loops/if-then statements were not followed, variables were not named consistently, passing data via globals, and whole functions where copy and pasted throughout the code. None of these things in themselves were terrible problems, but combined they caused some difficulties in cleaning the code.

Then, as I delved deeper into the codebase, I found something interesting. There was a portion of the code dedicated to building forums and it was fundamentally different than the rest. The SQL statements were clean, the variables had consistent naming conventions, and a variety of other things that made it clear that this code was not written by the same person. I took a block of code and threw it into Google.

Sure enough, I found a bulletin board system written by a gentleman in the UK which was identical to the existing forum codebase. After some further digging, I found that the license allowed redistribution as long as proper credit was given via inclusion of the complete copyright statements. None were included in the code I was examining, but I wasn't surprised.

This isn't the first time I've seen this. At a former employer, there was a "Senior" Developer who admittedly stole code from Open Source projects and used them within the proprietary codebase. I confronted him numerous times over this and he simply said "In [his country of origin], we don't care about copyrights." This was further evidenced by the fact that he suggested - to the development team initially - distributing the MS Project ISO from the company webpage. He saw nothing wrong with this and once again suggested this in front of the client. [Saner opinions prevailed and this had not occured by the time I parted ways with the organizations. - KC]

In addition, I've noticed this more and more as Outsourced Projects are discussed. If you want to send your code overseas for development, that's your choice. But once you get it back you MUST do due dilligence to ensure that the code is truly yours to use, distribute, and sell under your terms. It is simply too risky otherwise.

You could be inadvertently opening up you and your organization to serious litigation risk by using code from other sources without attribution.