Foo Infusion

dom4j

2009-10-17T15:16:00.003-03:00

I started using a dom4j implementation of an interface provided by a client's framework libraries (ie something they built themselves).

Little did I know I would need the jaxen and saxpath jars as well. Hopefully this saves someone the time it spent me...

SOAP 1.2 + MTOM + WSE3 + NetBeans WebServices

2009-04-30T14:53:00.003-03:00

For a project I'm working on at work right now, I needed to get a web service client implemented using WSE3 and communicating with a web service returning SOAP 1.2 using MTOM.

I know that's a bit of a mouthfull. I'll try to expand those terms a bit.

SOAP 1.2 - just a new version of the SOAP standard. It seems most tools use SOAP 1.1 as the 'standard' version of the standard. The trick seems to be how to tell your tools/technology that you want to use the new SOAP 1.2 standard. I think in reality the syntax of a SOAP 1.1 vs SOAP 1.2 message are pretty similar upon first/shallow glance. While there are some big differences in the model, the REALLY big difference from an implementation point of view seems to be the namespace it uses.

WSE3 - Microsoft's Web Services Extensions, version 3. An updated (and very changed from v.2) version of Microsoft's framework for dealing with web services.

MTOM - Message Transmission Optimization Mechanism - A standard (newish) for transmitting binary data using web services. Using just plain-old web services is not really sufficient for tranmitting binary data because SOAP is an XML standard, and it's difficult to get binary data in XML properly, esp without specialized processing on either end. Essentially, MTOM transmits your SOAP message as a multipart MIME message, with a MIME part for your standard XML SOAP message response, and another separate MIME part for the binary part. The MTOM implementation can unwind that message however it pleases I guess, though it seems that the tools I'm working with seem to take the binary data and Base64 encode it and stick it back in the SOAP XML.

Although I was only implementing the client for my part of the project, I needed a web service that used SOAP 1.2 in order to test that my stuff worked correctly. And I discovered some interesting things while stringing it all together. There didn't seem to be much in the way of help on the interwebs about this, so I wanted to put it up here in case anyone else finds it helpful. (Though I think most people have moved on past WSE3 by now, and are using WCF - I cannot make that move yet, unfortunately).

The soap namespace in your WSDL does need to be changed in order to tell your clients what version of SOAP you want to use:

o SOAP 1.1 : xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
o SOAP 1.2 : xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"

The correct binding annotation for the SOAP version you wish to use should also be present to tell the JAX-WS stuff how to work. The NetBeans/GlassFish stuff picks SOAP 1.1 by default.(Java 6 has constants for this in the javax.xml.ws.soap.SoapBinding interface - http://java.sun.com/javase/6/docs/api/javax/xml/ws/soap/SOAPBinding.html#SOAP11HTTP_BINDING)

o SOAP 1.1 : @BindingType(value=”http://schemas.xmlsoap.org/wsdl/soap/http”)
o SOAP 1.2 : @BindingType(value="http://java.sun.com/xml/ns/jaxws/2003/05/soap/bindings/HTTP/")
o SOAP 1.1 + MTOM : @BindingType(value=”http://schemas.xmlsoap.org/wsdl/soap/http?mtom=true”)
o SOAP 1.2 + MTOM : @BindingType(value="http://www.w3.org/2003/05/soap/bindings/HTTP/?mtom=true")

MTOM can also be specified by using @MTOM(enabled = true) annotation, but the binding type annotation takes precedence, therefore, specifying the SOAP 1.2 binding type (no MTOM) will give you SOAP 1.2 but NO MTOM even if the @MTOM annotation says otherwise.

The use of MTOM must be specified in the client as well as the WS. If the SoapClient’s RequireMTOM property is set to true, it is expecting a response with a content type of “multipart/related” – if the content type of the response is not “multipart/related” the client will throw an exception while processing the response. If the WS is not using one of the MTOM binding types it will not use a content type of “multipart/related” for the response ( I think it will use “text/xml” instead). So these must match up – if you’re using MTOM (in the WS) you have to tell the client you’re using MTOM so it will expect the “multipart/related” content type in the response, and if you’re not using MTOM you have to tell the client that so it will expect the “text/xml” content type in the response.

Here’s a very basic sample of what the client needs to look like:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Web.Services3.Messaging;
using Microsoft.Web.Services3;
using Microsoft.Web.Services3.Addressing;

namespace wse3_tester
{

class Program
{

public static String CONTENT_TYPE = "Content-Type";

private String url = "http://localhost:8888/PDFWebService12/TEIGInquiryService";
private String soapAction = "GetPolicyInquiry";

private String message = @"http://www.teig.com/"">AUTOMyIDEN2003-08-08-03:00";

private bool useMTOM = true;

static void Main(string[] args)
{
Program p = new Program();

p.test();

}

private void test()
{
SoapEnvelope requestEnv = new
SoapEnvelope(System.Web.Services.Protocols.SoapProtocolVersion.Soap12);

requestEnv.CreateBody();

requestEnv.Body.InnerXml = this.message;
EndpointReference endpoint = new EndpointReference(new Uri(this.url));

WSClient client = new WSClient(endpoint, this.soapAction);

client.RequireMtom = this.useMTOM;

SoapEnvelope responseEnv = client.Send(requestEnv);
}

public class WSClient : SoapClient
{
String methodName;
public WSClient(EndpointReference refr, String methodName) : base(refr)
{

this.methodName = methodName;
}

public SoapEnvelope Send(SoapEnvelope env)
{

return base.SendRequestResponse(this.methodName, env);

}

}

}

And here’s a sample of what the annotations required for the ws:

@BindingType(value="http://www.w3.org/2003/05/soap/bindings/HTTP/?mtom=true")
@WebService(serviceName = "TEIGInquiryService",
portName = "TEIGInquiryPort", endpointInterface =
"com.teig.TEIGInquiryPortType", targetNamespace = "http://www.teig.com", wsdlLocation =
"WEB-INF/wsdl/TEIGInquiryService12/TEIGInquiry12Wrapper.wsdl")
public class
TEIGInquiryService12 {

Pausing in a Windows batch script

2009-02-18T09:50:00.002-04:00

It seems like I've been creating a lot of batch scripts lately.

I recently wanted a script that would start a server process, wait for the server to finish starting, and then start a client process.

I used the START command to kick off the server and client processes, but then was unsure of how to proceed to accomplish a pause/sleep in the batch script while the server was starting. Searching the internet seemed to turn up less information than I wanted, and often the suggested solutions didn't work anyway.

I settled on using the CHOICE command which has the following help screen:

C:\Users\admin>choice /?

CHOICE [/C choices] [/N] [/CS] [/T timeout /D choice] [/M text]

Description:
This tool allows users to select one item from a list of choices and returns the index of the selected choice.

Parameter List:
/C choices Specifies the list of choices to be created. Default list is "YN".

/N Hides the list of choices in the prompt. The message before the prompt is displayed and the choices are still enabled.

/CS Enables case-sensitive choices to be selected. By default, the utility is case-insensitive.

/T timeout The number of seconds to pause before a default choice is made. Acceptable values are from 0 to 9999. If 0 is specified, there will be no pause and the default choice is selected.

/D choice Specifies the default choice after nnnn seconds. Character must be in the set of choices specified by /C option and must also specify nnnn with /T.

/M text Specifies the message to be displayed before the prompt. If not specified, the utility displays only a prompt.

/? Displays this help message.

NOTE:
The ERRORLEVEL environment variable is set to the index of the key that was selected from the set of choices. The first choice listed returns a value of 1, the second a value of 2, and so on.
If the user presses a key that is not a valid choice, the tool sounds a warning beep. If tool detects an error condition, it returns an ERRORLEVEL value of 255. If the user presses CTRL+BREAK or CTRL+C, the tool returns an ERRORLEVEL value of 0. When you use ERRORLEVEL parameters in a batch program, list them in decreasing order.

Examples:
CHOICE /?
CHOICE /C YNC /M "Press Y for Yes, N for No or C for Cancel."
CHOICE /T 10 /C ync /CS /D y
CHOICE /C ab /M "Select a for option 1 and b for option 2."
CHOICE /C ab /N /M "Select a for option 1 and b for option 2."

So to accomplish a pause in the batch script execution, I used a line that looks like this:

CHOICE /N /D Y /T

No message is needed.

/N - don't bother printing the choices

/D Y - the default response to choose, should time run out (it will) is Y

/T - specifies the timeout (time to wait for a response before picking the default)

Not complicated, but it's something that seemed to be lacking from the knowledge of the internet.

Dofuscator, Reflection, .NET Properties, and Attributes....

2007-08-14T13:19:00.000-03:00

Recently the team I work on encountered some buggy behaviour that only exhibited itself in the obfuscated build, leading us to believe the bugs were a result of the obfuscation.

It was discovered that Dotfuscator's 'Library Mode' setting was to blame for the bugs.

From Dotfuscator's user guide:

Library Mode By Assembly

This setting tells Dotfuscator that a particular input assembly constitutes a library. (For Dotfuscation purposes, a library is defined as an assembly that is going to be referenced from other components not specified as one of the inputs in this run) This has implications for renaming and pruning, regardless of any custom excludes you may have set.

Here are the rules when using the library option:

1. Names of public classes and nested public classes are not renamed.
Members (fields and methods) of these classes are also not renamed if they have public, family, or famorassem access.

2. In addition, no virtual methods are renamed, regardless of access specifier.
This allows clients of your library to override private virtual methods if need be (this is allowed behavior in the .NET architecture).

3. Any user-specified custom renaming exclusions are applied in addition to the exclusions implied by the above rules.

4. Property and Event metadata are always preserved.

5. Pruning Rules. Public classes are not removed, even if static analysis determines they are not required. Fields of these classes are not removed if they have public, family, or famorassem access. Methods of these classes are not removed if they have public, family, or famorassem access. In addition, such methods are treated as entry points, so their call trees are followed and all subsequently called methods are also protected from removal.

If you do not have the library option set for an assembly, then you are telling Dotfuscator that your input assembly is a standalone application, or that it will only be referenced by other input assemblies. In this case obfuscation is much more aggressive:

1. Everything is renamed except methods that override classes external to the application (i.e. classes in assemblies that are not included in the run.)

2. Property and Event metadata is removed, since this metadata is not required to run the application (it is meant for “consumers” of library code).

3. As usual, user specified custom renaming exclusions are also applied.

4. Pruning Rules Specifically included classes, methods, or fields are not pruned. All trigger methods and fields are not pruned.

All classes, members, and fields that are excluded from renaming also become excluded from pruning. All other classes, fields and methods that are unreachable from some included class, method, or field are pruned.

We have some stuff built to make serializing a class to XML easier and more automatic. It uses three VB.NET concepts to accomplish this : .NET Properties, property attributes, and Reflection.

The XML serializer inspects an object using reflection, asking for a list of all 'properties', and then cycles through the list looking for properties which have the special XML serialization attributes (these are called annotations in Java).

When Dotfuscator was using 'Library Mode' on the assembly, there were no problems, as the 'property metadata' was preserved.

When Dotfuscator was not using 'Library Mode' on the assembly, the obfuscated assembly no longer contained the 'property', but rather had the property split up into the corresponding 'get' and 'set' methods. In this case, the XML serializer's call to the object for a list of properties returned an empty list as they were no longer considered properties but methods. Thus, the XML serializer didn't work very well.

I think I've determined that in our case there aren't any real negative consequences to using 'library mode' other than the obvious (but likely, slight) reduction in actual obfuscation.

If you're doing anything that combines using .NET properties for storage and you're relying on that special 'property' structure to be maintained through to the other side of the obfuscation, you need to obfuscate your assembly using Dotfuscator's 'library mode'.

In the Professional edition like we use, this property must be set (or not) on each assembly individually (as opposed to the Community edition, in which you set it for all assemblies or none).

A Little Java Humour

2007-05-15T13:36:00.000-03:00

Nothing like some geeky humour to break the week up.
Check out this sweet batch of ads from RailsEnvy.

I totally dig all the crazy jars 'Java' has.

Design for Developers

2007-05-04T10:51:00.000-03:00

CodingHorror had a couple of good pieces up recently about how important it is for software developers to get some basic design skills (including a tool like photoshop) under their belt.

I plan on using these as ammo when getting the dev manager at work to order these books for me and let me schedule their study into my time.

Advice for juniors

2007-03-21T09:48:00.000-03:00

I had hoped to do an article just like this someday. Maybe I still will. Either way, here's a great bit about what [needs to] go on for your first few years as a junior developer.

All Hail Keyboard Modifiers!

2007-02-09T11:14:00.000-04:00

I LOVE keyboard modifiers. A lot of people don't like them, and I think it's because they want to use their computer with one hand only, while I almost exclusively use the computer with two hands full time. So if I move my hand to the mouse, my other hand will usually still be up on the keyboard waiting to press the required modifier.

Actually this is probably why I prefer one mouse button while others insist on multiple buttons.

And actually now that I'm thinking about it in this context, multiple mouse buttons might slightly edge out keyboard modifiers in terms of usability when you consider multi/ambi-dexterous folks. (Though only slightly, as the inherent usability of the 'left' and 'right' buttons becomes useless when it's in the 'wrong' hand - and I say this speaking as someone who mouses with both hands. Keyboard modifiers are shitty when mousing with the 'wrong' hand too.)

ANYWAYS, all that aside, I had a little iTunes adventure this morning, and I'm glad to report the results here. First a little background:

I use Party Shuffle a LOT.

I listen to music all day long, and I don't want to be picking out an 8 hour playlist every morning, or constantly picking music to listen to as the day goes on. This is what I will refer to as "The WinAmp Way".

It would at first appear that the old "shuffle your entire library" trick would fulfill that requirement. But there are downsides to this as well, the biggest of which is that you 'lose' the shuffle every time you stop and start the play. So if you're listening to one song and you decide you want to listen to another song next, you have to:

find the track you do want to listen to
wait for the current song to end (destroying your fade in/out effect) (This is optional of course)
play the newly selected track

This of course resets the 'shuffle' and so you stand a much higher chance of listening to the same music over and over again (Maybe this aspect isn't such a big deal now that we all have multi-decagigabyte music libraries, but still). Also it takes a lot of personal attention and time. Not as much as "The WinAmp Way", but still a lot. I will refer to this as "The iTunes 1.0 Way".

Since iTunes 6 or so (maybe 5? 4? I can't remember) there's been a nifty feature included called Party Shuffle. It adds a separate source to your sources list, specifically designed to take care of this situation for you. It's a dynamically generated shuffler, which shuffles from any given source (ie: playlist), can do some selective randomizing (higher rated songs more often), offers all the benefits of shuffling your entire library ("The iTunes 1.0 Way"), without all the distracting attention requirements ("The WinAmp Way"), and without the transition-and-shuffle-resetting qualities.

You can dynamically add tracks to the end or the front of the track queue, you can inspect your queue before it gets played and adjust it, and you can also completely forget about it and allow the shuffler to take over, giving you a highly randomized and automatic queue. This is big stuff in jukebox software. This is big stuff in music enjoyment period.

In addition to all of this, while the random playlist listening thing was evolving, the iTunes Store (formerly the iTunes Music Store) came in to existence. To aid in navigating from your music library into the desired locations in the iTunes Store, little arrow-in-a-circle links were added next to each bit of metadata in the track view. There's a little link next to the track name, next to the artist name, and next to the album name. When you click on the link icon, iTunes takes you to the iTunes Store and does a search for that metadata, to help you find that particular item in the store and thus hopefully aid you in finding what you're looking for. (note: you can tun these little link icons off and so you might not see them - you can control this from the preferences pane)

Getting back to Party Shuffle - lately I've been finding myself being reminded by the music in my Party Shuffle of something else I want to listen to, and wanting to go find it in my Music Library. It occurred to me recently that this is an unnecessarily complicated process:

scroll up to the Music source in the sources list
select it
give focus to the search box in the upper right and search for the item
- OR -
open the browse panes and scroll around until your find your music

Actually it isn't that complicated, it's just a lot MORE complicated than finding the music in the iTunes Store.

"Wouldn't it be great" I thought, " if I could click on a little link/icon like the ones for the iTunes Store, and have it show me that track or artist or album in MY OWN LIBRARY!". It would be great.

So I went to the feedback page at Apple.com and submitted a feature request, asking for this feature to be implemented.

Later on, while thinking about how someone might go about implementing this in the UI, I was thinking - "I wouldn't want another icon in there... there's no room", and also "If I was Apple, I don't think I'd want to change the behaviour of those icon/links to ALWAYS point into the local music library, and as a user I wouldn't want that anyway - sometimes I want to go to the store, sometimes to my library". Then it hit me - MODIFIER KEYS!

Wow, what great UI it would be, if I could just hold a key, like say CTRL, and press the icon/link and have it modify the behaviour to take me to my library. I did it just to see what it felt like, expecting either nothing to happen or to be taken to the iTunes Store (the icon/link having ignored my modifier key) when to my surprise IT DID EXACTLY WHAT I WANTED!!!

SHOUT IT FROM THE MOUNTAIN TOPS!!

The CTRL keyboard modifier links you into your own library!!

Those crafty UI guys at Apple think of everything!!

Enjoy!

How To Shoot Yourself In The Foot

2006-10-04T15:01:00.000-03:00

This piece is crazy funny. Just the thing to get me through a dreary wednesday afternoon. Thank you so much fullduplex.org.

Agile Hooey

2006-09-27T16:03:00.000-03:00

Stevey chimed in recently with his thoughts on (big 'A') Agile development Methodologies. A great read and plenty insightful for those of us searching for the 'one true way'.

I've found myself being perpetually cautious of development methodologies, while at the same time longing for a great one.

I love the idea of pure Object Orientation, but everytime I read/hear about it, the examples are so terrible (in my opinion) that I feel like, "maybe I don't really think this is so great after all." I mean it's probably better to do the half-assed attempt at pure OO that most of us manage than to have no 'basic' structural foundation at all, but if the examples are to be trusted (and why would they be used if that wasn't the intention?) I think it's way off base - what with 'customer' objects having a 'login' method and all of that (seriously, what the hell is the customer doing logging itself in? And what is it logging in to anyway?)

The same goes with XP and Agile development. I absolutely LOVE pair programming, but probably I wouldn't if I was forced or expected to do it, and I'm not sure all projects need it all the time. Besides that, they will never go for at my current office, so it'll never gain any traction here. I love the idea of contracts with the team and with 'the customer' (marketing) but come on, how the hell am I supposed to know how long it's going to take to do something until I've done it. And even then it would be different the next time I tried it. Geesh!

I think I'll go through this article a few more times to try to glean what I can from it. Mostly what sticks out in my mind right now though, is that I really need to get a job with Google!

Customer Segmentation

2006-08-01T15:36:00.000-03:00

I forget if that's the 'official' term for this or not. I just read an article on the other Joel's website about how Dell's website sucks because of its insistance on classifying you as soon as you get through the gate: you're either a home customer, a small business customer, or a large business customer.

I agree with him that this is stupid, and it's going to bite them in the a$$ before too long (I think the same can be said for MSFTs new 'a zillion models' scheme for Vista, BTW).

Something I DON'T agree with though, is the way people like Joel (smart people - he's one of the smartest I can think of) complain about this, and don't do anything about it.

He says:

Somehow Apple and IBM/Lenovo have been happy to sell computers on the Internet to people without needing to know their "customer type."
Whenever we buy servers from Dell, even though they eventually offer us a price that beats the competition, we still have to spend a week or two negotiating, gathering competitive bids, etc. By the time we place our order the price we pay is about 20% to 30% less than the price advertised on the web, and we're still not sure if we could have paid less.
I'd love to just order the damn servers from their website, clicking on the links to configure it. Dell would have my money sooner and wouldn't have to pay any sales people to talk to me on the phone. But you've trained me to negotiate every time if I don't want to pay the sucker price, so now I have no choice.

And lo and behold, there is another answer - a solution to every gripe on his list, and he even *almost* mentions the answer in his prolouge leading up to his real problem. And yet he doesn't see it.

I know the XServes have their own shortcomings (I don't think they have redundant power supplies, for instance - which is arguably a pretty important feature) but it's ridiculous for people to completely overlook them ALL THE TIME.

If/when I need server class hardware it won't be a question as to which piece of hardware I will buy - not because I have a penchant for Apple's hardware, but because it's pretty damn good, and very very cheap compared to the competition. Plus, no haggling or customer classification.

Real Developers

2006-06-21T14:02:00.000-03:00

In a great bit of interweb cross-referencing, RAGANWALD has written a piece applying John Gruber's recent "And Organes" article's metaphor of 'Real Mac Users' to the world of software development.

I agree with both of them completely.

I have always felt uncomfortable with "Apple is better" argument. Similarly, I have always been wary of the "Agile is better" and "XP is better" and "Java is better" and ".NET is better" (and on and on forever - there's a flavour of fanatic for every idea) arguments as well.

Best quote: "... to an open mind, anything at all of interest is an opportunity to learn and improve."

I love this. I was speaking with a colleague the other day about curly braces. Like this: {}

I have been programming in VB.NET for 2 years now, nearly curly-brace-free. I don't miss them as much as I thought I would. I do, however, miss the clear scope definition that curly braces provide.

For example, when you see a method definition in C++/Java/C# you KNOW the anything inside curly braces only exists inside those curly braces. This can be a little more confusin in a language like VB that doesn't have this type of scope clarity built into the syntax. Python's indentation can leave people wondering about scope too, although I wish it didn't (I think the indentation is just about perfect. At least it 'sucks less' than the curly braces)

But I HATE using curly braces in try/catch blocks. I think it's terribly ugly. VB and Python really get top marks from me for their exception handling code. Although it's a little misleading because the try/catch/finally/end try lines are all lined up like they're at the same level... oh well.

That's the point though, right? Keep an open mind.

Speaking of keeping an open mind about development, I'd really love to have my own computer to do some experimentation with this new D thing. Anyone out there with experience with this neat little project should let me know how it went.

Enjoy the articles.

Evaluate(Me.Year)

2006-05-23T14:56:00.000-03:00

At my office we have an evaluation process which requires that both the manager and the employee fill out the evaluation papers.

Shortly after I arrived here the company started using a webapp that we purchased for doing this. The department manager 'starts' and evaluation, and the webapp sends notice to both the evaluatee and the evaluator, who then proceed to fill out the form using the webapp. When both parties are done with the evaluation form, the department manager meets with the evaluatee to go over the results and present him/her with a pay raise or some degree (should they deserve one).

In general I'm really happy with the process. I'm expected to honestly reflect on my work over the last 12 months and my responses will be held up against the reponses of my manager - this seems to me to be good for keeping the process fair and 'two sided'. It provides a digital record of my personal achievement and progression which can be referenced later on, which is also pretty good. It's a good chance for the evaluatees to meet with the department manager, which is generally pretty infrequent, so this is good too.

There are some problems.

For instance the forms 'categories' or 'questions' seem to not be unique to my position, nor are they whittled to better fit my position. Consequently I (and my manager) end up rating my performance in categories like "Putting the customer first" - which is ridiculous, as I've never once interfaced with an external customer for my product. There are lots of other categories like this one.

Also, the form, because it's so 'general' (by which I mean, it's aimed at evaluating sales and support people, not developers) takes a dog's age to fill out. This year I billed 8 hours against it.

Anyway, as I said before, the process as a whole is pretty good, so I'm not complaining too much.

I got a pretty decent raise percentage wise last year, but I'm hoping for something considerably more substantial this year. For a number of reasons. We'll see how it goes.

Projects Category

2006-05-05T11:28:00.000-03:00

I think I'll start doing short posts about the various open source projects I'm interested in.

I will preface the article title with the acronym "OSS:" and then supply the name of the project. Hopefully this will differentiate these posts from other posts where I want to discuss a particular aspect of the project in question. This way, you can do a search for the string "OSS:" and find all the articles that fall into this domain.

I think this type of naming convention will allow me to do some of the 'category' stuff that other blog software has built in.

Getting Serious About Testing

2006-04-29T20:54:00.000-03:00

I had a brief discussion with the guy who's sort of in charge of my project this week. The basics of the beef center around the support network the my company has [not] set up for my development team. Among other things, I am upset because our QA team isn't doing enough automated testing.

Here's a message to all you project/product/development/team managers out there. Your developers find it insulting when you don't take their work seriously, and choosing not to perform proper QA is one of the surest ways to get them to feel this way.

The rationale goes a little something like this:

"I do good work. If my company recognizes that I do good work, they will ask me to do important work (important as in 'important to the business'). If the work that I'm doing is important, my company will support me (with QA, among other thigns), so that the products I produce are the best products they can be. If the work that I'm doing is not important enough to do proper QA on, get me working on something that IS important - I want to be working on something that IS important. If I'm not doing important work, my comapny must not feel that I do work that's as good as I think it is, and they don't want me to do important work. If I'm not doing important work, I don't know why I'm doing anything."

We do automated unit testing (although we recently broke that part of our build process and are in the midst of redoing that stuff - it is there though) but it's no excuse for automated acceptance testing. I suspect many mangers don't realise the difference.

The Truth About Darwine

2006-04-27T21:27:00.000-03:00

So I've discovered a few things about WINE that I was didn't understand before.

In my last post I was all gunned up about how WINE should be able to use the actual Windows DLLs right off the Windows CD to provide it's functionality.

As it turns out, you CAN use the original Windows DLLs, which I would have known if I had actually read the introductory paragraph on the WineHQ homepage. Obviously, Wine's goal is to create a 100% MS-free solution, but in order to make their product usable in the interim (while this 100% MS-free thing is implemented) they have also provided the facilites to use the Windows DLLs. Smart.

The process for doing this is described here.

Still, I think my original idea was/is on the right track.

I think that something that would really make Darwine successful on Mac OS X/x86 is a Windows CD DLL extractor/wizard. I think it would greatly speed up the adoption rate of Darwine, by making more things work sooner.

The extractor would work by running either along with the Darwine installer or after Darwine's already been installed, sucking all the DLLs it can out of a Windows install CD, and replacing the equivalent Wine DLLs with the 'native' Windows versions. Maybe it would present you with the option of sucking the DLLs off the CD, but still trying to use the Wine DLLs first, and then if you experience problems you can flip on the Windows ones. I don't know.

If I had a machine to do some playing around on, this is something I would be working on.

Darwine, Parallels, BootCamp, when will it END?

2006-04-25T11:51:00.000-03:00

I've been thinking a lot lately about this whole "Windows on Macintosh Hardware" thing lately.
Really I guess I've been thinking about how terrible the current solutions are.
I think I have a better solution but I have no idea how one would go about implementing it, or even if it would be legal. But I think it's doable, at any rate.

Right now there a few things going on in this space:

Apple is obviously thinking about people who want to use Windows software on their Mac hardware. BootCamp, I think, is only one piece of Apple's game plan. Lots of people have been discussing Apple's possible moves in this regard, so I won't go through everything. Here's some pointers though: Cringely;Shute;Gartenberg;Daring Fireball-#1;Daring Fireball-#2;among many others.
Parallels has released their products to allow virtualization, specifically aimed at Mac users that want to use Windows on their machine.
There are other virtualization options, like QEmu and VirtualPC - maybe VMWare will get into the fray as well.
Darwine has been gaining steam - attempting to utilize the Wine project's attempt to re-implement the entire Win32 API (in a portable way so that any OS can run applications that rely upon it), adding some Mac OS X specific stuff to make it look better and work better/more cleanly.
Mono has also had some great advances over the past few years, attempting to re-implement the .NET runtime in a more portable way, so that any OS can run applications that rely upon it.

While all of these are pretty great ideas/products, none of them really get at the heart of the matter (running applications that were developed for Windows to run on Mac OS X) with quite the right mix of performance and ease of use.

Apple's got a neat solution of providing a neat dynamic disk partition tool, and a fancy bootloader. Neat as in 'intersting', not neat as in "tidy". Anyone who really needs to use a Windows app will quickly tire of rebooting, and being stuck using a crappy FAT32 partition in order to share files between the two OSes (not to mention the indiosyncracies that have already been reported with respect to the partition tool and the bootloader). While it's probably a good move for Apple, it's probably not the best long term solution for users. Again, I think Apple's really just testing the water with this one, and it will be interesting to see exactly where they're willing to take this in the future, but for now we can file this away in the "good, but not quite right category".

Virtualization is also a pretty nifty solution, and I think there will always be a market for real machine virtualization technology - it's been employed by many an enterprise for years to do server virtualization, for example. (Beneficial, as when the VM goes down, but the hardware stays up, and can even safely restart VMs for you, plus it runs in its own address space like any other process, and can't mess other things on the machine up).

Still, for regular users who don't need to have virtual machines for this type of enterprise separation and protection, the idea of having Mac OS X, all your own apps, PLUS a full Windows install, PLUS whatever app you're running in windows, seems terribly inefficient to me. There is no need to have ALL of windows running, hogging disk space and memory and sweet sweet processor cycles and precious little video card resources. (PS, if you think XP is a hog in this regard, just wait till you see what Vista can do to a machine's resources). Not to mention that issue of dealing with partitioning hard drives, filesystems' respective pros and cons, space limitations, security, etc)

Which nicely brings us to Wine/Darwine, and Mono. This is also a neat idea - probably the best idea we've looked at yet - and I give both projects' founders and contributers the hugest props both for taking this on and for being unbelievably successful at it. This approach achieves much better performance than VM style stuff, allows for neat applications-sharing-resources stuff to work that couldn't possibly with the bootloader approach Apple has taken so far, and can probably overcome most of the ease-of-use stuff with a nifty installer and some diligence.

The problem I have with the re-implementors (Wine/Mono) is that they are re-implementing. They're redoing something that's already done. And this approach doesn't stand a chance at keeping up with what Microsoft is doing with Windows and it's APIs.

I really don't understand why, from a technical standpoint, it isn't possible to simply create an environment for applications to run, that actually USE the DLLs from the Win32 API and the .NET runtime, right off the Windows CD. Rather than re-implement it, why not actually use THE reference architecture, and just get on with it.

I'm suggesting something along the lines of an application that could find all the files it needs on the Windows install CD, and pull them out, and place them somewhere sane in the host OS, which could then allow apps to call directly into the Windows DLLs, and either provide some kind of abstraction layer between the Windows DLLs and the hardware, or allow the DLLs to run in some type of sandbox that would grant them direct hardware access. This approach would be very fast as it could run directly on the new Intel hardware, and it would be a reliable implementation as it would be using the reference architecture that the apps were created for/with.

This is essentially what Apple did with the Carbon API, to allow 'classic' applications to run (in a slightly retooled fashion) directly in Mac OS X. It was a little slower due to the abstraction, but it was fine for most things. And it was MUCH faster than running something using the "Classic" virtual machine environment.

Now, admittedly, from a technical standpoint it may be doable, but I really have no idea how this would be accomplished. I, personally, wouldn't have a clue where to start.

Legally, I think there could be a number of pitfalls to this idea, and that is perhaps why it hasn't been attempted (to my knowledge). Apple would never be able to take this on. The open source community could probably take this on though.

Wil Shipley did a piece a while ago about how Darwine is the future for this stuff, attempting to incite young developers who feel like they have something to prove (*ahem!*) to get on board and help out. And I think I'm there. I would like to have a discussion about this with someone knowledgeable about all of this first though.

UPDATE: Some reading on the WINE site revealed to me that they CAN in fact use the Windows DLLs directly, though I haven't found the prescription for actually getting this done yet.

All of this ignores that fact that people don't buy Macs to run Windows programs, nor should they. It's a bonus for some people, but it won't make a difference to many users.

I for one wouldn't want Windows apps, with all their bizzare registry expectations, individual file management conventions, individual UI behaviour, completely path based file access, user permissions model, etc, etc, etc, to get in and bugger up my nice Mac OS X install.

Daring Fireball wieghs in on the Great Kernel Debate

2006-04-23T17:50:00.000-03:00

In the post I made about Mac OS X's kernel and Cringely's first mention of it, I basically said that eventhough the monolithic guys (Linux, esp) are all about getting down on Apple (XNU & Mach specifically) for being different, and slow, Apple should still consider themselves in a good position for innovation and technical acclaim. Plus I'm all for microkernels anyway.

Tech writer (newly full time!!) Daring Fireball has just published a few of his ideas on this topic as well. While I mainly avoided Cringely's article in particular, DF goes straight for the meat and makes a lot of the points that I hinted at, and many I didn't even see. For some great commentary on this subject, (plus a sweet geeky ink to a Linux kernel development forum thread that discusses this very thing from a slightly higher level), check out his article.

Look for much more from Daring Fireball, as he's recently taken up producing his blog as his full time job.

Ben Goodger on Fighting With Windows (Foo #1!!!)

2006-04-21T10:04:00.000-03:00

The great Ben Goodger has run a series of short posts recently about his fight with his development laptop, and the Windows installation on it.

I found these articles particularly relevant, as I've spent these last days rebuilding the Windows install on my machine here at work.

As I see it there are a few issues at play here.

Removing software from Windows SUCKS.
Installing Windows SUCKS.
Companies are building hardware that SUCKS.

The biggest issue for me, while rebuilding my machine, has been the installer.

First of all, an OS should most certainly not simply degrade to (as Ben says) "useless"-ness after time. Any amount of time, really. Maybe it needs repairing sometimes, maybe that's even often if you're a heavy user - but this attitude of rebuilding the machine everytime the OS gets too foobar-ed to continue serving usefully has got to go. (For the record, OS X has a ways to go in this regard as well, but it's certainly better than XP)

The Windows XP installer is the biggest piece of crap I have ever used. It looks terrible (640x480 display with 256 color graphics, monospaced fonts), it behaves badly (it does things that take hours to complete with nothing but a small green progress bar to tell you what's going on, and it reboots without telling you it's going to do it or why MULTIPLE TIMES), it makes you feel stupid by expecting you to know what's going on and what options you want to choose, and it doesn't give you the functionality you need in an OS installer (disk partitioning, reformatting, etc).

Actually it does let you do some of that stuff, and even lets you do some nifty 'repair' things too, but it does it in a 'curses' interface that looks even worse and it even harder to use than the XP installer described above.

I could go on forever about my own problems and the shortcomings I see in the hardware and software I use from day to day, but Ben does a good job with his gripes too, so go check him out.