NUnit 2.2.4 Released!!

Just got an e-mail within the Test Driven Development Yahoo Group from Charlie Poole concerning the release of NUnit 2.2.4:

If you haven't followed the development releases, here are a few highlights of what's new, as compared to NUnit 2.2:

* NUnit 2.2.4 runs under .Net 2.0 and works with VS2005. If you work exclusively with .Net 2.0, you can download a version that is actually built with that framework version, which eliminates dealing with the config file.

* You can run tests built against older versions - 2.0 or later - of NUnit without recompiling. As a bonus, you can run tests built against CSUnit without recompiling.

* A number of new Asserts and Attributes have been added. It is now much easier to create your own custom Asserts while still taking advantage of NUnit's built-in error message formatting.

* An extensibility mechanism allows you to define your own attributes for test fixtures and cases that behave in non-standard ways. [This feature is Still a bit experimental, and will appear in final form in the 2.4 release.

* Documentation is substantially improved and is provided as a set of html files. The packaged documentation includes only version-specific details, with info that may change over time, such as contacts, kept on the web site.

You can read the full release notes at http://nunit.com/testweb/index.php?p=releaseNotes&r=2.2.4. Note that the nunit.org site has not yet been updated to reflect this release.

You can download NUnit 2.2.4 at http://sourceforge.net/project/showfiles.php?group_id=10749

A thought experiment, just for fun

I typically, for a brief dose of humor, will go to the Dilbert site some point in my day. As I browsed to the daily comic strip I noted a link to Scott Adam’s free e-book entitled God’s Debris. Here is a part of the introduction:

The central character in God’s Debris knows everything. Literally everything. This presented a challenge to me as a writer. When you consider all of the things that can be known, I don’t know much. My solution was to create smart-sounding answers using the skeptic’s creed:

The simplest explanation is usually right.

My experience tells me that in this complicated world the simplest explanation is usually dead wrong. But I’ve noticed that the simplest explanation usually sounds right and is far more convincing than any complicated explanation could hope to be. That’s good enough for my purposes here.

The simplest-explanation approach turned out to be more provocative than I expected. The simplest explanations for the Big Questions ended up connecting paths that don’t normally get connected. The description of reality in God’s Debris isn’t true, as far as I know, but it’s oddly compelling. Therein lies the thought experiment:

Try to figure out what’s wrong with the simplest explanations.

What I found interesting is that, at least, sounds very much like the "simple design principle" that is advocated, correctly in my view, by the Agile Extreme Programming methodology.

In addition to this, I also found of interest related to software development was a discussion of pattern recognition and usage. In the chapter, Science, the central character states:

Computers and rocket ships are examples of inventions, not of understanding," he said. "All that is needed to build machines is the knowledge that when one thing happens, another thing happens as a result. It’s an accumulation of simple patterns. A dog can learn patterns. There is no 'why' in those examples. We don’t understand why electricity travels. We don’t know why light travels at a constant speed forever. All we can do is observe and record patterns." (P. 22)

In any event, instead of getting my daily fix of humor I got much more, a jolt to my thinking about fundamental questions. That, in my possibly warped view of entertainment, is for more enjoyable. Moreover, perhaps the joke is on me since I do not know nearly as much as I foolishly thought.

Agile Amigo?

Ivar Jacobson, one of the founders of UML, pledged to support Microsoft Visual Studio 2005 Team System with the goal of a more agile approach to design and modeling.

Check this potential Agile Amigo out here. This will be interesting to follow.

Microsoft released guidelines for converting ASP.Net 2002/2003 projects to Visual Studio.Net 2005

Microsoft released guidelines for converting ASP.Net2002/2003 projects to Visual Studio.Net 2005 at Step-By-Step Guide to Converting Web Projects fromVisual Studio .NET 2002/2003 to Visual Studio 2005.

The article states:

The primary benefit of converting a Web application project to Visual Studio 2005 is the ability to use many new features in ASP.NET 2.0 (e.g., master pages,etc.) in your existing application. If you are looking to enhance an existing Web application built using Visual Studio .NET 2003, then upgrading to Visual Studio 2005 is most likely the right decision.

As expected, simple projects will be easier to convert:

For relatively simple Web projects where a Webproject is the only project in your Visual Studio .NET 2003 solution, conversion should be a relatively automatic process requiring little time or problem resolution.

However, not all ASP.Net 2002/2003 project conversions will be easy:

If the application you are converting is of reasonable size and has several Web projects and additional projects, such as class libraries, in a single Visual Studio solution, it is possible to encounter issues during migration. Be prepared to spend the better part of a day completing the entire process. The steps and guidance provided in this article can help an informed user to migrate most applications of medium complexity.

Thank you Web Platform and Tools Team for your honest assessment. I must admit that I am very skeptical when someone says, "it’s really pretty straight forward." Yea....right. In any event, I am looking forward to moving some of my small-sized projects to VS 2005.

Webservice Account Permissions "Gotcha"

For a project, an internal customer wanted to utilize web services for file reading and writing. Both the file write and read services were utilizing a System.IO.FileStream object, invoking the object's Read and Write methods. Since the location that the web services would be reading and writing from is a network share, two domain accounts were setup and given read, and you guessed it, write permissions each respectively to the share.

The “gotcha” that we encountered was that the accounts that the web services were utilizing needed modify permissions on the server <WindowsFolder>/temp folder in order to generate serialization proxies.

Click here to see what was done to remedy the issue.

It's in the wild!!

SQL Server 2005, Visual Studio 2005 with .Net 2.0 and BizTalk Server 2006 had their official launch today.

Also, DotNetNuke, an Open Source Web Application Framework, is releasing its 3.2 framework, built on the 1.1 .Net, and its 4.0 framework, built on .Net 2.0.

I can see that I am not going to get much sleep.

New from Yahoo! and still in beta - Instant Search

New from Yahoo! and still in beta - Instant Search where results instantly appear for Yahoo! Shortcuts and common searches.

Covariance and Delegates in .Net 2

Click here to view this little nugget in .Net 2 dealing with covariance, an object-oriented principle, and delegates.

Very nice code re-use construct!

Essential ASP.Net 2 Webcasts and Lab Exercises

Fritz Onion has been doing some great webcasts concerning ASP.Net 2.

There are also labs and demo code provided with the slides! There is nothing like actually building something with the code to learn newprogramming constructs and techniques.

Continuous Partial Attention, please?

I typically download podcasts, audio program files in MP3 or WMA format, to listen to as I jog or mow the yard. One podcast feed that I subscribe to is IT Conversations.

A recent podcast dealt with a discussion panel of information overload and how that affects our attention to any one thing at a time.

In a world where information overload is common, attention is a very scarce resource and there is an increasing need to manage it efficiently. In this panel discussion, Steve Gillmor, Glenn Reid, Doreé Duncan Seligmann, David Sifry and Linda Stone talk about the problem of coping with more information than one can handle and the possible solutions.

In a connected world it is becoming very difficult to filter out the information that really needs our attention from that which is irrelevant to us. The panel discusses the work that they are currently involved in and tries to come up with answers to the problem of overwhelming information, only some of which deserves our attention. They talk about the tools, practices and new technology being developed to effectively use data which matters to the end user.

Part of the discussion dealt with what Linda Stone has termed continuous partial attention:

For almost two decades, continuous partial attention has been a way of life to cope and keep up with responsibilities and relationships. We've stretched our attention bandwidth to upper limits. We think that if tech has a lot of bandwidth then we do, too.

With continuous partial attention we keep the top level item in focus and scan the periphery in case something more important emerges. Continuous partial attention is motivated by a desire not to miss opportunities. We want to ensure our place as a live node on the network, we feel alive when we're connected. To be busy and to be connected is to be alive.

She then states how through the last twenty years we have come to realize that the belief that connectedness is synonymous with living is not necessarily true.

Now we long for a quality of life that comes in meaningful connections to friends, colleagues, family that we experience with full-focus attention on relationships, etc.

I for one will begin to strive to give full attention when talking and relating to not only my loved ones, but friends, neighbors, and co-workers. What higher compliment can we pay to others but attention?

It is all about people

The longer I am in the Information Technology world the more I am convinced that it is all about people. What is more important to a company than human capital? We all know that technology provides both assistance and in some forms, electronic enslavement. The latest gadgets come and go. However, when the dust settles, we the people are still here.

We are all still striving to become. Let the newest software languages and methodologies, the latest portable toys, and the most recent killer apps assist us in being, not just being wired.

ASP.Net 2 Cross-Page Posting - More than Server.Transfer

Cross-Page Posting provides what we had in classic ASP form posting and more. Instead of the form posting back to itself, as we currently have in ASP.Net 1.x, or using the Server.Tranfer method, also in ASP.Net 1.x, we can now post directly to other ASP.NET forms.

For those controls that implement the new (in ASP.Net 2) IButtonControl interface, such as the Button control, the PostBackUrl property (that must be implemented by the control), "Gets or sets the URL of the Web page to post to from the current page when the button control is clicked."

Too cool!!

For more on this go here.

The LINQ Project - Check this out!

Here is a cool announcement that came out of the PDC. According to Microsoft:

The The LINQ Project is a codename for a set of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It extends C# and Visual Basic with native language syntax for queries and provides class libraries to take advantage of these capabilities.

See a demo from Anders Hejlsberg on Channel 9.

Factory Method or Abstract Factory

Since I provided the code examples in C# for the Head First Design Patterns book, I recently got an e-mail from a reader, James Micheals, of the Head First Design Patterns book that sent me this question.

I'm trying to understand the difference between simple factory and factory method. They are the same thing! It's just one is composed while the other is inherited. I could even argue that since we prefer composition over inheritance, simple factory is better than factory method. I don't understand why factory method is better, and I've been tearing my hair out for hours to figure out why.

While I myself am a mere student of patterns here was my reply and thoughts on his question:

James,

You have asked a good question.

The factory method is good to implement alone if you have variations of a particular object that you need to create.

The Head First book uses a pizza store as the example here. The pizza store has a limited variation of pizzas it sells. Therefore, an abstract class is implemented (extended in java) in your subclasses and you are good to go for specific pizza object creation.

The abstract factory is utilized for creating a "family of objects" and therefore often utilizes factory methods within it.

In short, which pattern is used is dependent upon your need. If a simple set of related objects is what you want, then the factory method is your pattern. If you need a more varied set of objects created, the abstract factory pattern provides this via the ability to use a set of interfaces for each desired set of objects.

You stated that composition is favored over inheritance. That is correct, but which pattern is used is dependent upon your need.

Hope this helps,

Mark

Playing with Partial Classes in C#

I was reading a Partial Class Definition on MSDN and thought it looked simple enough and decided to take Partial Classes for a C# run.

Here it is.

Web UI Developers, for now, use the Firefox Browser

I am primarily a Microsoft platform developer. Microsoft makes a great IDE in the form of Visual Studio.Net and has a great language in C#, which is getting better with C# 2.0.

However, I must say, at least until IE 7 becomes more visible and out of beta, that Mozilla’s Firefox browser provides better tools for web developers through Firefox’s extensions for developers.

I especially like the Web Developer extension. Sure beats the Alt+Tab dance between the browser you are viewing your changes with and your CSS editor!

How can we be sure we are singing from the same page of music? – Fit in the key of C#

To build on an earlier posting on the use of Fit with C#, here are examples of Fit fixtures implemented in C#. The fixtures I demonstrate are the ActionFixture, ColumnFixture and RowFixture.

I also briefly discuss the desire to test properties in addition to fields and methods with Fit. I have "tweaked" the source code to provide this. My initial tests work but I would like to further test the code and submit it to other Fit developers as I am sure this has already been considered. My guess is that I may not be implementing the RowFixture subclass correctly. I will provide my source code on this later following more tests and discussion.

UPDATE 7-10-2006: After posting the above info, I submitted a proposed patch to source forge, artifact 1255429, which deals with using properties instead of member variables. The patch was submitted to source forge in August of 2005. Nothing as of this update has been done, that I am aware of, so I thought I would put it out for public consumption and comment.

In more detail, fixtures deriving from RowFixture have instantiated classes with public variables, instead of exposing the instantiated object’s members via public properties. With these modifications you can write fixtures directly against objects under test, which are typically the actual application classes, exposing properties instead of variables to the RowFixtures. This enables the .Net developer to avoid writing additional code beyond the fixture and the actual application objects under test.

The new post: Testing .Net Properties with FIT

Resharper: Sharper indeed

ReSharper provides some needed editing features for Visual Studio.Net.

For example, if you have private local variables and you want to expose those guys via public properties just Alt+Insert (ReSharper > Code > Generate... via the ReSharper menu) in Visual Studio and you get:

As you can see you can also easily generate a constructor, implement interface members, or override members from base classes.

There are many more “niceties” from ReSharper such as automatic indentation within bracket blocks {}. I got real tired of typing the brackets, separating them via hard return, and then tabbing to indent the first line in the block of code.

public void SomeMethod()
{
     //indented code here
}

Instead, when you enter a set of brackets for a block of code, ReSharper will insert your cursor between the brackets. Then, when you hit the Enter key the new line is indented for you! These are just a few of the great features of ReSharper.

I did not mention the Refactoring it provides. ReSharper rocks!!

101 Samples for Visual Studio 2005, in VB.Net and C# -- Nice!

Via a post on the ServerSide.Net site from Paul Ballard, Microsoft has released a compilation of 101 code samples in both Visual Basic.Net and C# for Visual Studio 2005 and the .NET Framework 2.0.

Samples include base class library samples, data access samples, web development samples, and windows forms samples.

Nice!

I love Virtual PC!!!!

I love Virtual PC! Now I can do something more unique with my older workstations, one with Redhat and the other with Windows 2003 Server, since I now have Virtual PC where I can have several "virtual installs" of operating systems that run on my Windows XP Pro SP2 system!

I have 2 Windows 2003 server virtual installs (one with Fitnesse, PHP5 and the Netbeans IDE running on it and the other with Visual Studio 2005 Beta 2) and am installing SUSE Linux 9.3 in a separate install next!

This is most useful when doing development R & D on various OS/platform applications. Did I already say that I love Virtual PC?

C# FIT Basic Setup on XP Pro

As you know from a previous post, I have been reading Fit for Developing Software by Rick Mugridge. What a great tool for communication and clarification of requirements between the customer(s) and software developer(s).

I am now at the chapter introducing Fitnesse. The use of a wiki format for Fit tests is powerful to say the least. More on that going forward.

Anyway, I thought it best at least to detail the steps of the basic setup of .Net's Fit on Windows XP Pro. So here you go!

Open exchange of ideas...NOT

Here is a great Dilbert cartoon that unfortunately describes the mentality of many, not just managers, in the exchange of ideas in the corporate environment. I think it is true that one can keep the subordinates or co-workers ignorant and powerless, but only for so long. Then, the brightest and best either dumb down, which harms the organization, or move on to other employers, which also hurts the company. In either case, the ones who win are the competitors.

I must say I am thankful this is not the case where I work! Thanks Sarah and Reed!!

Just got my copy of Fit for Developing Sofware!

I just got my copy of Fit for Developing Software by Rick Mugridge and Ward Cunningham! Stay tuned for musings from this book. I hope to be providing some of the book's code examples (which in are java in the book) in C#.

IT Conversations - It’s a small world indeed

Each morning, at least on weekdays, I jog my usual neighborhood loop. To make this less tedious I usually have my Rio MP3 player piping music or a podcast into my head. The last few days here in Northern Kentucky we have felt the effects hurricane Dennis. Just days earlier I watched as the hurricane ripped through the pan handle of Florida. I find it fascinating that within our vast ecosystem one pressure or influence affects another. Anyway, on my run this morning, I noted the cloud cover from Dennis. At the same time I was listening to an MP3 that was found as the result of “googling” for technology podcasts. What I found from Google was IT Conversations. You often here in agile development circles of the emergence of "organic" applications due to environmental pressures. Here, at least in my view, is the emergence of a great service due to pressures of the need for thought provoking audio in the technology “ecosystem.”

The IT Conversations site is a free, donation based podcast site that deals with everything from software development to social trends and how technology affects these domains.

I highly recommend IT Conversations and encourage all to go there. If you agree, please donate to keep the informative and entertaining podcasts coming.

Configuring NUnit 2.2 to use Visual Studio 2005 Beta 2

I have been playing with Visual Studio 2005 Beta 2 lately. I do not have any Team System install on my test server yet. I was thinking how nice it would be to meanwhile, at least, have NUnit 2.2 working with VS.Net Beta 2.

Click here for the steps to make that happen.

I will be getting Visual Studio 2005 Team Suite Beta 2 on my server shortly. Until then, it is nice having NUnit2.2 to use with just the plain Visual Studio 2005 Beta 2 install.

Language Oriented Programming

I was browsing my RSS feeds and noted an update on Martin Fowler's bliki dealing with Language Workbenches for Language Oriented Programming (LOP). This entry led to an article by Sergey Dmitriev entitled, Language Oriented Programming: The Next Programming Paradigm. As I was reading through the article I came across the statment:

In mainstream programming, most of the time spent 'programming' is really just finding ways to express natural language concepts in terms of programming level abstractions, which is difficult, not very creative, and more or less a waste of time. For example, today a good deal of development time is spent on object-oriented design (OOD). This is actually a fairly creative process where the programmer expresses classes, hierarchies, relationships, and such. The purpose of this exercise is to express the program in object-oriented terms such as classes and methods. The process of OOD is necessary because these classes and methods are the only abstractions that object-oriented languages understand. It seems like it is necessary and creative, but with Language Oriented Programming, OOD is not needed at all.

Okay, now you have my undivided attention. Having just spent a week in RUP training which was about taking use cases and performing "use case realization" which is completed to translate the anticipated business line usage senarios of the application in question, I was really interested.

The article then discusses the aspects of LOP. Then following this an overview of LOP and a JetBrains' Meta Programming System overview dealing with LOP is provided. Most interesting.
Needless to say, I will be reading more on LOP.

RUP Development Iterations and TDD together

I have spent most of this week in Rational Unified Process (RUP) training, presented by the Ivar Jacobson International company. The training was engaging in that there were several opportunities for group discussion and hands-on exercises.

During a class discussion it was stated by the teacher that within the old waterfall lifecycle approach, when the project was nearing the production release date, testing was the portion of the project that got squeezed out due to a looming deadline. The discussion then moved to the fact that within the phases of RUP, iterative style development insures that testing for that particular iteration is done and not affected by timeline pressures.

When the instructor stated that, I quickly considered past situations within development iterations where testing time still got "squeezed" because of the various pressures to move to the next iteration. Because I know the value of the Test Driven Development (TDD) methodology I thought, what if, within the RUP phase iterations, TDD was utilized?

First, the TDD methodology could ensure that the developer tests are passing and that code coverage is almost complete. In addition, TDD would make certain that the code is refactored and ready for the next development iteration. TDD could also provide a living artifact to demonstrate to the stakeholders of the project that the entire bank of developer tests is passing. (You TDDers know the warm, fuzzy feeling you get when you see the green bar of tools like JUnit or NUnit.) Finally, the tests provide a quick and automated regression testing mechanism when any changes are made to code base in future iterations.

The Rational Unified Process and Test Driven Development

Since I have spent most of this week in RUP training, presented by the Ivar Jacobson International company, I was reading a blog from Mike Bosch concerning the Rational Unified Process (RUP) and Extreme Proramming (XP).

I agree with Mike concerning "Unless you have a LOT of authority you will find it very exhausting to try and influence a culture change without buy-in from your management." I work at a large financial institution which whole heartedly supports RUP. In addition to having one of the "three amigos" own consulting company contracted to provide detailed courses on the four phases of RUP and their various disciplines, Dr. Jacobson has often provided great lectures to the application development teams that are broadcast to the various corporate team locations within the United States. In my view that is great. However any corresponding and/or competing methodology is typically viewed with skepticism and then ignored.

I have found that within the corporate environment I have been able to introduce Test Driven Development as a programming methodology that our dev team can use internally. In fact I am finding that it is a relatively easy sale because TDD is so effective concerning both the quality of code and efficiency of the team production! Moreover, the artifact of the tests is a great source of "developer oriented documentation" for new team members that are already familiar with developer testing tools such as JUnit or NUnit.

All in all, RUP is a tried and tested methodology for an organization as large as the one that I am currently employed. Yet, it is greatly enhanced by agile processes.

My First C# DotNetNuke Module

Click here to see the ramblings of my first C# DotNetNuke custom module. In the normal tradition, its a Hello World module. What else could it be, right?

Initial DotNetNuke "gotchas" with Windows XP Pro

After reading for sometime the great reviews of the opensource portal, DotNetNuke, I decided to download it and give it a spin. Wonderful framework but a few "gotchas" when installing on a Windows XP Pro OS workstation.

Click here to find out more.

PDF to byte array with TDD

At work, I was tasked with reviewing and prototyping a Windows Service that will monitor a file directory, and invoke a web service that utilizes FileNet to archive reports that will be FTPed to the directory in question.

From the sample API of the web service, the first task was to get the report, that is in a PDF format, to a byte array that will be passed to the web method.

Click here to see the how Test Driven Development (TDD) made this task much easier and quicker to complete.

What to do with complexity

I was pursuing the Creating Passionate Users blog and noted a link to a new, interesting product that the Head First folks are coming out with called Head First Design Meditations. This looks to be a deck of cards that is, Designed to be used as a brainstorming and inspiration tool, the card deck will contain small bits of software design wisdom, insights, idioms, inspiring quotes and perhaps even a chuckle or two.

What I quickly noted on the page was the following quote by Alan J. Perlis: Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it.

Wow! I must admit that when I have encountered complexity, in both code and in life in general, I have ignored it, suffered it, and avoided it. Rarely, if ever, have I removed it. What comes immediately to my mind concerning the removing of complexity is Refactoring. This I try to do regularly with code. What is Refactoring? According to the Wikipedia Refactoring is the process of rewriting written material to improve its readability or structure, with the explicit purpose of keeping its meaning or behavior. Wikipedia defines readability as, Readability is a measure of the comprehensibility or understandability of written text.

The main reason I refactor is indeed pragmatic. I find that further updates to the code is easier to do if the current code is as clear in its intent and as simplistic in its structure as possible.

Perhaps those who really are geniuses remove complexity out of altruistic reasons, for myself as a mere mortal, I remove it so I can better understand how and why.

For more quotes by Alan J. Perlis, click here.

XHTML and CSS: a union made in....

Because I sit all day hammering out code, I have to make a real effort to get enough exercise. What I often like to do is download and listen to a great weekly podcast, that is offered in both MP3 and WMA format, that is a recording of a show called .Net Rocks while I am taking my daily jog. This week’s show featured Rory Blyth and Scott Hanselman who discussed at length a great site, csszengarden.com that demonstrates the use of XHTML and CSS for website design. To date, I have used CSS primarily for font formatting, but not much else. However, a combination of both the show and the csszengarden web site have caused me to take another look at CSS (Cascading Style Sheets) and a new look at XHTML (Extensible HyperText Markup Language).

Check out my latest learning spike about using XHTML and CSS to form a great web design toolset.

NMock 101

Recently a new member of the development team questioned me on how various dependent objects, that are part of an implementation of an app we are building, could be tested using NUnit and NUnitASP, a set of unit testing tools. I stated that the simplest way I understand would be to "mock" the objects that the view (or the UI) and controller tiers under test are dependent upon. The tool that I am most familiar with is NMock. Since it had been a while since I had utilized NMock for testing purposes, I thought it would be good to review the documentation for the tool.

Click here to see the step-by-step process I used to create a demo of NMock using a TDD methodology with NUnit.

CopySourceAsHtml

Loaded the great addin for VS.Net 2003, CopySourceAsHtml , version 1.2.3, last night. However, when I went to select some code to Copy As HTML I would get an interop exception. Unfortunately, I did not copy the exception message in the dialog box that was displayed.

Anyway, the solution was to take the source code and do a local build, creating the install file and installing from that .msi file. Then all worked swimmingly.

The link from Head First Design Patterns is up

The link from the Jolt 2005 Award winning book, Head First Design Patterns website is up that links back to my page. Check it out!!

Head First Design Patterns in C# with NUnit

I recently read a great new software design patterns book entitled, Head First Design Patterns. Click here to go to the books web site.

Anyway, the book shows the code and exercises in Java. To better learn the patterns I implemented the code in C#. About halfway through the book I e-mailed the authors and let them know how much I enjoyed the teaching style of the book and informed them about the C# exercise code that I was creating. They were interested and asked me to post it to them when completed. I did and they, I say they as the book has four authors and I have been corresponding with one, suggested that I create a small web page to link too, that briefly shares my learning experience with a link to the C# code. I did and the author graciously stated that they will be linking to my page from their page (see link above) shortly. Meanwhile, click here to get to my page with the brief overview and code.

Eating Elephants

You have heard the answer to the question, “How do you eat an elephant?” Of course, the answer is, “One bite at a time.” The purpose of question/answer is to help one realize that regardless of how large your problem, challenge, issue, goal may be, you solve or arrive at the desired result, the same way, one bite at a time.

The fact that is hard to remember is that the process of eating is the same for whatever size meal you may have before you. Whether you are eating a peanut-butter sandwich or an elephant, you take the food item, and bring it to your mouth, take a bite, and begin chewing. Since the process is the same regardless of the size of the meal, it is logical to deduce that the size of meal should not be a factor in the decision of one starting the process.

Now I understand that the size of the meal can be intimidating if you are expected to consume all that is set before you. However, since we are not using the analogy to discuss the eating of food, the goals we are trying to achieve or problems we are attempting to overcome typically do not require a solution be reached in one sitting. We may in fact want to have the goal met or issue dealt with quickly, but this does not mean that it has to be. More than often, that is simply our impatience forming our expectations and not a well informed understanding of the situation we are desiring to change.

Finally, both you and I will end up taking several bites as we sit at several meals throughout our lifetime. We might as well be taking bites out of those goals and issues that are before us. We all exist in time. We will use this time for something. This moment-by-moment time is the same for everyone regardless of how we use it. Therefore, start biting!!

...you who judge practice the same things.

I have been thinking about a particular passage of scripture lately. I have been thinking about it because the longer I live, the more I realize that the little things I note about others that annoy me are the same things that I do, maybe less or in a different form, but still I do them.

The passage that I am thinking of is Romans 2:1. The New American Standard translation states:
Therefore you have no excuse, everyone of you who passes judgment, for in that which you judge another, you condemn yourself; for you who judge practice the same things.

The Message paraphrase states the passage as:
Those people are on a dark spiral downward. But if you think that leaves you on the high ground where you can point your finger at others, think again. Every time you criticize someone, you condemn yourself. It takes one to know one. Judgmental criticism of others is a well-known way of escaping detection in your own crimes and misdemeanors.

Yes, at work, I hear the annoying laugh of the girl in the adjacent department and then realize just how silly my laugh can be at times. Or, I notice the peculiarities of others around me. Then I see that these are the same tendencies that I exhibit.

In fact, for quite some time I have thought that this passage was only speaking of the preceding section of Romans, chapter 1, that details how that even though mankind has a general revelation of God in nature, we have and do suppress that truth and spiral into all sorts of wickedness. Oh my!! You mean that as we see this taking place in our time, we are in fact doing the same things. Yes. Perhaps in less obvious forms, but still the same, we are actively at fault, just as those outside the family of Christ. Not just in the large things. But as time has shown me, the small, insignificant things also. Indeed, in my view, the Word of God is true.

Yet, what is different about us who name the name of Jesus? Do we deserve any less punishment than they? More on this later....

Great GoF Patterns site with C# examples

Here is a great site that defines, models, and provides demo code in C# of the Gang of Four (GoF) software design patterns.

First Post

Well, here is my first post. Stay tuned for "musings" on topics like software development, primarily on Microsoft's .Net platform, as that is what I do to pay the bills and what I love to do. I admit, I am blessed in that I like my job!

Also, and more importantly, stay tuned for thoughts on a Biblical Worldview.