Brian Grinstead

We are what we pretend to be, so we must be careful about what we pretend to be.

Kurt Vonnegut’s Mother Night is narrated by a fictional character, Howard W. Campbell Jr. Campbell is an American playwright who was living in Germany during World War II and became a well known Nazi propagandist and war criminal.

Campbell had accepted the task of being an American spy at the beginning of the war. He transmitted messages through deliberate pauses, coughing, etc. in his radio transmissions. Throughout the war, he was the most reliable agent of his kind that America had and survived the war undetected.

Living a secretive and quiet life in New York City after the war, Campbell’s identity is suddenly exposed. The novel is a memoir that he is writing from inside an Israeli prison awaiting trial for his war crimes.

Campbell seems to be both good and evil at the same time. But is he essentially good or essentially evil?

In an internal sense, his actions were good – the information he was passing through the airwaves was helpful to the Allies and it took a total sacrifice of his reputation and his life to provide this service. His career as an author and playwright was gone, he lost his wife, he would never be accepted as a member of society in his home country and he continued to do his work in spite of these things.

However, the external Campbell, the person that the world saw, was clearly evil. When his father-in-law, who would have “been delighted” to figure out that Campbell had been a spy, was speaking with him near the end of the war he says:

You could have never served the enemy as well as you served us, … I realized that almost all the ideas that I hold now, that make me unashamed of anything I may have felt or done as a Nazi, came not from Hitler, not from Goebbels, not from Himmler–but from you… You alone kept me from concluding that Germany had gone insane.

When judging the morality of Campbell, which of these people matter, the inner or outer person?

This is perhaps the main question posed by the book. Which person is you? Vonnegut explicitly states the moral of the story at the beginning: “We are what we pretend to be, so we must be careful about what we pretend to be.” You are the sum of all of your parts. The actions that you take as a means to accomplish something are as much a part of you as the something that is accomplished in the end. No matter the circumstances in which you find yourself, you still have to live with the actions that you take.

Campbell seems surprised by this concept when visited by his “Blue Fairy Godmother” (the man who recruited him as an American spy) long after the war. They are speaking about how only 3 people in the world knew that Campbell was a spy.

“Three people in the world knew me for what I was–” I said. “And all the rest–” I shrugged. “They knew you for what you were, too,” he said abruptly. “That wasn’t me,” I said, startled by his sharpness. “Whoever it was… he was one of the most vicious sons of bitches who ever lived.”

No matter what his intentions, Campbell was a Nazi.

Campbell is a fitting main character to portray this moral. He is not quite a hero and not quite an antihero. He is a lucid protagonist who is neither ignorant nor insane. He knew what he was doing at all times and he realized that the orders he took were either ignorant or insane, and he did them anyway. He is a reminder that even in difficult times, we need to take our actions for what they are, and not what we hope they will be.

I recently had to access a web API through C Sharp that required a file upload. This is pretty easy if you have an HTML page with a form tag and you want a user to directly upload the file.

<form method="POST" action="http://localhost/" enctype="multipart/form-data">
	File : <input type="file" name="content" size="38" /><br />
	<input type="hidden" name="id" value='fileUpload' />
 </form>

However, this is not always a reasonable path to take. Sometimes you may be wanting to access a file that is already in a system and you don’t want a new upload. If you are accessing an external API, this is probably always the case. Unfortunately, building this post using C# is not quite as straightforward. I first tried using the WebClient UploadFile method, but it didn’t fit my needs because I wanted to upload form values (id, filename, other API specific parameters) in addition to just a file.

So, I needed to roll my own form post. Here is the Multipart Form RFC and the W3C Specification for multipart/form data. After reading these links and searching some forums, here is what I came up with.

Note: If anyone is interested in this code in Visual Basic, reader Mike Ferreira converted the code into VB.Net in a comment below.

public static class FormUpload
{
	private static readonly Encoding encoding = Encoding.UTF8;
	public static HttpWebResponse MultipartFormDataPost(string postUrl, string userAgent, Dictionary<string, object> postParameters)
	{
		string formDataBoundary = "-----------------------------28947758029299";
		string contentType = "multipart/form-data; boundary=" + formDataBoundary;
 
		byte[] formData = GetMultipartFormData(postParameters, formDataBoundary);
 
		return PostForm(postUrl, userAgent, contentType, formData);
	}
	private static HttpWebResponse PostForm(string postUrl, string userAgent, string contentType, byte[] formData)
	{
		HttpWebRequest request = WebRequest.Create(postUrl) as HttpWebRequest;
 
		if (request == null)
		{
			throw new NullReferenceException("request is not a http request");
		}
 
		// Set up the request properties
		request.Method = "POST";
		request.ContentType = contentType;
		request.UserAgent = userAgent;
		request.CookieContainer = new CookieContainer();
		request.ContentLength = formData.Length;  // We need to count how many bytes we're sending. 
 
		using (Stream requestStream = request.GetRequestStream())
		{
			// Push it out there
			requestStream.Write(formData, 0, formData.Length);
			requestStream.Close();
		}
 
		return request.GetResponse() as HttpWebResponse;
	}
 
	private static byte[] GetMultipartFormData(Dictionary<string, object> postParameters, string boundary)
	{
		Stream formDataStream = new System.IO.MemoryStream();
 
		foreach (var param in postParameters)
		{
			if (param.Value is FileParameter)
			{
				FileParameter fileToUpload = (FileParameter)param.Value;
 
				// Add just the first part of this param, since we will write the file data directly to the Stream
				string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n", 
					boundary, 
					param.Key, 
					fileToUpload.FileName ?? param.Key, 
					fileToUpload.ContentType ?? "application/octet-stream");
 
				formDataStream.Write(encoding.GetBytes(header), 0, header.Length);
 
				// Write the file data directly to the Stream, rather than serializing it to a string.
				formDataStream.Write(fileToUpload.File, 0, fileToUpload.File.Length);
			}
			else
			{
				string postData = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}\r\n", 
					boundary, 
					param.Key, 
					param.Value);
				formDataStream.Write(encoding.GetBytes(postData), 0, postData.Length);
			}
		}
 
		// Add the end of the request
		string footer = "\r\n--" + boundary + "--\r\n";
		formDataStream.Write(encoding.GetBytes(footer), 0, footer.Length);
 
		// Dump the Stream into a byte[]
		formDataStream.Position = 0;
		byte[] formData = new byte[formDataStream.Length];
		formDataStream.Read(formData, 0, formData.Length);
		formDataStream.Close();
 
		return formData;
	}
 
	public class FileParameter
	{
		public byte[] File { get; set; }
		public string FileName { get; set; }
		public string ContentType { get; set; }
		public FileParameter(byte[] file) : this(file, null) { }
		public FileParameter(byte[] file, string filename) : this(file, filename, null) { }
		public FileParameter(byte[] file, string filename, string contenttype) 
		{
			File = file;
			FileName = filename;
			ContentType = contenttype;
		}
	}
}

Here is the code to call the MultipartFormDataPost function with multiple parameters, including a file.

 
// Read file data
FileStream fs = new FileStream("c:\\people.doc", FileMode.Open, FileAccess.Read);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
fs.Close();
 
// Generate post objects
Dictionary<string, object> postParameters = new Dictionary<string, object>();
postParameters.Add("filename", "People.doc");
postParameters.Add("fileformat", "doc");
postParameters.Add("file", new FormUpload.FileParameter(data, "People.doc", "application/msword"));
 
// Create request and receive response
string postURL = "http://localhost";
string userAgent = "Someone";
HttpWebResponse webResponse = FormUpload.MultipartFormDataPost(postURL, userAgent, postParameters);
 
// Process response
StreamReader responseReader = new StreamReader(webResponse.GetResponseStream());
string fullResponse = responseReader.ReadToEnd();
webResponse.Close();
Response.Write(fullResponse);

Hopefully this code can help someone, figuring out exactly where to place the boundary and newlines in between form key-value pairs caused a little bit of grief during development. This is some functionality that would be really nice inside of the language library, but it seems like in most languages this is something you end up coding yourself.

I have always enjoyed using the logical OR operator in JavaScript (||) as an oppurtunity to check for a null-like value, specifically to provide default parameters for functions or to check for existence of a property on a collection. I think they are a great way to make code more concise, and if used well, more readable.

These two functions do the same thing, but the first is shorter and more readable to people who may have to go back and modify it later.

function contentDocument(frame) {
    // If the frame.contentDocument either doesn't exist or is a null 
    // value, it will skip to the next value down the line 
    return frame.contentDocument || 
        frame.contentWindow.document || 
        frame.document;
}
 
function contentDocumentVerbose(frame) {
    // This works, but is possibly too verbose for such a simple task
    if (frame.contentDocument) {
        return frame.contentDocument;
    }
    else if (frame.contentWindow) {
        return frame.contentWindow.document;
    }
    else if (frame.document) {
        return frame.document;
    }
}

I was happy to see that C# has a similar feature, the Null Coalescing Operator.

This is nice for the same reasons, and is more readable than the normal ternary operator when simply checking null. Of course, if I am not checking for a null value, but a more complex boolean expression, I will usually use the ternary operator or an if-else block it is more than just a variable assignment or return statement. Anytime I use any extra syntactical feature, it is my hope to make the code more readable.

Anyway, here is an example of the ‘??’ (coalescing) operator contrasted with the ‘?:’ (ternary) operator.

string APP_DEFAULT = "application/octet-stream";
 
private string GetContentType(string contentType)
{
    // Nice and readable.  The '??' operator can be very useful.
    string FUNCTION_DEFAULT = null;
 
    return contentType ?? FUNCTION_DEFAULT ?? APP_DEFAULT;
}
 
private string GetContentTypeTernary(string contentType) 
{
    // This is NOT readable.  Please do not use nested ternary
    // operators... They take too much energy to figure out.
    string FUNCTION_DEFAULT = "text/plain";
 
    return (contentType != null) ? contentType :
        ((FUNCTION_DEFAULT != null) ? FUNCTION_DEFAULT : APP_DEFAULT);
}