No, not really. Or is it?

Azure. EC2. App Engine.

Do any of those names sound familiar? If so then join us for the first meeting of the McHenry Cloud Developers Group in Crystal Lake, Illinois!

Our first meeting will be an informal discussion of the goal of the group, ideas for projects and presentations. Also, we want to know what you are looking to get out of the group.

The meeting is Monday, December 14th from 7:00 PM until 8:00 PM. We’ll be meeting in the downstairs Ames-1 meeting room.

Please join us in Crystal Lake and join the projects or hang back and soak up some info!

Our first meeting will be held at the Crystal Lake Public Library.

Register here!

Directions:
Crystal Lake Public Library
126 W Paddock St
Crystal Lake, IL 60014-6194

View Larger Map

Also, we have a brand new site up. http://www.clouddevelopersgroup.com. It’s a very early draft but feel free to check it out.

A few years ago I posted a small snippet of JavaScript from a library I created way back in the bad-old days of “Classic” ASP. The post generated a handful of comments between the different blog hosts I’ve tried but only two mentioned anything about how to do it better. The rest were the standard Internet-protocol messages reminding me of how much I suck (thank you *so* much).

A couple a guys posted something more useful than just a reminder of my own total failure as a developer and a human being. Daniel Schaeffer and the code-name “R.” posted alternative solutions. Unfortunately, Mr. “R.” didn’t post a link for me to find him, but I do think I tracked him down (Google will find you).

A little history first, back when .NET 1.0 was the new hotness one of the first things I fell in love with was the String.Format() method. Simply put, given a string literal decorated with some tokens you could create template strings without having to muss about with concatenation. I know, I know, C/C++ had something like this and other languages have too. Whippty-do. I was reared on the BASIC product-line, whatever.

C#’s string template functionality was a godsend in my eyes. I had (have) an intrinsic hatred of concatenation, mostly built up from creating dynamic sites in ASP that had to work in NN4 and IE4 (hate). All the HTML, JavaScript and CSS was built on the server and spit out to the client in whole. It was a nightmare to look at because of dynamic nature of the application as almost all the output was built programmatically on the server. Let’s just say there was a lot of string concatenation. Unfortunately, moving to .NET wasn’t an option. Yet string concatenation made me so itchy, so I scratched it as is the nature of an itchy developer.

String.format("Hello, {0}.", "World");

Very simple, obviously, it didn’t contain the full sophistication of the full-blown String.Format() in .NET but it did mean I didn’t have to do this anymore.

var myContrivedExample = "<a href=\"" + protocol + "://" + url + "\">" + text+ "\"</a>";

Now I could do…

var myContrivedExample = String.format("<a href=\"{0}://{1}\">{2}\"</a>", protocol, url, text);

Yeah, just take a second and try to follow the first one and spot the mistake. Then find the mistake in the second one. Yeah, much easier, huh.

Here’s the original code snippet.

String.format = function(text) {
 //check if there are two arguments in the arguments list
 if (arguments.length <= 1) {
 //if there are not 2 or more arguments there's nothing to replace
 //just return the just3ws text
 return text;
 }
 //decrement to move to the second argument in the array
 var tokenCount = arguments.length - 2;
 for (var token = 0; token <= tokenCount; ++token) {
 //iterate through the tokens and replace their placeholders from the just3ws text in order
 text = text.replace(new RegExp("\\{" + token + "\\}", "gi"), arguments[token + 1]);
 }
 return text;
};

Basically, it dynamically appends a static method to the String object. By default it expects a single argument, which can be any string. If there’s only one argument it just passes that string through unmodified. Although, if a second argument is provided the method will attempt to locate a token in the string and replace all instances of that token with the passed in string. Repeat the replacement for each following argument. Pretty straight-forward, probably a naive implementation but it got the job done.

A few years pass and I post the method on a blog.

Time churns on and the events of history progress, eventually someone reads the post.

More time churning more historical events, then someone replies to it. Neat.

Another one, wait. I know I suck.

Okay, here’s another one.

Now I’m looking back on the sad legacy of my blogging efforts till now and trying to gleam something useful from it and this is the best I can do.

Daniel Schaeffer was the first to oblige me with a response. I like what he did, it was clean and simple. Although, it wasn’t *exactly* the same.

All the comments that begin with //JUST3WS: were added by myself for the sake of the posting. And please forgive my taking some liberties with the code formatting, I’m a bit fussy.

String.prototype.format = function() {
 var pattern = /\{\d+\}/g;
 var args = arguments; //JUST3WS: Referencing the JavaScript 'arguments' object that is available inside all methods.
 //JUST3WS: 'this' refers to the current instance of the String object.
 // and the Lambda function is called for every match of the pattern.
 return this.replace(pattern, function(capture) {
 return args[capture.match(/\d+/)];
 });
};

We can turn Mr. Schaeffer’s method into a static method relatively easily.

String.format = function() {
 var pattern = /\{\d+\}/g;
 var args = arguments; //JUST3WS: This stays as is.
 if (args == null || args.Length == 0) {
 return “”;
 } //JUST3WS: The arguments might be null or empty because the
 // method signature doesn't require at least one.
 // JavaScript is permissive in it's parameter checks
 // and will just use the closest match. So if there are
 // no overloads which match better this method will still
 // be invoked regardless of how many arguments are passed in.
 //JUST3WS: 'this' refers to the current instance of the String object.
 // and the Lambda function is called for every match of the pattern.
 return this.replace(pattern, function(capture) {
 //JUST3WS: This is where Lambda's can be tricky. The calling scope (caller) is visible to the executing method (callee).
 // We can't use the local 'arguments' object because it would refer to the callee's arguments, not the callers. :-P
 //
 return args[capture.match(/\d+/)];
 });
};

What’s cool about his method was actually adding an instance method to the String object. Meaning, you couldn’t just call the method in an imperative manner like my static method. But it did mean you write some really neat looking syntax. Also, he used a Lambda function to handle the token replacement. You know Lambda’s; used to be feared and respected and known only to the Lisp/Scheme necromancers but now all the cool kids are running about like it’s Dad’s old Army overcoat.

var myContrivedExample = "<a href=\"{0}://{1}\">{2}\"</a>".format(protocol, url, text);

Because the string literal is actually an implicit instance of the String object in JavaScript, you can invoke methods on it. Very, very cool and clean.

Later on secret-agent known only as “R.” left me cryptic message to check out his implementation. But he didn’t leave a clue as how to find him, so once I mustered up the car and realized I needed few hundred more words in this post to make it seem “literate” I did a little research (Google) for “R.+String.format()” and think I found him. His post on a String.format() implementation provided both methods, a static and an instance version.

String.format = function() {
 if (arguments.length == 0) {
 return null;
 }
 var str = arguments[0];
 for (var i = 1; i < arguments.length; ++i) {
 var re = new RegExp('\\{' + (i - 1) + '\\}', 'gm');
 str = str.replace(re, arguments[i]);
 }
 return str;
};

Great minds think alike. Sorry about that mate.

String.prototype.format = function() {
 var str = this;
 for (var i = 0; i < arguments.length; ++i) {
 var re = new RegExp('\\{' + i + '\\}', 'gm');
 str = str.replace(re, arguments[i]);
 }
 return str;
};

Thanks for posting guys.

What’s interesting to me is the variety of ways that string formatting can be implemented. I don’t know why most JavaScript frameworks don’t offer some kind of string formatting functionality out of the box. The only one that I’ve seen thus far is the Microsoft Ajax framework, but they have a whole different methodology. But that’s for a different article.

Presented this morning with my Introduction to AOP with PostSharp.

I may have done the same topic multiple times each presentation was almost completely rewritten based on feedback from the previous times. Which is good and bad. Good because I feel like the information is clearer and better. Bad because it’s like I’m giving the presentation for the first time each time.

Slides and source code are available on GitHub.

http://github.com/just3ws/Introduction-to-AOP-with-PostSharp

Slides

http://github.com/just3ws/Introduction-to-AOP-with-PostSharp/blob/master/Introduction%20to%20AOP%20with%20PostSharp%20Redux.pptx

Source

http://github.com/just3ws/Introduction-to-AOP-with-PostSharp/tree/master/src/

My wife asked what the difference was between the list of Warnings, Errors and Exceptions in a batch results report.

I used our car as analogy.

• Warnings are supposed to be the little dinging you hear when you leave the lights on and turn the ignition off. Something might be wrong. Did you really mean to leave the lights on?
• Errors are like when the car won’t start because you have the wrong key. Something is definitely wrong.
• Exceptions are like when you start the car but you can’t go anywhere because you’ve got a flat tire. Some thing is broken.

Except most software developers seem to mix the meanings around. Like when a developer uses an exception to mark the end of a list. Similar to driving without any sign of warning then the car explodes when it should have just shown a “low fuel” light.

A true agile zen developer can implement a system by simply hearing the sounds of their specs failing then passing.

Each project is as successful as the ability to learn from the previous one. The goal is to transcend to a higher state through continuous reflection and discipline.

If you were ever a skateboarder then you’ll understand the importance of stickers on your deck. Oh, you may think, “I wasn’t a skateboarder and I liked stickers.” No, it was a skater thing, no other group that I knew of put as much loving attention into the placement of their stickers as a skater. Positioning them in places where they won’t (or were more likely to) get torn up. Cutting around them to make cool looking inlays in your grip tape. Good times. I think that not riding anymore has finally caught up with me and I’m wanting to express myself on my current “deck”, my lappie. But I can’t run down to the local skateshop and beg for stickers. And vendors rarely include any stickers with the equipment I’ve purchased. So I’ve compiled a short list of places you can get stickers typically with just a S.A.S.E.

• The Daily WTF (SASE)
• Powered by Ubuntu (SASE)
• hackerstickers.com (link exchange)
• Coding Horror Stickers (4 for $4)
• openstickers.com (print your own)
• a grab bag of links to free stickers (some require forms)
• Thirsty Developer (don’t know if they mail them)
• Python ($3.99)
• Ubuntu ($0.79 p/sheet)
• Typing is not the bottle neck. (free, but it’s just one guy doing the hookup so be nice when you ask.)

This is kind of funny, but it’s true. How to apply stickers to your skateboard.

Join the Anti-If Campaign. Check out http://www.antiifcampaign.com for more info.

The Single-Responsibility Principle or SRP of SOLID is one of those wonderful little principles that can apply to so much, from your objects to methods to libraries (blog posts, emails, so many other things in your life). I want to focus on libraries for the moment. As I refer to libraries, I mean any bundle of code that is compiled and deployed as a unit. This could be .NET Assemblies, Java JAR Files, whatever your platform uses.

SRP describes the goal of keeping your objects focused on one thing and one thing only. This keeps undesired dependencies and complexity from creeping in. Instead, of munging all the logic into one “God Object” you break the logic into smallest possible objects, making changes to a specific object much easier because you don’t have to worry about breaking some other tangled up responsibility. But let’s change a little terminology, instead of “objects” let’s swap in the word “libraries”. This gives us the goal of keeping our libraries focused on one responsibility and instead of a “God Library” we want to have discrete, focused libraries that do one thing.

Why would this be a good thing? Consider an application that has the entire business framework, business logic, data access and UI logic all contained in one assembly. You have three applications that utilize the library, one to handle web services, one to handle file transformations and another is your companies flagship web application. Now, this is convenient if you always deploy all three applications simultaneously. You only have one library to worry about, just compile and deploy everything. But let’s say you want to change something in the file transformation logic but don’t want to have to redeploy the website? Now you have to try to figure out how to deploy a new version of the master library without impacting the website. Typically, you’ll end up with multiple versions of the same library and a version headache. How can you avoid this? By breaking up the libraries.

Instead of one master library separate your application structure up by responsibility. Our example would probably become three new core libraries, one for the framework, another for data access and business logic and then we’d create libraries for our file transformation logic and web application. This way, when we make a change to the web application we don’t *have* to redeploy the file transformation service and vice-versa.

I’ve used this approach in dealing with my current employer. We have two .NET assemblies that pretty much hold the entirety of the core application and all of it’s sub-processes. These assemblies are stored in the GAC so pretty much, if you want to redeploy the file transformation service you have to also redeploy three other application and the website. By refactoring the file transformation logic into a separate assembly I was able to work freely on the file transformations without having to concern myself with accidentally breaking our primary business systems.