What is the first seven-digit prime palindrome in pi? So, while looking at the digits of pi, what is the first sequence of seven of them that are both prime (not divisible by anything but one and itself) and a palindrome (the characters are the same both backwards and forwards).

Well, the way I am, I just wanted to solve it just to solve it. So I did (I think). Feel free to:

A) Tell me if I’m wrong and

B) Tell me if my code is suboptimal

My code takes about nine seconds to run on my machine. That sounds slow, but then again, it’s doing a LOT. But again: feel free to let me know if it’s not efficient. I’ll show blocks of code and explain them.

Here’s the beginning of the method that does all the work (it’s called on a button click. It fills in a text box with the answer):

function GetEmailAddress()
{

var palindromes = [];
var indexString;
var reverseIndexString;
var primePalindromes = [];
var piIndices = [];
var lowestIndex = 4294967295;
var savedIndex = 0;

We’re going to have some palindromes, some prime palindromes, the indices of the locations of the prime palindromes within the digits of pi and a few placeholder variables along the way.

// Make seven-digit palindromes instead of checking all seven-digit numbers
// Get all three digit numbers, filter them, reverse them and plop one digit between the original and the reversed
for (var index = 100; index < 999; index++)
{

// If the FIRST digit is divisible by two, in a palindrome, obviously the LAST digit is, too, so skip it
if(parseInt(index.toString()[0]) % 2 === 0)

index += 100;

indexString = index.toString();
var reverseIndexString = indexString.split(”).reverse().join(”);
for (var middleDigit = 0; middleDigit < 10; middleDigit++)
{

palindromes.push(parseInt(indexString + middleDigit + reverseIndexString));

}

}

The point here is to find all the palindromes first instead of trying to find the prime numbers first. I think this filters it down from nine million numbers (seven digit numbers) to 5,000 (I didn’t check this). The way I do this is that I know we’re making seven-digit palindromes, right? So in reality, the first three digits are the same as the last three, just reversed. The middle digit doesn’t matter. So… just build three digit numbers, add any number and then reverse the original three numbers. While doing so, we can filter out anything that STARTS with an even number. Because, since it’s a palindrome, if it STARTS with an even number, it ENDS with an even number. No prime number does this. That’s why we jump from 200 to 300, from 400 to 500, etc. That brings us down to five hundred numbers (again, these are all guesses. I didn’t debug this code because it just worked right away). Multiply that by ten (one per middle digit, 0-9) and you get 5,000. Instead of testing 9,000,000 numbers for palindromes, we’re only testing 5,000. Next block of code:

// Now we only have 5,000 numbers from a possible 9,000,000 if we just checked all seven-digit numbers
// Find all the prime numbers
for(var index = 0; index < palindromes.length; index++)

if(IsPrime(palindromes[index]))

primePalindromes.push(palindromes[index]);

I run all of these through my IsPrime method (I’ll show it after this paragraph). I tried to cheat on this part, but every algorithm I found was extremely inefficient. So here’s mine, from scratch (all my code is):

function IsPrime(number)
{

var middle = Math.floor(number / 2);
// We can start from 3 because everything’s divisible by one and we know we don’t have any even numbers from previous filtering,
// also allowing us to skip every other number
for(var index = 3; index <= middle; index += 2)

if(number % index === 0)

return false;

return true;

}

The algorithms I found were horrific. By comparison, most weren’t smart about where to start or stop evaluating. I started at three because everything’s divisible by one and I’ve done some filtering already to make sure I don’t have any even numbers like two. Also, I’m not doing a ++ in the third clause of my for loop. I’m doing += 2. I’m skipping the even numbers. The last bit of optimization is the immediate return of false if we find out it’s not a palindrome. For some weird reason, some algorithms just saved the value, continued to check against all other possible multiples and then returned the saved value.

The next bit of code was setting a pi variable… I’m not going to post it because it’s thousands and thousands of digits of pi. I put it in a string (don’t include “3.”) so I could do an indexOf on each of the prime numbers I found in the previous step within the pi string. So here’s the last block of code:

// Find the first prime palindrome
for(var index = 0; index < primePalindromes.length; index++)
{

piIndices[index] = pi.indexOf(primePalindromes[index].toString());
if(piIndices[index] < lowestIndex && piIndices[index] > -1)
{

lowestIndex = piIndices[index];
savedIndex = index;

}

}

document.getElementById(‘emailAddress’).value = primePalindromes[savedIndex];

}

So here, we’re running through all the primePalindromes to find the index of each of them within the pi string. If it’s not -1 (meaning, it’s actually in the string), then I save its index if it’s lower than the last one I saved. After that, I populate the textbox with the value at this saved, lowest index. Here’s the little bit of HTML if you want to see this working for yourself (you’ll have to slap together all the bits of code – they’re just two Javascript methods, and you’ll need to set var pi = ‘[Many thousands of digits of pi]‘;):

<input type=’text’ id=’emailAddress’ />
<input type=’button’ onclick=’javascript:GetEmailAddress();’ value=’Click me to get the answer’ />

Again, let me know if I’m wrong or if you’ve got a way to optimize it. Mine took about nine seconds, consistently, on my machine.

The Twin Cities Code Camp is now a two-day conference! On the first day, I got things rolling by going to see Getting Func-y with C# and F# with Keith Dahlby. Keith gives good, valuable talks, so I recommend going to sessions he gives. He started off by describing the basics of functional programming and then showed how we’re using a lot of functional concepts or ideas in C# anyway. LINQ was heavily discussed. Things kind of broke down at that point, with what was meant to be a short Q and A about the concepts turning into an actual debate about whether or not they’re even useful! There were two people actually arguing against LINQ! A small piece of me died. Their arguments were bad and amounted to “I don’t understand it, therefore it’s bad.” Or acting like changing or learning something new is a bad thing. After that finally washed over, Keith talked about why someone would then use F# instead of C#. He listed the following as reasons:

More sophisticated type inference
Immutability by default
Functional data structures
Curried functions and partial application
Computation expressions

The interesting part about that list is that I don’t see these as imperical facts as to how F# is better than C#. It seemed like Keith was just listing off some tenets of F#. Some of us actually don’t think immutability by default is a good thing, for example. I am known to use variables on occasion. Shocking, I know. I do recommend learning functional programming even if you never use it professionally. And Keith’s very knowledgeable on the subject, so this was a great talk to attend.

For the second talk, I went to HTML5 Graphics: Pretty Pictures for Practical Processes by Jon Stonecash. I think Jon wrote a really nice library in C# for creating HTML5 graphics from scratch just for this talk! If he didn’t gank this from somewhere else, that’s really impressive. He went over how he was generating it all and it was very nicely done. He used it to show how you can write real, practical software for the “real world” instead of just making pretty pictures and crappy games, etc. His demo included what looked like tracking products through the order, packing, shipping process. Boxes of steps in the process had the number of items in their queue step, showed where they went, if they were rejected, etc. It certainly was a good example of how this can be used to visualize something in a meaningful manner. Jon’s delivery is interesting. He seems right at home at the University of Minnesota. He both sounds and looks like a college professor.

Next up, I went to Practical Monads in C#: Maybe<T> by Jordan Terrell. I figured he’d start out by explaining what a monad is, but he actually did that late in his talk. Strange. Most of the talk was about his implementation of something called Maybe. It’s something used to represent zero or one value. It works with all .NET types, both value and reference, unlike the nullable types. I’m not going to describe it in detail, but if you’d like to learn more about it, you can do so here. It’s an interesting concept when being introduced to monads and kind of takes you further down the functional rabbit hole.

After that, I attended Building Metro-style applications for Windows 8 by Steve Peterson. He’s a principal architect from Microsoft, so he had a lot of good content. He talked about a handful of interesting things. He mentioned that Visual Studio Designer is now going to share the core authoring UI with Expression Blend. He also brought up “Blend for HTML.” It’s built for Windows 8 applications, not web sites. I had to ask for clarification, if I had heard correctly. You really write HTML, JavaScript, etc. for Windows 8 applications. Very interesting. Other too-complex-to-discuss-here topics included: Client Hyper-V, WinRT asynchronous API design, GPU compute and C++ AMP. Also, the async keyword!

For the last talk of the first day, I went to see Distributed Version Control: Attack of the Clones by Keith Dahlby again. I wasn’t sure what to expect from this talk, but I knew it would be good as Keith was giving it. As he warned, it ended up being a bit of a rehash from a previous talk I had seen from him – git commands like rebase, cherry pick, stashes, reflog, bisect. Still valuable, but I didn’t learn a whole lot of new things to mention. He did bring up whygitisbetterthanx.com.

During the prize giveaway at the end of the first day, I won an XBox 360/Kinect package!

I started off the second day by going to see Level-Up Your Win7 Kinect Apps by Mike Hodnick. On the first day, there weren’t any real conflicts in which talks I wanted to see. Day two started off with a conflict. I also wanted to see Brian Gorman’s talk on design patterns. But I thought this would be too fun to let myself miss it. Mike has done a lot of Kinect development, making demo projects for Avtex, so he could really speak from experience. He discussed some of the major concerns into which he’s run. Background noise is a big issue in Kinect development. You have to figure out what to do with other people in the scene, for example. He also talked about how cursor control is easy but flawed. Cursor control is controlling a pointer or cursor with your hand. It’s more of an out-of-the-box solution, but it’s rough, says Mike. It behaves differently when you have an abnormal body size, it has cross-body problems and he just thinks it’s outdated. A better way, he suggested, would be to use voice commands. Another concern to consider is lighting. He said that an app that he wrote just did not work when they were outside. Pitch black poses no problems, though.

Mike’s talks are always fun, so I suggest checking them out when you can.

Why does everyone code on the fly? Don’t do it. You will always fail, no matter how awesome you are. Your code will fail and you will look dumb. I’ve said it before and I’ll say it again. Just don’t do it. Have all the code pre-written. We don’t want to watch you code anyway. This happened in several of the presentations that I attended.

After that, I went to see KnockoutJS: Web Development Bliss with Judah Himango. Judah put rage comics all over his slides. I had to let him know that this was ill-advised. The fake StackOverflow question was funny, though.

Knockout.js, Judah says, is basically data binding for your HTML. It can be used to employ MVVM for JavaScript. It seemed really slick. I had never looked into Knockout.js before (typed very sheepishly), but I was really enamored with a lot of the concepts. It follows the observable pattern and has functions that use observables, too.

I’m really sold on a lot of what Knockout brings to the table and will certainly be looking into it in the future.

Next, I went to Intro to HTML 5 Canvas by Kevin Moot. This was a really fun talk. Kevin had a nice looking presentation format (using HTML5, of course) and it was really entertaining. The canvas is a 2d surface for drawing shapes and bitmaps and a 3d surface for polygons and shaders. When talking about a canvas arc, he showed a picture to illustrate the concept. Above, it said “canvas arc.” Next to it was a picture of a woman in medieval battle gear. Above it, it said “Joan of Arc.”

Not funny, Kevin. Not funny.

He went through a ton of mini-demos showing how every little aspect of the HTML5 canvas worked. He showed a couple of cool things. He turned a jpg into a drawing on a canvas. He had a video playing and wired up a button to basically take a snapshot of the video and post it as an image to the canvas. Then, instead of taking a single snapshot, he had it take a snapshot every ten milliseconds. Well, that’s basically instant, so it looked like a video was playing on the canvas. The video had a green screen, so he washed away the green pixels and replaced it with an associated pixel from a different background image. It was actually really cool. He topped off the talk with an extremely silly demo of an old guy dancing in a video and being plastered like a wall paper onto the canvas with different effects applied to them, with a bouncing cat with what looked like a pop tart on its back, leaving a rainbow trail around him… yep, I described that accurately. His whole presentation is online. I suggest not using IE: http://moot-point.com/presentations/canvas-part1/index.html. Use the left and right mouse buttons to navigate.

For the last presentation of Code Camp before my presentation, I went to Web Development with CoffeeScript and Sass with Brian Hogan. He’s literally written the book on things like this, and I’d seen him present before, so I knew this would be a good talk. Now, I went into this talk expecting to hear a lot about what CoffeeScript was and learn a lot about it and this “Sass” thing was just a tiny add-in that really wasn’t going to be a big deal. Interestingly enough, while I liked CoffeeScript, the real take home for me was Sass! CoffeeScript is really simple to pick up and hit the ground running. There’s very little to learn. It’s more like an extension to JavaScript with some nice added bonuses. The “fat arrow,” for example, allows us to pass “this” around into different scopes. There are more streamlined ways to do iteration, as well.

Brian said “there is no reason not to use Sass.” That’s pretty bold. But it really does give CSS “everything programmers want.” Iteration, modularization, mixins (functions), etc. Sass is a way to create CSS in a more programmer-friendly manner. You can make variables in your CSS. That’s crazy! Think of all the time you have to write the same color or margin, etc., in a large stylesheet. Instead, you could store it in a variable and re-use it over and over again. If your marketing department decides to change the background of the selected tab from pink to salmon, you’ll only need to change it in one location and it will just work. That’s awesome.

For the last session of the day, I gave my talk on Silverlight 5. Silverlight 5 will be out later this year and I just demo’ed every new thing I could. I included browser in browser, with the webpage in the in-browser browser showing this image:

I also demo’ed the multiple windows concept. The cool part was that you could put whatever you want in the child operating system window. So I put in just a portion of my page. But that page also had the mechanism to open a window. So above the button to open the window I had this picture:

I also did a PivotViewer demo with all the people I follow on Twitter, amongst many others, but those were the fun ones.

One annoying note to add: an 18-year old raised his hand every five minutes (probably more frequently) to ask tangential questions. They weren’t adding or helping with the presentation and made me go over and skip going further into detail on some things. I hope I wasn’t critiqued too harshly for that and I hope that doesn’t happen when I give this talk again.

At the end of the day, I won a grab bag from Telerik. Not an XBox 360/Kinect, but it’s better than a poke in the eye with a sharp stick.

Again, I really can’t urge more strongly to take advantage of learning opportunities like this. It’s not a chore. It’s a treat. And I’m not talking about the free food that they had all day.

Now I didn’t have to worry about my employer paying for me this year because I got in due to being a member of TechMasters. We gave a demo of a meeting as a presentation on speaking skills.

The conference began with a keynote by Cem Erdem. My response is not going to be very popular amongst other people that were there. While everyone else seemed to just love this, I just plain didn’t. The entire thing was how he moved here from Turkey and is now successful. Nothing about development, code, where technology is going, etc. Don’t get me wrong, it’s a nice story, but maybe it would be better suited to give to immigrant entrepreneurs rather than established computer programmers. Complimenting America a bunch isn’t going to win me over. Don’t mean to sound cold, but that’s how I felt.

The first session was when we gave our mini-demo of a TechMasters presentation. All of the people that attended the talk were very interested and asked a lot of questions. If you’re intersted in getting better at public speaking, I certainly suggest stopping by sometime. You can show up as a guest for free.

For the second session, I saw Improving Web Site Performance and Scalability While Saving Money with Robert Boedigheimer. I’ve been to Robert’s talks before and they’re really great. They’re different from a lot of other talks. He includes a lot of useful tidbits of information that he’s learned on the front lines. Word must have gotten out about Robert because there was a packed house for this talk!

In order to sell home the point of increasing web performance, Robert gave out an interesting factoid: for every 100ms of increased load time to your site, sales decrease by 1%. That should be enough to make sure everyone thinks of performance as incredibly important, no matter the industry. Topics discussed include Fiddler, IIS log files, HTTP compression, content expiration dates, etags, minification and consolidation, CSS sprites, image optimization, CDNs, multiple domains for static resources and pre-fetching. The ideas mainly focused around monitoring what’s happening so you know what’s costing you the most in terms of time and bandwidth. Then acting on what you learn. Are you sending over too much data? Compress, cache, minify, optimize, etc. Is something taking too long? Pre-fetch, use CDNs and multiple domains, that sort of thing. I definitely found it to be a very valuable talk and will hopefully use some of the things I’ve learned in the future. Most people were aware of/have used some of what Robert discussed, but some of us have never been involved in deploying large, enterprise projects and haven’t run into some of these issues.

For the third session, the original speaker canceled. The talk was to be about JavaScript and MVC, I believe. The replacement, Matt Milner, spoke about jQuery Templates and data-link. That actually seemed a little more interesting anyway. Matt started off by pointing out when Microsoft got involved with jQuery. Basically it was after the popularity of jQuery really dominated the ajax client library. Microsoft threw all their weight behind contributing to jQuery, thus pretty much killing the ajax client library.

jQuery Templates enable you to display and manipulate data in the browser. It’s a jQuery plugin that was included in the core library for version 1.5 of jQuery, which came out earlier this year. To use it, you make a script tag with a type of “text/x-jQuery-tmpl” to let the jQuery parser know that this is a template. Then, you use pretty intuitive tagging to format your template.

For example, if you have a var like this:

var myFoos = [{a: "b", b: "c"}, {a: "d", b: "e"}];

You could use a jQuery template like the following to format myFoos into a list of divs:

<script id=”fooTemplate” type=”text/x-jQuery-tmpl”>
<div>
<h2>${a}</h2>
<br>
<b><i>${b}</i></b>
</div>
</script>

To actually enact this template, you simply pick a place for these items to exist like <div id=”myFooDiv”></div> and write the following line of jQuery code:

$(“#fooTemplate”).tmpl(myFoos).appendTo(“#myFooDiv”);

Pretty simple. There are other things to learn, but that’s the gist of it.

Data-link binds objects to other objects and uses change events to update targets. It’s another really cool concept that’s also extremely simple. Data link is a jQuery plugin with two methods: link and unlink. If you have two objects that you want to link together (the links are two-way by default), you say

var foo = {};
$(“form”).link(foo);

Every time a named item in the form changes, an associated property in foo will either be modified or created. Links are, by default, two way.

Matt also spent time looking into the future of these technologies. He mentioned jsRender, jsView and jQuery Datagrid. jsRender and jsView are supposed to be updates to templates and linking. jQuery Datagrid will also update templates and binding.

For the last talk, I went to see Silverlight 5 by Jeff Brand. I thought that was a good idea, seeing as how I would be giving a talk on the same topic for Code Camp on October 9th. I had already written out a rough draft outline for a short speech at TechMasters, so I knew what I would be discussing, even if I was nowhere near finished. Jeff talked about most of the stuff I wanted to talk about, sometimes going off on a few tangents or including more in-depth information. I ended up snagging a couple of things from his presentation. Mainly the performance metrics on printing, an image illustrating how much sharper the text looked and another image showing linked rich text boxes. It was certainly a good talk that helped me get ready for my talk.

Another great MDC in the books. I hope to see you all next year!

I don’t get it. True synchronous web calls in Silverlight are impossible. I’ve tried every suggestion out there. Not possible. Giving up

Source: http://twitter.com/#!/vbullinger/status/122425689566748672

Well, I couldn’t let that stand and figured it out.

Put this method in your Silverlight.js file:

function SyncWebServiceCaller() {
var client = null;

if (window.XMLHttpRequest)
client = new XMLHttpRequest();
else if (window.ActiveXObject)
client = new ActiveXObject(“Microsoft.XMLHTTP”);
client.open(‘GET’, arguments[0], false);
client.send();
return client.responseText;
}

Then, in your Silverlight code, where you want a synchronous call, just put this:

string webResponse = HtmlPage.Window.Invoke(“SyncWebServiceCaller”, “http://MyWebsite/MyService.asmx/MyMethod?parameter1=value1&parameter2=value2″).ToString();

My example is for a web service, which is what I wanted. You can do whatever, but due to cross-site scripting, I’m pretty sure you’ll be sticking with services within your solution.

I want you to closely read the Wikipedia definition of monetary policy to see just how powerful a topic this really is:

“Monetary policy is the process by which the government, central bank, or monetary authority of a country controls (i) the supply of money, (ii) availability of money, and (iii) cost of money or rate of interest.”

It doesn’t take a genius to figure out that having any level of control or influence on monetary policy can have a major effect on just about everything. And if the wrong people have any control over monetary policy, bad things always happen. Imagine if you had control over something that everyone wanted and no one could get enough of…

Mayer Amschel Rothschild, founder of the Rothschild family international banking dynasty, and listed in Forbes Magazine as the seventh most influential businessman of all time, once stated: “Give me control of a nation’s money supply and I care not who makes its laws.”

With any level of control over a nation’s money, you can steer the economy in such a way that you will always come out ahead. You can then, over time – and many generations – buy up more and more power and influence in the government, which would then be used to gain more and more of that nation’s wealth. This story has repeated itself over and over again in many different incarnations for thousands and thousands of years.

When the United States were still British colonies, they used British money. As the population grew, the amount of physical money became scarce. Since the British government was so far away, it was hard for them to keep the money supply adequate. Add to the fact that they just didn’t care about us, and it’s easy to see why the colonies began to import other currencies and print their own money in order to continue with normal finances.

But a strange thing happened: the colonies then flourished. After a while, England realized that the colonies were not using British money and the King sent a decree along with many enforcers to make sure that the colonies used only British money. As soon as that happened, a wave of depression hit the colonies and this was definitely the most important factor to us revolting against England that has been swept under the rug of history.

The founding fathers realized that monetary policy was a very important issue when creating our country. They knew that they had to make sure that our currency would be in good hands. Obviously, handing it over to private interests like Mr. Rothschild would be a bad idea. Transparency and controls to hold currency stable and predictable would be paramount. As such, the founding fathers put into Article I, Section X, Clause V of our Constitution that the only things that could be used as legal tender in this country are gold and silver. Gold and silver have relatively held their value very steadily for thousands of years, and their values would be very transparent to everyone inside and outside of the country.

The founding fathers knew the dangers of a loose or irresponsible monetary policy. Thomas Jefferson once said “I sincerely believe that banking establishments are more dangerous than standing armies; and that the principle of spending money to be paid by posterity, under the name of funding, is but swindling futurity on a large scale.” With the birth of the Federal Reserve, Jefferson’s worst nightmare has come true. And his prophecy about what would happen as a result is rapidly coming true, ever since our central banking authority – the Federal Reserve – came into being in 1913. We’re massively in debt, whole states are going bankrupt and we never balance our budget unless we do so by printing up more monopoly money that is backed by nothing and must be repaid – with interest – to the Federal Reserve.

Central control over monetary policy is dangerous and invites corruption. Always has and always will. In fact, it would be easy to prove that the people that push for central banking are only doing so in order to capitalize on the corruption it invites. I hope this first chapter has opened up some eyes into a rarely discussed topic that truly can make or break politicians, economies and entire nations.

Back to the Introduction to The History of Monetary Policy in America

One day, a fellow member asked a Table Topics question concerning creating a new holiday, suggesting maybe we celebrate the anniversay of the creation of the Federal Reserve. As someone who is staunchly against the Federal Reserve and central banking in general, I used that question to launch into a series of speeches against central banking and profiling the history of monetary policy in the US.

The first speech of mine about monetary policy in America was given in July of 2009. Since then, the majority of my speeches have been on monetary policy and central banking. Last Tuesday, May 24th, I gave the last of my chronological speeches. I’m putting these speeches online, in order, as if they were chapters in a short book chronicling monetary policy in American history.

I slightly altered the speeches. The introductions and conclusions were altered a little bit to make them flow better. Since these were given weeks apart, I would give a refresher at the beginning and give a teaser at the end. These are not necessary when all the speeches are at your fingertips. Also, since a lot of the information would be seen as massive shifts in most peoples’ paradigms, and I smash prevailing wisdom in the process of these speeches, I’ve given a lot of links to documents, articles and documentaries that back up my points and information.

The references are not in true bibliographic form, but they should certainly be adequate in beginning your research into the matters I bring up. Feel free to debate me in the comments, but rest assured: you will lose.

Continue on to Chapter One

public void InsertMyEntity(MyEntity entity)
{
  if ((entity.EntityState != EntityState.Detached))
  {
    ObjectContext.ObjectStateManager.ChangeObjectState(entity, EntityState.Added);
  }
  else
  {
    ObjectContext.MyEntities.AddObject(entity);
  }
}

I also noticed that delete was the same way: each entity had the exact same format. What I decided to do was to refactor these methods into something like the following:

private void InsertEntity<T>(T entity, IObjectSet<T> entityCollection) where T : EntityObject
{
  if ((entity.EntityState != EntityState.Detached))
    ObjectContext.ObjectStateManager.ChangeObjectState(entity, EntityState.Added);
  else
    entityCollection.AddObject(entity);
}

Then, in the InsertMyEntity methods, you just call the InsertEntity method like so: InsertEntity(entity, ObjectContext.MyEntities);

That, in and of itself, saves seven lines of code per entity. If you’ve got 50 entities, that’s 350 lines of code! And that’s just for the insert method. Throw in the delete (eight lines per) and you’ve saved another 400 lines of code! 750 lines less code?!? That’s a lot. Add in modifications from ReSharper (getting rid of unused using statements, all the “this.”s, the empty parentheses in the attributes (as in “EnabledClientAccess()”), etc. and you save a ton of code and everything looks just so much better.

Obviously, this is just another refactoring exercise, but I felt the need to mention it because RIA Services generates these methods for all of us so we can all use them. And we frequently have to modify the DomainService file anyway, and a lot of us don’t like looking at ugly code.

Happy refactoring!

The first session I attended was * Takes deep breath * In-Depth Unit/Integration Testing Using VS2010, TFS-2010 and Other Platforms/Frameworks by Baskin Tapkan.  Baskin is a fellow TechMaster, by the way.  As such, Baskin’s presentation skills are fantastic.  His introduction was very fun.  He also peppered in interesting anecdotes like when the F-22 failed after crossing the international dateline.  If I had to give a piece of criticism about the talk, outside of the name, it would be the immense amount of information being crammed into a 75-minute session.  He talked about TDD, BDD, unit testing, integration testing, acceptance testing, database unit testing, coded UI testing and a few other topics.  Really seemed like information overload.  Most of it was review for most of us, I’m sure, but I certainly learned a few things.  I’d never seen coded UI testing in action, for example, and it was nuts.  It takes over your mouse and keyboard and clicks on things and fills out your forms as part of the testing.  You have to take your hands off the mouse and keyboard and let it do its thing.  A couple of things seemed a little 101-y, like when he discussed unit testing and talked about Visual Studio 2010.  Baskin also gave us a nice overview of TeamCity and I came away with a nice quote on how meaningless deadlines are: “If it’s not ready, it’s not ready.”  Cue Yogi Berra.

For the second session on Saturday, I went to Introduction to Grails, by Chris Bartling.  I thought this was an excellent presentation.  The topic was interesting to me, as a .Net developer, and the content was great.  The presentation was well-paced, easy to follow and it had the perfect amount of information.  Chris was the first of a few people that had great presentations but could use a little work on their presentation skills.  A few trips to TechMasters and he’d be the talk of Code Camp.  Grails is a web application framework that uses Groovy.  Grails is similar to Ruby on Rails and ASP.Net MVC as far as the frameworks’ aims, but obviously different according to programming language.  For anybody familiar with Java (I’ve been out of the loop since college), this Grails talk would’ve been a little more manageable, but for me, it was another landslide of information.  Chris talked about Gant, GORM, SiteMesh and various other Groovy/Java-specific topics.  Though I had heard of the IntelliJ IDE, I had never seen it in use.  Chris says it’s better than Eclipse, which I found quite adequate for its day back in college.  The guys at JetBrains make a lot of good software, though, so that’s no shock.  I was glad to see Chris didn’t turn this into a huge anti-Microsoft talk, which I almost expected.  But, to be honest?  I’m not sure why I’d make the switch from .Net to Groovy, nor do I see why Grails is superior to MVC at the end of the day.  It does seem, though, that Microsoft might be stealing some ideas from the open-source community to throw into .Net, and this Grails talk definitely planted the seed of that thought into my head.  MVC- and LINQ-like ideas were all over the place.

Originally, Git More Done by Keith Dahlby was left off the schedule.  This saddened me.  Fortunately, a slot opened up and Keith’s talk was added back in, so I went to it.  Keith had a “this talk is/isn’t” slide like I did in my presentation.  It’s when you tell your audience your focus for the talk, lest they think you’ll be giving some background.  This wasn’t a 101.  I’d heard and read plenty about Git, been to a session or two about it, but I’m no expert.  I knew roughly zero of what Keith brought up.  For example, if you’ve just been tinkering with Git, and haven’t used it in a production setting, you wouldn’t know much about the git.config file, would you?  Using Subversion, however, I did have a decent understanding of the concepts, so it wasn’t too much of a stretch.  Git seems to be one of those things on which I’ve really been dragging my feet, and I should probably instead be getting them wet.  I’ll have to put that on the docket for things to get under my belt in the near future.  Other new topics discussed include git stash, git reset, git cherry-pick and git rebase.  One thing I noticed in Keith’s examples was that he talked a lot about rewriting history.  Seems like a bit of a devious use for Git, especially since most people won’t know Git at all.  Something that really stood out with Keith’s session was that he did a really good job explaining complex topics.  I didn’t feel like anything went over my head at all.  And I walked away with another memorable quote when Keith was talking about stashing: “OMG, drop everything and work on this problem!  That never, ever happens.  Ever.  Right?”

My talk was next.  So, onto the next talk.

To round off the end of day one, I attended Introduction to Scala by Dan Chamberlain.  Dan was another guy that would be a good candidate for TechMasters.  Otherwise, it was another really good presentation.  One of the first things I noticed was that he was using Eclipse.  I asked about what he thought about IntelliJ and he said that Eclipse was the better IDE for Scala.  I thought I’d check the interwebs and it seems like most people think that IntelliJ is better:

http://theyougen.blogspot.com/2010/01/best-scala-ide-intellij-idea.html

http://weblogs.java.net/blog/lifemichael/archive/2011/03/21/scala-intellij-plugin-0

Dan assures me that Eclipse is getting better with regards to Scala.  As it was, the Eclipse editor was very buggy and interrupted his otherwise excellent presentation.  I was originally thinking that Scala was a functional programming language, but Dan showed me that it’s definitely a hybrid.  That’s pretty slick.  Apparently, the creator of Groovy likes Scala, too: “I can honestly say if someone had shown me the Programming in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I’d probably have never created Groovy.”  Dan covered most of the bases: immutability, pattern matching, etc.  Most of the talk wasn’t ground breaking, and I understand all the concepts behind the paradigm.  I’m comfortable enough with functional programming that I feel like I could use Scala if I wanted to do so.

To kick off the second day, I went to Heal Your Code with Rx with Judah Himango.  Judah had, without a doubt, the prettiest presentation slides of the conference.  He had some clever graphics, too.  For example, since Rx not only means “reactive extensions,” but also prescriptions, Judah used some pharmacy pictures in his PowerPoint.  When he was going to define Rx, he had a Google define prompt for an image.  Those were interesting, but his jokes were a little off.  Not sure if he’s spending too much time with Mike Hodnick (making him try to be funny when he’s not) or not enough (Mike’s humor hasn’t rubbed off on him yet).  Judah’s presentation skills were much better than his humor, however, and he had great volume and a good command of the room.  I did notice that he probably could have buttoned up just one more button on his shirt, however.  That or wear an undershirt.  Pretty sure that was intentional to leave that button undone, too.  While watching Judah’s presentation, I came to the embarassing conclusion that I’d never explicitly used an ObservableCollection before.  The whole talk was incredibly interesting.  I really like LINQ and just better ways of doing things in general, so I was really enthralled by the power of Rx.  He had some great demos, as well, to point out what Rx was doing, like the demo showing how events can create memory leaks and how Rx can be used to fix that.

I noticed that four out of the five talks that I attended on day two were in the same room.  So, I didn’t have to move to see Dev for the XBox Kinect with .NET by Mike Hodnick.  Mike first let us know that his talk may be partially or completely obsolete, depending on the announcements at MIX.  He’s assuming that there’s going to be an announcement surrounding a Kinect API.  But he said it’d still be valuable to sit in as many of the concepts would more than likely carry over.  Mike got us all interested right away by showing us the Minority Report video we’ve all seen.  Obviously, this was a fun talk.  We got to see Mike wave a bunch and act silly for 75 minutes.  He went over a couple of Kinect libraries out there like OpenKinect, OpenNI and CodeLaboratories.  The demos he should included cursor control, push control, smoothing, swiping and skeleton tracking, as well as the display at the entrance to Avtex, where Mike works.  All that with a little smack talk for C++ developers made for a really fun presentation, as is usually the case with Mike.

The next session to which I went was “I Didn’t Know You Could Do That” .NET Tips and Tricks by Jon von Gillern.  I wasn’t sure what the format of this talk would be, but it ended up being pretty awesome.  Basically, Jon went through a litany of things he’s learned over the years, and sometimes we’d chime in with little tangential tidbits.  Jon’s a geek after my own heart, let me tell you.  Though he basically just reinforced the majority of how I code from day-to-day, I still learned a lot.  He gave the advice of unplugging your mouse for a couple of days to retrain yourself to use the keyboard.  Well, I don’t need to do that because I do that all the time.  But if you find yourself doing things like clicking on the run button in Visual Studio, maybe you do need to try it.  You should know as many shortcuts as possible.  If one doesn’t exist, then Jon suggests creating your own.  I have to say, I’ve never made my own shortcuts.  I might end up doing that if I can think of things I typically do that don’t have shortcuts.  Little tidbits I ended up learning include:

• Hitting F9 while your cursor is on a part of a line, like a part of a for loop, will set the breakpoint in that individual part of the line.  If you were to click on the left-hand side of the line to set the breakpoint, it would always be set to the first clause of the line.
• Alt+d in a browser will bring you to the address bar.  Go ahead.  Try it.  I’ll wait.
• Control+dragging the mouse will allow you to copy parts of multiple lines in Visual Studio.

I also learned that I’m a “ReSharper traitor.”  Jon seems to prefer CodeRush.  Jon’s one of those people that thinks that the singular form of parentheses is parenthese instead of parenthesis.  I also could’ve done without the “VinceSucks” part of one of his demos, but the part where he wrote throw new Exception(“ha ha ha, Jason isn’t here”); was pretty funny (Jason Bock is very much against ever throwing a generic exception).

The only session I attended not in that same room was Build an N-Tier App with Entity Framework, WCF Data Services, and ASP.NET MVC by Dave Stienessen.  Dave should stop by TechMasters, too.  I’ve worked with projects that have dealt with some or all of these technologies, so not a whole lot of this was new to me, but I did get some nuggets out of it.  I hadn’t dealt with the ADO.NET Mocking Context Generator, for example, as well as the SetEntitySetAccessRule method, WCF Service URI filters, ChangeInterceptors and QueryInterceptors.  I thought this was a solid presentation on a pretty important set of technologies for the near future, but you never want to say this while presenting: “The version that’s on my blog works.”  That was pretty funny.

The last session I attended was Secure Coding Practices for .NET with Glenn Leifheit.  Another fellow TechMaster, Glenn definitely gave a great presentation.  It’s really amazing to see how much he’s grown since he joined TechMasters.  He had a good command of the room and kept everyone interested the whole time.  The gist of the talk was how we, as developers, focus on frameworks and algorithms and don’t put enough focus on security.  A memorable quote that Glenn gave out was: “Hackers only need to find one weakness.  Developers need to protect everything.”  Interesting facts Glenn mentioned include:

• 13% of websites are compromised on front page
• 49% of websites contain critical or high risk vulnerabilities
• 99% of apps do not meet PCI requirements

Glenn had a lot of good anecdotes and I think this was a real slap in the face to a lot of us.  The presentation was engaging and thought-provoking.  He gave us a lot of tips involving auditing and logging, exception handling, session and state management, input validation and encryption, among other things.  After dumping a lot of information on us that undoubtedly went in one ear and out the other, Glenn finished up by offering a couple of book recommendations so we could actually take all of this in.

I didn’t get as lucky as I did last time, and I didn’t come away with an awesome book like last time.  I did, however win a book.  Which one?  A glorified user manual for Android phones…

No worries, however, since I got to spend a whole weekend learning a ton of great stuff.  These kinds of chances to get a lot of free training, great networking and a possibility to present yourself should really be taken by any developer within a hundred miles of the Twin Cities.  It’s a great way to improve yourself and is really a lot of fun.  Hope to see you at the next Twin Cities Code Camp in October!

If you didn’t know, the market’s crazy right now.  I’ve frequently made the analogy of holding a beach ball underwater.  You can try as hard as you want to keep down your costs in a down economy by not embarking on new, technological endeavors, but you will soon face the facts: keep up or get plowed over.  You can’t cut certain costs, no matter the economy.  So, when the economy seemingly bottomed out (for the time being), companies opened up the dams and let the projects fly.  At least, that’s my estimation as to what’s been happening lately.

As such, the market is very good right now.  I poked my head juuuuuust over the fence, and was just slammed with recruiters calling, emailing, etc.  I’m sure you know the drill.  With the market the way it is, I decided I might try my hand at independent consulting.  Either I’d be able to keep doing it long-term, or I’d find a place where I’d like to stay permanently in my travels.  I could also just give a list of things that would describe the perfect place for me and do the independent consulting thing until a recruiter brought the perfect permanent position to my feet.

So that was the plan: try independent consulting until a perfect opportunity came my way.  My list, for those who would want to know, included:

• A place where I’d always use the latest technologies
• A place that encouraged – not just allowed – extra curricular activities like user groups
• A role that was using really fun stuff.  I listed off Silverlight, WPF, MVC, jQuery and HTML 5 as current, fun stuff
• A place that was close to where I lived or allowed me to work from home sometimes
• A role that looked for input from me, where I wasn’t just a cog in the wheel

All of that might seem a little arrogant or asking a little too much, but I was prepared to wait and work a few gigs while waiting for the right opportunity to present itself.

I had a good handful of ok consulting gigs tossed my way that I considered, but most were trash.  Let me tell you, people: Wells Fargo is hiring!  Just about every single recruiter tried to jam a contract with them down my throat.  I’d rather be unemployed.  There were two pretty nice sounding consulting gigs I was really looking at, however.  One was extremely close to where I live and was going to be with a very strong team of developers, mostly independent consultants.  The technologies were great and I would’ve learned a lot and built a lot of good skills.  The other one was more on the fun side and paid extremely well.

But I was given an opportunity that meet all of my criteria.  Right now.  So I took it.  I get to use Silverlight, WPF and MVC right now.  I’m not a cog in the wheel.  I can work from home if I so choose, but the commute is great anyway.  I met with the CTO and he’s more in tune with the latest and greatest things than I am.  He was a developer for a long time and moved into his current role after working with them as an independent consultant.  He didn’t want to leave.

About this blog post’s title.  In case you didn’t know, LeBron James is kind of full of himself.  This past offseason, the best basketball player alive was a free agent.  When he decided where he was going to go, he had a brilliant idea: instead of just telling everyone with whom he’d be signing, he’d make a one hour special on ESPN that would have us all worshipping him.  He called his special “The Decision.”  Hence the name of the blog post.

But, wait, Vince, trois means “three,” not “two.”  What gives?

I would have called this post “The Decision: Part Deux,” but Anthony Tolliver beat me to it.

So, what was my decision?  I decided to take my talents to Hastings and work for Anytime Fitness.

public String SerializeMe(MyClass myInstance)
{
StringBuilder myInstanceStringBuilder = new StringBuilder();
new XmlSerializer(typeof(MyClass)).Serialize(new StringWriter(myInstanceStringBuilder), myInstance);
return myInstanceStringBuilder.ToString();
}

That’s awfully clunky. I thought I’d make an extension method, but then I realized that, in order to do so, I’d have to have an instance of XmlSerializer first to use an extension method. Well, there are no parameterless constructors for XmlSerializer, and you’d negate the benefit of creating the extension method in the first place if you used any of the ones with parameters.

So, I decided to extend the XmlSerializer class. Here’s the result:

public class QuickSerializer : XmlSerializer
{
public static String Serialize(object instance)
{
StringBuilder instanceSB = new StringBuilder();
new XmlSerializer(instance.GetType()).Serialize(new StringWriter(instanceSB), instance);
return instanceSB.ToString();
}
}

Now, anything can be serialized (if it’s serializable) by just this little snippet:

QuickSerializer.Serialize(myInstance);

Much quicker and much easier. This is the way it should be. Happy serializing!