Blurring out areas in an image

This isn't really a post I'd normally write, but since I get this question all the time from colleges, I thought I'd mention it.

I often blur stuff out in images on my blog or in just quick print screens I create at work sometimes for whatever reasons.

But first I will say I do not use free paint programs like Paint.NET or GIMP.  They just don't cut it for me for the following reasons:

• while you may not care about quality in simple print screens for documentation or blog posts, well I do.  When I create images for my blog or even for pasting stuff in OneNote for work for remembering how I did stuff, clarity, sharpness, and just overall look matters to me.  Don't asky me why, it's just en-grained in me
• The tools are sub par.  Sure they attempt to do the same things Adobe does, but again, you end up having to either take a lot of steps to do the same thing or you can do the same thing as in Adobe or the results areis just not that good when you apply effects or filtering I've noticed as compared to Adobe products.  Sure sounds stupid but this stuff matters to me

I can't afford Adobe Photoshop.  So the next best thing is Adobe Elements and I highly recommend it for developers at least.  IMO it's basically a very dumbed-down version of Photoshop probably and it's good enough for me.  It's got high quality and advanced tools, just enough for a developer but not over the top which this wouldn't hack it for a designer.  So it's perfect.  Elements is only $50 people, it's not like it's gonna break the bank.  Get it, it'll save you time (efficiencies) and provide you much better and more powerful control over the fine grained stuff as compared to Paint.NET, etc.  In fact Costco carries it for even cheaper sometimes.  Check there.

Anyway back to how I create that blur effect.  It's simply the Gaussian Blur.  

Pay attention to the options.  You can tweak the transparency (how strong the blur effect is) by moving the transparency bar left or right to get it just how you like it:

Note that in PhotoShop Elements, after you apply the filter once, then you get a nice keyboard shortcut that's activated that you can use from that point on to quickly apply the blur again

So I do this a lot with code to protect sensitive info:

Cheers.

Using ReSharper to remove Code Smells and Keep Code Cleaner

I promote ReSharper always as a necessary tool that I feel all developers should definitely be using.  In fact there are teams I've been on that require it as they've decided that the tool is so useful that everyone should be on board and using it because it helps so much that it became a requirement to use it literally.  And on those teams developers didn't debate using it, they were already using it or if they weren't they were all for it because they saw how it can literally help the team to be more efficient in so many ways.

One of the big reasons to try and make it a standard on your team is about is keeping code clean.  Some people don't think they have any use for a tool like ReSharper.  They're "proud of manually coding everything without much assistance from intellisense".  Well that's just ignorant.  And most likely those kind of developers are producing code smells for the rest of the team and they don't even know it or causing themself extra pains that they weren't even aware were walls/pains in the first place on a day-to-day basis!

And remember your code is everyone's code.  The code base belongs to the entire team, not just you.  So if you think it's ridiculous to keep even the smallest lines of code clean and it's below you, you might consider another profession.  Do you think accountants allow messes?  Doctors?  The answer is no and it should be no different in our profession as Software Engineers or "Craftsmen".  What you do affects everyone in your development team so you need to view the code YOU write as such at all times and be thinking about how it might be reusable, cleaner, etc. for everyone else who has to work with it in the future.

Turning back to ReSharper.  It's such a gem in that it clearly points out unnecessarily code in every class and every line of code in that class.

There's no reason if you have ReSharper installed that you aren't by habit removing unnecessary code as you come across it, which is part of the boyscout rule, keeping the code campground clean.  As you know the boyscout rule that so many great teams abide by is that every time you check in code, it should be a little better than what it was before you check it in.  Robert Martin's Clean Code book emphasizes the boyscount rule.

When you are in a class and you have ReSharper installed, this stuff just screams out at you.  And for me it's just a habit to remove it.  It feels gross to have it in here...and you should feel the same way.  It takes up no more time doing this;  It does not slow me down as it's just a few seconds to remove this stuff as you go and as you see it elsewhere in an entire class.

Look at these examples where ReSharper has pointed out/grey out unnecessary code (I pointed it out with yellow here):

unused usings

unecessary "this." where there is no object type conflicts whatsoever

unecessary Fully Qualified Types where you should have added a using statement

unnecessary explicit conversions:

unnecessary chatter:

unnecessary default assignments at times

Would the examples above give you "code itch" if you knew about them?  It's very much code smell, and it really should make you itch if you truly care about keeping your code base clean.

Why should we removed this stuff? for READABILITY, simple as that.  And having more readable code leads to easier maintenance for all.  Don't be lazy, get rid of it NOW while you are working in that class before you check it in.  ReSharper makes it stupid easy and quick do do this, and It's part of being a professional Software Engineer to keep this clean.

One of the things I do just by good habit right off the bat is when I make a new class in C#, I immediately remove the default usings that are generated at the top as initially they are unused anyway.  half the time you won't end up need a lot of them once you are done with the class anyway.  ReSharper will simply hint and allow you to add using statements quickly and easily anyway when it detects you need them.  So start off with a nice clean template is what I highly suggest so that this stuff is removed initially to start with.

Now you may be thinking "hey I like to show things explicitly to make code more readable". You know what?  you're actually making it less readable.  For instance if you think you still need to do something like establishing a variable with default such as int someVariable = 0; and you know though in certain cases you don't need to explicitly show that you're setting it to zero.  Seriously, stop over thinking and just get rid of it.  It's like the same with commented out code, get rid of it, it's clutter.  99% of the time you'll never use that commented code again.

ReSharper's Marker Bar

Now another thing that people who have even used ReSharper for a while don't know about or notice which for me is an awesome feature is  the Marker Bar.

When you open a class, look to the right.  ReSharper outlines problems, hints, or suggestions in code making it very easy to see an overview of your class in terms of code quality and errors that exist:

And all you have to do to get to that line of code that is a problem is to click on that colored bar on the right.  

ReSharper shows different colored bars to the right to point out different things:

Don't you love that?  In fact there was a team I worked with who decided that a good standard for the team as part of cleaning up code would be to check this in every class you've made changes to BEFORE you check in the code.  

So get rid of unnecessary code or use the hints to make the code more compact, do it, then check it in.  You start to view your classes different with this feature too.  Because when you open classes, you start to look to the right automatically and it just becomes a habit to use this feature to see if you can clean something up before saving your code and checking it in.

This just touches the surface in how ReSharper can help a team keep code consistently clean and uniform.  There are many more features that I'd like to resurface later in a future blog post.

While most ReSharper users already know about this, there are plenty of developers who have never heard of a tool like ReSharper, refuse to use it, or don't understand some of its benefits.  So I like to resurface some of this stuff once-in-a-while hoping a newbie finds out about ReSharper and some great stuff they and their team are missing out on.

A Journey to TDD - Part 3 - Creating a TDD test with ReSharper

To learn TDD takes time.  It takes time to learn how to do it, but also to do it in the way that is efficient as possible.  So that shouldn't stop you from doing TDD.  That includes using and learning tools like ReSharper and keyboard shortcuts to make generation of production code fast.  VERY fast.

Again when I talk "production code" in the context of TDD, that is code you create AFTER you code the lines in your Unit Test of things that don't exist yet.  "Things that don't exist" could be anything from the core class you need, new methods in that core class, or properties that you want to populate as part of your TDD Unit Test.

So I wanted to find the fastest way to generate the classes, methods, whatever from my Unit Test...that is generate the stubs that do not yet exist as fast as possible.

After researching a bit, I found that there are 2 ReSharper keyboard shortcuts that you'll need and that's literally it!  Those are the following:

• Alt + Enter
• F6

At first I found the Efficient Navigation when doing TDD/BDD with ReSharper video from JetBrains but it's very old.  It talks about TDD with R# but that's ReSharper 5!  Apparently they have not updated their videos in 10 years or so.  While most of this is still valid, I found a better option, F6 for the moving of the cla

Anyway, I found it, was just what I was looking for.

Later, after applying Alt + Enter and Ctrl + Shift + R (refactor menu), I found yet a quicker way which was just F6 for the refactor menu.

So lets take a look at how you would apply this in Test Driven Development because that will also show and explain how ReSharper will help you in this process once you get the keyboard shortcuts down by habit just from routine practice.

Using the Red, then make Green, then Refactoring principals of TDD, here's what that looks like and how I used the shortcuts to perform a typical creation of a unit test against a use case and necessary classes related to one particular unit test:

1) Always Start with a Use Case (Story) to drive what tests you need

Eventually this will just come naturally through time as habit, but intil then, be sure to keep reminding yourself and try not to forget that TDD tests themselves are a form of living documentation.  When a team looks at TDD tests they should feel confident that those who created those tests did it with Use Cases driving them...and that they are not some abritrary guesses.  

So you should feel good that with TDD you have guidance.  You don't just blindly start off guessing what you may need for "possible" requirements in the future like many devs have done without TDD and who create much more code than is needed in a lot of cases (wasted time).  Instead, you don't need to guess where to start.  TDD tests are and should be driven by Use Cases (Stories)

Your test classes should therefore act as documentation itself.  Meaning anyone should be able to go into a test class and it can be viewed as a footprint for business requirements.  Tests in your class were written for business requirements so the intent and reasons why those tests are there should read like documentation.  Meaning your test names should be clear on what they are testing.  And each unit test has a direct relation to one or more Use Cases that drove the creation of these tests.  So these tests are the business requirements literally from use cases.

Also all your tests serve as a form of documentation to other devs.  If you want to know how to call something, look at the tests!  They show you exactly how one could call a certain method in many ways as if you're coding via TDD you'll have a lot of tests per method usually.

And as a result, you are driving your team to create LEAN code.  Since Unit Tests are driven by Stories and you are to make sure unit tests are as small as possible each, some seemingly ridiculous to newbies, they are not too small.  Because by creating small tests, you are thinking about the parts you need to satisfy those business requirements.  And a unit test by definition means you test ONE very small thing.  That could literally be testing to make sure a method does not return a null instance or doesn't return an empty string.  All these kinds of little tests are things that could go wrong while you code methods and classes for the use case.

And remember you aren't going to know what tests you need instantly even if you have a use case right in front of you.  One of the good things about TDD is that it forces you to think about what you need for a use case.  So you're only creating the code you need, at its leanest.  Just enough code to pass the tests that make sense to support the business use case.


So lets start with a hypothetical Use Case:

    Figure 1 - a user story in Jira

So this user story has a couple tasks (we'll only talk about the first two):

• create an initial Web Service class stub
• create some method stubs we think we'll need to support facilitating calls to various payment processors
• Create some utility methods for parsing proprietary XML, sending API requests, creating request tokens, etc.
• ....

So this is a business requirement.   Tests we create should make sure our code is satisfying that business requirement.

The first two tasks are dependent on each other so our tests will naturally involve the two anyway (you need a service and you need methods after that)

1. We'll create a new PaymentServiceTests.cs class to hold our unit tests for this service
2. We'll start thinking about what this service should do/provide, if it needs a constructor and some initially wiring up on a constructor for any reason, and how it might start out. This is the part of TDD that forces you to think about what you need now and at its leanest.  This is the best way to discover what you need based on the Use Case
3. As we go, we'll naturally start thinking about and as a result discover how we'll implement the production code in these methods and class to make our tests go green

Now Lets start on the Tests to Support these requirements

First lets create the service Interface.  Note we could also be creating a class but we'll do it by an interface for now since that's normally where I start when I create a web service because I start thinking about what methods we'll need for the service and there are several reasons I'm using an interface here that I won't go into in this post

To go about this, lets start creating tests in our PaymentServiceTests.cs class:

Usually most TDD tests start out with checking the absolute very basics.  We're talking about stuff like making sure you even have an instance of the service object itself.  When you do TDD again nothing is too small to test.  It may seem absurd to test something like a valid object but you'd be surprised that these things can fail at any time in the future if people start changing the implementation of the class, initialize it wrong, or whatever...

So the first test simply checks that we have a valid instance (object) of the service we want to use, in this case our PaymentService.

    Figure 2 - our first TDD based unit test for our new PaymentService and using 
    Roy Osherove's convention of method naming as well as comment guiding parts of the test     code inside (Arrange, Act, Assert)

Because I want to base my service off an interface, we know we'll need an Interface AND a service class that implements that interface.  We also know we'll need methods in both places right?  A method stub in the interface and method implementation in the Service class. 

(Some may argue we don't need an interface here but I can argue some reasons that we benefit from having one here.  I'm not going to debate that now, so just follow along...the point is to get a test of how to start TDD which again I'm learning as well but figuring out more and more every day at work.  We do not have a certified TDD guru on board so we're all in the same boat, learning and trying to do TDD right.)

The Service Interface will house those methods that we want to expose publicly to the client/consumer of this Web Service.  In TDD you want to only unit test public members for several reasons that I will not get into in this particular blog post.

The Service Interface is also where we will house and define the WCF or other specific attributes that the methods will rely on.  We are adding attributes in this case because we are creating a RESTful WCF service.

So if you look at the test above, I thought to myself ok, at the very least, we need a valid service instance before all else.  This is typical in the TDD world.

One interesting thing to note.  For now, I like the approach of creating the assertion first.  By doing so it makes me think about what the test expects as an outcome to support the use case  

Then after creating the assert, going backwards to create the non-existing class or methods and code as if they are available but we know they are not that the assert is using.  This is called Failing First (going Red first).  Meaning you code as if those interfaces and classes already exist but we know they don't.  That's ok and what you want to be doing, it will feel awkward at first but you will see the beauty of this later as you get more practice with TDD and start seeing the light as to why this is the first thing you do if you are coding via TDD principals.  

Again, don't be tempted to go create theses files (class and interface).  When you do TDD, You want to generate the actual class and interface files from your test.  And this is where ReSharper will really automate that and help you do it quickly.

So first I create the assert:

    Figure 3 - initial assert to support this Unit Test.  This unit test will be one of many to                               come as we create more tests support our Use Case
    
   This asserts says I expect that I always have service object instance to work with at the very     least.  We need that do do anything period if anyone wants to start using our service.

Next, lets start creating production code (implementing the actual method, class, interface, etc)  to support the assert:

    We needed to create the variable called  serviceInstance.  To do so, that means we'll 
    need both a ServiceInterface and related Service class that implements that interface.  
    Again the interface just abstracts out WCF specific stuff and also defines the public 
    contract which is very common when creating WCF services.  We could define a public 
    contract for WCF with just a plain class, but I have my reasons for 
    doing it this way, there are many benefits in this particular case.

    So I just started right in creating the variable as if everything exists.

    And what you end up with is red invalid service and interface references.


Next step is to create the production code.  Meaning we need to start making this test green.  Putting another way, we need to make this test REAL.

Now here's where ReSharper is very handy.  There are a couple things we want to do to accomplish creating our interface and test class here:

• We need an IPaymentService.cs interface and a PaymentService.svc.cs class
• We need to be able to create new files for these
• We need to be able to decide where we want to create those files as we don't want them located in our Test itself
• We want to be able to reference the namespeces for those new classes in our test project so it knows about them (in other words we'll need using statements for these at the top to recognize they exist)

Now the nice thing about ReSharper is it helps us do this very easily and quickly which othewise would take minutes.  

Here's what ReSharper can do for us in response to the steps we'll need to take in the list above:

• We'll need only 2 ReSharper based keyboard shortcuts already built into ReSharper to assist us
• ReSharper will automatically inject the using statment in our Test class after all is said and done (you don't even need to think about it, nice right?)
• Optional benefit:  I like using the ReSharper test runner, which to me is more powerful and easy to use rather than MSTest runner or NUnit's crappy test runner

Now here's how we'll finish the rest efficiently with ReSharper:

First lets create the Interface class stub and file:

Place your cursor at the beginning or end of IPaymentService and press Alt + Enter.  Nice right?!!!  you immediatley get an option instantly to create a new interface:

This will create the interface stub in your test class:

    That was Jimmy Johns-like freaky fast right?  Huge time savings right there, no excuse to 
    say TDD is slow (well after you practice and get this down pat that is)

Ok and now lets create the PaymentService class stub, same deal, Alt+Enter:

Nice right?!?!  but wait, look again.  ReSharper also helped us out by the fact that it knew the context.  It knew not only to create that class but to automatically implement
IPaymentService based the context of the line of code where you told it to generate that 
class from.  Awesome right?  You should be saying damn straight...because this is the kind 
of stuff Visual Studio doesn't do for you...stuff like this that saves you so much time.  This 
goes beyond basic generation, this is smart generation at the same time saving you a few 
more steps.  ReSharper is smart people.

Finally you say to yourself, well that's stupid, we don't want this here, these should reside in our WCF Service project.  How can I move these and also create a new file at the same time?

Again ReSharper to the rescue.  All you need is F6 on your keyboard.

All you need to do is place your cursor at the beginning or end of what you want to move, this being the PaymentService class and choose "Move to Folder":

   Then this brings up a quick dialog to allow you to finish that move and also specify what 
   project and where in that project you want to move this and also create a file for this:

    Ok great.  However it defaulted to the location being our current test class.  Lets change         that.  Backspace a little and ReSharper automatically adjusts the list to show you more and     more up the tree of projects and folders in your solution:

    Ok cool, but I want to go all the way back to the root of my solution and choose a different 
    project.  So instead replace it and type in the name of your project and you'll get a broader     list up the stack to choose from.  Then just arrow down to which one you want:

   Once you select the right project, then add a slash "\"  at the end and it'll start showing 
   you the folders within that project to choose from:

    OPTIONAL: Also notice you could use this icon at the top right for another way to visualize     the solution stack as well:

    
Anyway, I've told it where to generate the class and now it just did.  It created the .cs files and placed them where I told it.  

I repeated the same set of steps we just did to move the Interface as well.

Now our Test class is clean again and just contain tests:

And look!  And since I use the ReSharper Test runner, it automatically detected what Unit Test Framework is on, so it added a nice little icon to the right that we can click on to run the test:

And results shown in the ReSharper Test Runner shows our test now runs green!  We've just created just enough production code to make this particular test past.  So we've just created what we need and only what we needed for that test.  We're creating LEAN code and that's just one of the benefits of doing TDD and following its principals in order.

Actually I had to change it up in the end to make it go green, just an example of how TDD makes you think about stuff and make it work

Tools used in this example:

• VS 2012
• ReSharper 8.0.2
• My Brain and thinking based on the Use Case

Till next time, work hard and learn TDD ok?  Stop Making Excuses. It's worth the work now, you'll benefit beyond your wildest dreams later once you get this stuff down and it becomes habit / no brainer later on.

A Journey to TDD - Part 2 - Getting Proficient As Possible as Fast as Possible

On our quest to be a TDD driven team, one of my colleagues had a great suggestion.  That is to watch a video together once a week while we also try to code TDD.  I totally agreed as I was thinking the same in that we should all be watching about basics first to get a foundation in addition to just "diving in" and some of our guys have not had the time to watch videos what I really feel is important for us to watch.  The rest of the team thought that was a great idea as well.

Our boss also started us doing some Mob Programming.  It's pretty neat.  Our team doesn't don't do it all day every day to the extreme whereas some places do as it's not our methodology.  We are a SCRUM based agile development shop, but we are stealing that idea and applying it for an hour taking 2-3 times a week, bringing in the entire team or immediate devs on your project come together in a conference room and work on real production code together via these Mob sessions.  

In our mob sessions, one person drives.  We rotate the driver every session so everyone is forced to be a driver.  Then we all start to code real code together.  Think about is as like one huge XP session where production code is getting done and everyone is learning at the same time.  If you can't make a session it's alright, it's a come as you want basis but usually we have several devs show up to at least a couple sessions a week so we end up being productive in it.

As a teammate, I'm also trying to contribute by helping myself and everyone up to speed and doing TDD as much and as fast as possible.  To do this though, we know that it will take time to get it right as we are all new to this.  We also need to keep in mind that this is not just a technique, this is a total change in mindset and attitude when you do TDD and that there are principals that when followed, work.

Anyone starting a team out doing TDD might question some things about it or how you do it.  But we know there will be a period of learning why and how and that yes, there will a cost in that there will be slower development going on but that there will be a threshold met when we get used to it and able to fly with it and it will be a no brainer.  This is when the business starts to see fast and quality end results out of their development team to a degree that they have never seen before.  But this won't happen unless you follow the 3 principals in order and refactor your tests to be DRY as stated in the diagram during that process.

Principals of TDD have been proven and successful for a long time now.  This is not some theory or "achedemic" set of rules being forced on you or a "we are doing it because everyone says we have to do it this way" as some people might view it.  These are not principals you say "oh we don't have to do it quite that way, we can write tests after and come back and write the test".  These are principals that depend on each other and depend on you doing it in the right order.  If you don't adhere to failing test first, etc. then that's not TDD and that will not provide you the benefits you are seeking.  If you are not writing failing tests first, then please do not call it TDD.  This is not a discipline you just take for granted or twist and turn into your own way of doing it.  There are 3 principals.  If you force yourself to figure it out, understand it, practice it and follow it as does all other TDD shops who have been successful at it, you will reap its benefits.  If you do not, you will eventually end up with a mess plain and simple and sadly will never know TDD as it was meant to be applied and never reap its benefits.  Having unit tests is great.  Driving new code with TDD is awesome.  Just stick to the principals when you do it is all I'm saying.

As a side note, I've been on so many teams in the past who get lazy and write tests AFTER for any new code, and it just ends up in a huge ;pile of shiza, and lot of inconsistent useless Unit Tests that test more than one thing, test things that do not relate to the use case, as well as high confusion over WHAT should be tested after the fact.  Or I've been on teams that do not see the value in unit tests at all and will do anything to deter you from spending time doing them.  

And let me say sure, obviously you can't apply TDD to all of your code as you will have legacy code as well.  But if you are test driven, eventually all new code will be created with this technique and mindset and, you will no longer have to be wasting your time wondering if you are writing the right tests or if your tests are too big, etc.  Because when you can do TDD when writing tests, as you code, you are forced to THINK about what you are coding and how you are meeting the business requirements and again, failing tests first coding classes and methods that do not exist yet force you to think about what you really do need (simplicity) for that business requirement.

That hardest part is to change people's mentality but more importantly devs don't get that your tests should be so freakin small you think it's ridiculous.  But that's the point.  A lot of devs typically in early stages will say do we really need that many tests and to spend time writing so many?  Do we really need to test something that small?  the answer should always be without question YES if you are buying into the technique and mindset of TDD.  Otherwise you loose its benefits.  You should have many tests...small as hell, testing one thing, and even if you think it's too simple to test, that's not the mentality you should have in TDD.  You will have several tests for "a" method in a class.  There is no "too simple to test" idea or concern here.  A "unit" is testing ONE thing.  And that ONE thing should be very very very very small.  You have to get that mentality in your head and accept it. For me it makes total sense and I don't have that conflicting urge not to do that.  Personally I want a lot of small tests, ti just makes sense and I know it's gonna help find bugs very quickly and that you can trust your tests because they are so small there is no doubt about what to call your test, or that you are introducing bugs into your tests.  You will write tests and over time get good at it and the automation of all this will save hundreds of thousands of hours each year for the dev team and the business in the long run.

So going back to our video sessions. The first video I suggested which we watched this week was Unit Testing Best Practices with Roy Osherove.  

And the reason I suggested this one as opposed to jumping right into TDD videos was because 
it's just as important for you as a developer to know traits of what makes good unit tests (TDD or not).  

This video by Roy is not about TDD although he does relate to some TDD in it.  
But it's more about how to write good tests.  I felt that it would be a good suggestion that we take 
that step backwards and then into TDD videos after and I think the team liked it and it was a beneficial video 
to start with as far as I could tell.

I also suggested the next video to be the following from Uncle Bob to be Clean Code → Episode 6, TDD - Part 1, as I bought it tonight and thought it was very good.  He explains the benefits of TDD better than any video I have watched yet and also drives home how important it is to STICK to the 3 principals of TDD and why you should not deviate or mess with the formula.   It addresses a lot of concerns people who are not experienced with TDD have, common responses you get (oh it'll take too much time to code all these tests, yada yada) that try to push TDD out and keep it from penetrating your development team as a way to develop code. 

We're having fun as a team, but more importantly learning together and a unified goal to create better code, have test driven code that will save us a ton of time later on and our boss is totally on board and motivating that drive.   That's one of the problems in our trade...finding a good team and a good manager.  That doesn't always just come easy as a lot of my friends have experienced the same.  So point is you have to have a manager who is invested and passionate on improving the business and the team.  

I think this is the kind of team every developer should want to work with.  Who wouldn't right?  If you are not working for this kind of team then maybe you want to seek one out.  It may take a long time to find and a dime a dozen but they are out there from what I've learned.  It's fun, we get stuff done, we know things will improve over time with TDD and cleaner code, and we know as this progresses, if we stick to our guns, we'll get to go home to see our kids and wife without worrying about shit at work like fires, meeting deadlines..stuff like that which makes your life hell on some dev teams I've been on in the past.

So taking an hour out as a team to watch videos from some great people (Uncle Bob, Roy Osherove, etc.) it's great parallel step as a team toward TDD development as we also do Mob programming together.  

Also we've decided to try to attend a Dev events outside of work together as a team (or at times we may even take a half day of work to go to these).  The first session we attended was one by Uncle Bob that you can find and watch here:

While we are not 100% an XP based agile shop (again we're primarily SCRUM) we still also do pair programming as well quite often in fact.  We will go to each other's desks and code together (one codes, one observes) and the productivity level increase is just astonishing and is the only way to go on any development team as far as I'm concerned.



So as we start to do more TDD together, I will post Part 3 of this series which shouldn't be too much longer...we're gaining ground more and more on this adventure.

Different Ways to Run WCF Services Locally

Today, I just wanted to post the different ways you can run a WCF service.  There are times you want to run them certain ways so here are a few to think about:

First Option:   Run it in full blown IIS

Honestly I think even though this is more work for each developer when they initially want to just run a service project the first time, rather than use IIS Express, IMO it may be worth the pain to have to set it up in full IIS locally yourself ..because IMO it's just good for devs at all levels to know IIS inside and out and many devs still do not which I think to myself why would you not want to.  

So even though now I use IISExpress, in the past I liked setting everything up in full blown IIS personally...and that's forced me to really get to know IIS and know it well through the years by doing this.  I never used Cassinni either for this reason and also it was a black box and I do not prefer black boxes.  In IIS you can solve any issue with hosting whatever, you have full control.

So doing it a more manual route to me forces you to learn IIS, because that's how you're going to deploy it anyway to other servers.  Why use something like IIS Express if that's not how you will be hosting it in a real environment, I just don't see some shortcuts as being a benefit in the case where devs are totally reliant on not knowing much of IIS at all.  For instance ASP.NET web controls and Web Forms; sure they let programmers program easily (piratically pushed us to be "dumb" programmers), but we found out years later that MVC was better and forced people to LEARN code.  I feel the same about IIS and running stuff locally.  But that's just me :).

Second Option: Run it in IIS Express

v    So to do this, in your WCF Service project, right-click your service ([MyServiceName].svc) for and choose to open it in the browser from the context menu:

This launches the service automatically in IISExpress as you will notice if you go down to the running task icons next to your clock in windows:

This also then continues to open up the service endpoint in the browser to the default service page:

Third Option:   Run the WCF project straight up using F5

This is a “WCF Service Application”.  That means by default it’s set to run in a browser and by definition of this template, has a web.config associated with it. 

So if you just want to run the service quick, by itself in memory in the background, and don’t want it to open a browser (which does NOT run the service it appears), then go to the properties of your WCF service project and tell it not to: 

By doing so, then when you set this as the default startup project, it will indeed start the service so that you can go back and my unit test above will run GREEN.

Fourth Option:   Run the WCF project straight up using F5 -  but set Project Startup Priority for the entire .NET solution

This might be better for you as you can tell it hey, I want to run my service service in memory (not through IIS) AND also run other projects like another web project, etc. in your .sln (solutoin)

To do that, just make sure that the service project is started first...as other things might rely on it such as your web project, etc.

Do this by going to the .sln properties in VS and set your startup projects and order:

Then try pressing F5, you will notice that now, the web service will run, AND for example an ASP.NET MVC project will also launch, so you have both running now.