Category: General

My blog at nicholasbarger.com pretty much died. It had a decent run from 2008–2013, but then a sudden death. I stopped writing, forgot about controlling all of the SPAM comments, and even forgot to update my credit card which subsequently caused my custom css theme to disappear.

I’m not quite ready for a blog eulogy, so time for a reboot and let’s see if we can salvage the remains.

Looking back at why I started my blog, I remember how I wanted to share what knowledge I had and help strengthen what topics I was learning. This was much easier to do when I was focused purely on technical topics. Programming languages, frameworks, libraries, and databases are so much easier to identify learning milestones and gain that feeling of accomplishment. They are black and white, either you know it, and the application you’re writing works, or you don’t and you continue learning more (and look it up on Stack Overflow).

In 2013, I spent the vast majority of my occupation in meetings. Some of my time went to architectural design and creating technical solutions, but most of my time went to project management, scheduling, explaining issues, and rehashing the same thing over and over. Though I complained at times, it wasn’t bad. In fact, I’m pretty sure I learned just as much, if not more during that year than ever before in my career. However, the accomplishments of that kind of learning aren’t black and white, and they can be sneaky at teaching you more abstract lessons.

One of those lessons learned was about how much impact you can have on people in ways you usually don’t even know. There have been many people I worked with directly who I really focused on to try and help and others I feel like I was nothing more than a casual acquaintance. To my surprise, months or years later, it has been the casual acquaintance that I hear from out of the blue to tell me that I made a difference some small (and on rare occasion, big) in their life. It doesn’t happen often, but when it does, it’s quite an experience. First I feel flattered, then a bit confused because what may have been an important conversation or action at the right time for them might have been casual and fleeting for me, and in some cases, I may not even remember it. Sometimes that leads to guilt not intentionally creating a relationship with them as I may have had with others. However, I realize that is how things work, and the impact others have had on me happen in much the same way. Some are direct and built over hundreds or thousands of interactions, others just happen to strike the right cord at the right time.

These interactions give me an occasional reminder of how important it is to set your default to being the kind of person you want to be remembered as, because when your guard is down may be the time you’re making an important impression.

I am at the point where I visibly cringe at the mere mention of corporate buzzwords such as “paralysis analysis”, “single source of truth”, or “low hanging fruit”. However, all of these phrases are rooted in tried and true explanations of important and complex situations. I think it may be simple for communication to summarize these situations with a succinct two or three word phrase, but I also believe it is important to first understand what you may be short handing when you employ a phrase like this.

I can think of no better example than “paralysis analysis” (or “paralysis by analysis” for the longer form). Even now, I struggled with picking up my laptop and writing a draft of this blog post because I’m thinking of the following choices:

• It’s 3:30AM and I need to get rest to watch the kids tomorrow morning (Saturday).
• I really should be working on my project at work to meet this crazy deadline and the project accounts for significant impact to the company and potentially my career there.
• I could be working on my side projects to start a company.
• I could be attempting to drum up side work or consulting time.
• I really should watch Pluralsight or some other educational material to continue learning and stay sharp.
• I should put together a presentation for work.
• I should put together a presentation for the developer group.
• Etc.

You may look at this and say, this is just a task list; but it’s a conscious decision that I have to make before I take action to write this post and for the entirety of writing the post until completion to decide whether this is the best use of my time right now (or whether I want to do it the most). I find this incredibly difficult the longer the task is, for example, reading a book is excruciating to me lately because the pace is so much slower and I wonder if I should be doing something more “productive” which in many cases leaves me with not finishing the book and not doing a good job at the next task because I am thinking about having not finished the book.

A really strong light was recently shined on this for me when I stumbled across a TED talk by Barry Schwartz titled The Paradox of Choice. It’s fairly short at only 19mins and it’s been around for a couple of years now, but I really applaud the content. In the talk, Mr. Schwartz discusses many points regarding the simple fact of having so many choices that it provides less pleasure and focus on any one decision made and produces a sense of buyer’s remorse of allocated time. Wow, talk about your first-world problems, but this hits home for me like few others I’ve read or seen in the past year!

When thinking back of examples on when I generally write (decent) blog posts, learn new topics, write my best code, or actually solve difficult problems, it’s often at times like this: late at night, everyone else is asleep, sitting in the dark – relatively single focused. It’s not that I am anti-social or a recluse. It’s not that I can’t prioritize and push through distractions. It’s because my options are limited at 3:30AM, the pressure of so many activities or demands are slightly farther away right now, and there is some higher percentage of my consciousness that is focused on less problems.

It seems obvious as well that a lack of focus directly corresponds to a lack of quality in executing any one task and I’ve noticed that as my responsibilities in life and work become more diverse and when I can only allocate small tidbits of time across a great many activities, I sometimes look back and feel unsatisfied with the job that I’ve done. What’s interesting about this to me, is that usually I’ve done a good job; I met the goal, the customer is happy, some positive outcome – but I know I could have done better.

Now, with everything there are tradeoffs, and my focus on individual tasks currently is being supplanted with an opportunity to discover a much vaster array of different experiences that one would hope would have a synergy in and of itself. Perhaps in a couple of years I will be able to write a similar post on whether at the time of this writing I actually understand “synergy” or if I am merely using another buzzword.

I recently finished the Mythical Man Month by Frederick Brooks. Many of you have probably heard of Brook’s Law (Adding manpower to a late software project makes it later), and though this is the most popular and lasting theme of the book, additional sections of the writing are still relevant even after more than 30 years. Pause and think about that for a moment, a computer book speaking on the development of mainframe operating systems is relevant today; a time when most twitter remarks are outdated after hours or even minutes.

The book covers the assembly of focused teams, establishing effective roles for team members, how communication becomes the linchpin of a project’s success (which is the basis for why adding manpower can actually cause projects to be delayed even farther).

In addition to some of the interesting team development strategies and project management, there are some great quotes to remember from Mr. Brooks. The following is one in reference to the joys of programming that grabbed my attention:

“The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures.”

As I read this, it reinforces a development strategy I believe in, which is to have an idea of what you want, but as soon as possible to simply start. In generally, it is inexpensive to start prototyping software. It can be refined, scrapped, re-developed, and of course, there is always the infamous “phase two”. All of this initial work helps define requirements, design architecture, and identify many of the unforeseen difficulties that will happen no matter how much up front planning you do.

If you’re interested in learning more about Brook’s Law and the unique challenges of development projects from the 70’s, check Amazon to pick up your own copy: http://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959/ref=sr_1_1?ie=UTF8&qid=1304000450&sr=8-1

Web services are great aren’t they? You can easily link Java code, .NET code, and even many more obscure languages together with some type of XML-based web service. However, working with all of these different sources of code can be a little concerning as bug tracking and testing is concerned. Often times, when a change occurs it could impact several areas, which is why it’s great to have a tool to test just the web service (or a collection of web services) and experiment with different values passed to the service quickly.

I’m sure there are several options out there but I’ll share the open source one I’ve been using lately, SoapUI. Here are a few steps to get you started:

Step 1 – Download and Install

Head over to SourceForge and download SoapUI community edition. (I think I recently read that SourceForge owns ThinkGeek – if you haven’t been to ThinkGeek you’re not a true geek!)

Step 2 – Create a New SoapUI Project

Enter the project name to whatever you like (CalculatorWebservice, for example).

Enter the WSDL location of the web service; this can either be local or a remote address. If you would like to follow along you can use the following public web service URL: http://soatest.parasoft.com/calculator.wsdl.

By default “Create sample requests for all operations” should be checked, this creates a stub request which you can modify to plug in your own values later on.

Step 3 – Open Stubbed Request

Use the navigation tree on the left side of the window to open your new project you’ve created, this should read “CalculatorWebservice”. Choose an operation to expand (we’ll use “Add”) until you expose “Request 1”. This is the stubbed request that you will alter to begin testing the web service. Double click “Request 1” to open the XML request in a new window.

Step 4 – Modify and Send Request

The nodes will originally display a “?”, expecting you to enter a value for the nodes. Enter all values that you would like to pass into the web service. If you are following along with the example, you can enter 1 for x and 4 for y. Click the green run button in the top left to send the web service request.

Step 5 – Evaluate Response

The split screen will now favor the response window which should have the XML response returned from the web service (if you passed in bad data or if the web service failed, you should see the failure related response as well).

You now have a quick and easy way to load up multiple web services, adjust the input values and test the responses before complicating the situation with your own code. Hope this helps!

When working in an enterprise environment, invariably, you’re going to need to have a process for developing and eventually deploying applications to production. This is an important and potentially stressful process in development because it affects live data, business up-time, and highlights any failures in the development of the project.

There are several ways to structure the process of eventually deploying software applications and much of this depends on the business commitment to the software being developed. I will attempt to discuss what stages in the development life cycle to base environments on regardless of the software development life cycle (SDLC) methodology being employed.

Three-Stage Environments

We’ll start with what I consider to be the most basic, yet still complete, environment setup. This will consist of three physical (or virtual) boxes labeled: Development, Staging, and Production.

Development – This box will contain the latest and greatest (and most unstable) code which developers are currently deploying to or working against. This is not the local/client-development environment which developers write code against (Visual Studio for example). This is a stand-alone box which has the development-grade code deployed to it. This box may have a database associated with it which either resides on the same box or on another physical (or virtual) box within the development realm. Often times, developers using their local development environment (their client computer) may talk directly to this Development database instead of their own local versions.

Staging – This box contains the expected production-level code which may need to be tested or accepted prior to being deployed to production. The staging environment should be an exact replica of the Production environment in regards to physical attributes of the server and software installed on the server. Using three-stage environments, the staging server also acts as the quality assurance (QA) and user acceptance testing (UAT) environments. Once all tests are completed and the code is officially accepted, the code may be deployed again to staging to test the deployment procedure in a mock production deployment test. This procedure will be repeated when it is time to officially deploy the application to production.

Production – This box is the live system which end-users perform their work in. The production environment is always the oldest, and hopefully, most stable environment. Code changes, including bug fixes or patches, should only be deployed to production after they’ve been tested by the development team in the Development environment, and test/approved via the Staging environment before being deployed to production. In most cases, including Agile development, the production environment should not be in constant change because of the increased instability this often causes.

Pro’s

There are several pro’s to setting up three-stage environments; primarily, they’re fairly easy and more inexpensive than other models while still giving you much of the benefit of life cycle environments. Having a limited number of environments means lower maintenance of the machines, fewer licensing costs, and less backup responsibilities to worry about.

Con’s

Of course, this comes with a few trade-offs. Primarily, in larger environments where there is a dedicated QA team that can perform automated tests on the code which may be processor or bandwidth intensive can significantly impact the performance of an environment. This can therefore impact UAT testing or approval demonstration. Additionally, many QA software packages require additional software to be installed on the box which then somewhat invalidates the cardinal rule of Staging and Production environments being the same.

An additional note on Staging and Production being the same:

Even though we attempt to make Staging and Production exactly the same, there will be some differences; such as where the box sits relative to the network (firewalls, etc.), user permissions, production-specific data, etc. It is at your discretion which of these things need to be the same and which can be different; just keep in mind, the more differences, the more likely a failure during production deployment will occur.

Distributed Systems

Setting up environments based on the development life cycle for distributed systems is similar just on a larger scale. Instead of three boxes, you may have specific boxes for each layer in your architecture (such as Data Access, Business Logic, Presentation, etc.). In this scenario your environments would simply contain more physical (or virtual) boxes.

Source control is an important concept in modern day programming, especially when working in a team environment. Most Microsoft-based shops use either Sourcesafe or Team Foundation Server (TFS). TFS is a great product, it does everything under the sun, but at a pretty hefty cost. In steps Subversion, lightweight, capable, and (drum roll)… free! I tend to promote things that are both competent and well priced. I certainly encourage you to look into Subversion as an alternative to TFS if you lack the size or resources at your current stage of development.

Below, I’ve outlined a few pieces of information that I found useful while setting up Subversion and integrating it into my Visual Studio instance. This is by no means comprehensive, as you can find much more information and specific instructions for installation and use from Subversion directly. Consider this the “cliff-notes” version.

The Tools You Need

• CollabNet Subversion
• Tortoise SVN
• Ankh SVN

CollabNet Subversion

CollabNet provides an “enterprise-ready distribution of Subversion”. It is simply another flavor of Subversion which is purported to be one of the most stable versions. This provides the server and command-line client.

Tortoise SVN

Tortoise SVN provides a graphical interface for using Subversion as a shell extension. You simply install Tortoise SVN, right click on a folder and are provided with additional Subversion actions within the file context menu. Additionally, you can use the Repo-Browser to open a File Explorer-like view of the source controlled files.

Ankh SVN

Ankh SVN is a Visual Studio plugin which can be added to integrate Subversion into Visual Studio (similar to TFS/Sourcesafe).

There are several tools available that you can use in place of these, but I’ve found these three work pretty smoothly for real-world use.

Setting up a Repository

Creating a repository once you have Tortoise SVN installed is very easy. Create a folder in Windows, for example, c:\svn; right click on the folder, in the context menu, inside TortoiseSVN, select “Create repository here”. See screenshot below.

This will automatically setup all of the directories and files necessary for a repository where you can begin adding source controlled files and projects to.

Making the Repository Available Online

To allow your Subversion repository to be available remotely, you’ll need to add it as a service on a hosting server. You can do this by running the following command (change directory paths to match the location of subversion as well as the location of the repository) on your server.

sc create svn binpath= "\"c:\program files\collabnet subversion server\bin\svnserve.exe\"
--service -rc:\svn" displayname= "Subversion Server"
depend= Tcpip start= auto

Kick off the service if it is not already running, by entering the following command line:

sc start svn

Setting up Access/Authorization

Once you create a repository, open the folder (c:\svn), and open the “conf” folder to see the following files:

• authz
• passwd
• svnserve.conf

authz File

The authz file contains a sample “database” of authorization rules which can be used by Subversion to limit access to users, groups, or aliases. Let’s take an example of two users, Bob and Susan. First we need to add the users to the [users] section and assign them read/write (rw) access, as follows:

[users]
bob = rw
susan = rw

Next, we’ll need to modify the authz file to specify that all authenticated users have access to the repository; we do this with the following:

[users]
bob = rw
susan = rw

[/]
$authenticated = rw

There are several additional examples and notes autogenerated within the authz file; you can learn quite a bit by playing around with these entries.

Limiting Access to Specific Directories

Let’s now further restrict the repository so specific users will have access to certain areas, while others will not. Bob will have full access to the entire repository, while Susan will have access to everything except a directory called “private”.

Our repository directory will look like this:

c:\svn
c:\svn\private
c:\svn\public

In the authz file, we need to make an additional change to designate that only Bob has access to the private directory. Here is our previous authz file with the new access rule; we’ve added the directory to which only Bob has access to. The two criteria beneath the rule indicate to set access of ” (none) to everyone (*) which essentially blocks read/write access from all users. We then add to that entry by saying Bob = rw (read/write access for Bob only) in the next line to allow Bob access.

[users]
bob = rw
susan = rw

[/]
$authenticated = rw

[/private]
* =
bob = rw

passwd

The passwd file contains a “database” of users and corresponding passwords. Simply add your authenticated users and their passwords (one per line):

[users]
bob = password1
susan = password2

svnserve.conf

The svnserve.conf file contains several configuration settings for Subversion which you will need to modify to enable access control.

Here are the key entries that you should adjust:

anon-access = none
auth-access = write
password-db = passwd
authz-db = authz
realm = My Repository

There are directions and examples in the svnserve.conf file that are generated when you create a repository. The above example is pretty standard if you are going to allow multiple authenticated users to access your repository while keeping anonymous users out.

Further Information

You can find an abundance of documentation in the above links as well as at http://subversion.tigris.org/. If you have any quick tips that you would like to share, please add them below in the comments.

Education provides one of the greatest advantages in life. It is knowledge, that indiscriminantly improves a persons’ position in life. In my experience, it doesn’t matter age, ethnicity, gender or origin, you’re valued by what you know and what you can accomplish.

Yet education isn’t necessarily cheap, not only in terms of money but time as well. In cases where,
for whatever reason, going to (or back to) school is not an option, or you’re simply a self-learner, there is another option.

MIT, in conjunction with several other renowned educational institutes have spear-headed the Open Courseware Initiative, an “open-source” view of education. Many courses spanning across all subjects are provided without charge over the internet. Courses vary in what material is provided, but many include audio/video sessions of actual course classes.

For those interested in Information Technology, Stanford has one of the most comprehensive collections of computer engineering courses called Stanford Engineering Everywhere. Video is provided via YouTube, iTunes U, Vyev, WMU Torrent, and MP4 Torrent and cover the following course schedule:

Introduction to Computer Science

• Programming Methodology
• Programming Abstractions
• Programming Paradigms

Artificial Intelligence

• Introduction to Robots
• Natural Language Processing
• Machine Learning

Linear Systems and Optimization

• The Fourier Transform and it’s Applications
• Introduction to Linear Dynamical Systems
• Convex Optimization I
• Convex Optimization II

In addition to Stanford, MIT, Yale, UC Berkely, and many other schools offer free courseware. Now you can actually download many of the courses audio/video through iTunes U, a section within the iTunes Store which contains free open courseware content. All of your college classes right on your iPod, can’t beat that!

If you would like to learn more about open courseware, please check out some of the following links and begin reaping the benefits of a free education.

• MIT Open Courseware
• Stanford Engineering Everywhere
• Open Courseware Consortium
• Open Culture
• 101 Killer Open Courseware Projects from Around the World (bestcollegerankings.org)

One of the first tasks I was assigned when I started my new job was to recover some old source code that a contractor had developed for the company several years back. My company had working dll’s but no source code to make changes from. This was my first real exposure to Reflector and disassembling binary code. I’ll be honest, I got a real kick out of, the hacker mentality of my youth came flooding back but without any guilt because this was a legitimate (and legal) reason to disassemble code.

Since then, I’ve found Reflector to be an invaluable tool in a developer’s arsenal for the following scenarios:

• Retrieving lost source code.
• As a learning tool to peak into other, possibly more sophisticated code and code architecture.
• To assist in troubleshooting third-party vendor software (which is certainly not immune to bugs).

These are just a few reasons, but all contribute to advancing your skill as a developer and worth to your client(s)/company.

Where can I get it and how much does it cost?

There probably are a couple out there, but I use Red Gate’s .NET Reflector which you can download a FREE copy.

Red Gate produces various other products that are useful, though many of them are not free.

How do I use it?

Glad you asked; Reflector is pretty easy to use. First, begin by opening Reflector, selecting File > Open and selecting a .NET based DLL that you would like to analyze. For demonstration, I will be using one of the nopCommerce DLL’s, Nop.Common.dll. (nopCommerce is a .NET open-source ecommerce project).

If the Disassemble panel is not already open, go ahead and open it now by right clicking on the assembly you just loaded, and selecting Disassemble.

By drilling down the tree-style panel on the left side, you can see all of the individual namespaces that comprise the DLL.

This takes a bit of digging, but with enough patience you can find what you are looking for. We will now select NopSolutions.NopCommerce.Common.Audit > LogManager to view the code in this class.

Next let’s move to the right side panel and scroll to the very bottom and click “Expand Methods”. This will allow us to see all of the code in the class. A nice touch is that you can view code in your language of preference, such as C# or VB.

You are now able to disassemble .NET code in a breeze, remember, “with great power, comes great responsibility”! Please make sure that whatever you are disassembling you have the right to disassemble it. Good luck on your next project.

Technorati code: zneh8mkst6