My First Photo shop work!!!

                I always had thirst to work on photoshop to edit our own photos and make the photos much brighter, sharper and colorful as if the photo was taken in DSLR camera which had 24-70 f2.8 lens (Even though I just own a Nikon Coolpix Point and shoot Digital Camera now :P )

So after years and years of thinking finally I thought to download Photoshop elements 10 software (which is the latest version on the net) from Photoshop website and end up with a torrent which I got the full dump :) horray!!!

I installed Photoshop elements 10 on to my new HP laptop last week and was doing small tasks like cropping, red eye fix, apply healing brush etc.. and today I finally got a task to do. when I was applying a credit card through online I came across a option to choose your card design. Can you believe it? In US you can simply select your own card design by uploading a wallpaper into the credit card portal and they will simply apply the whole image as a background of your credit card with no additional cost. Wow that is so nice of them..

Anyway coming back to our task, I thought instead of uploading a existing wallpaper (they already had lots of wall paper in their website to choose one or you can upload your own wall paper from your computer) why can't I just create my own wall paper with a colorful background and my picture as the foreground. Yes you got it. (This is how legends are born!!! :P I'm not saying im a legend) I took a colorful wallpaper,

 and one small puppy photo

and a recent photo of Me to start the work.

After seeing few photoshop tutorials to how to cut a photo using photoshop tools and paste and make it real, I got the final output

I went on to put lot of effort to make me to fit into that greeny wallpaper as my photo was whiteish ( that photo was took in a cloudy snow day).  Even though the modified photo didnt had that professional touch and work it was ok for me to upload into credit card website for my First Creditcard in US. Here is how my creditcard is going to be after it is dispatched.

  

Google Translater for Indic Web ( Tamil, Telugu, Kannada, Gujarati, Bengali)

Google now translates in our mother tongue too.. Sounds familiar but there is a new stuff added to the translater complier. yes, the translater actually tries to get the meaning of a word instead of simply converting a word from one language to other...

For example, If you want to convey "thanks" to a tamilian and you know only english. Now its not a problem. Just use google translater and now it translates and finds the exact tamil word for "thanks" from its tamil dictionary. Sounds interesting right? I tried few words to translate and it works.. but still google still holds this in "alpha" version as it couldn't convert a whole sentense from english to Indic languages. The reason is Indian languages often use Subject Object Verb (SOV) order unlike English, which uses Subject Verb Object (SVO) order. see the picture below

More details about Google translator check Indic Web and the URL for you to test the same.

WCF Architecture

The following figure illustrates the major components of WCF.

Figure 1: WCF Architecture

Contracts

Contracts layer are next to that of Application layer. Developer will directly use this contract to develop the service. We are also going to do the same now. Let us see briefly what these contracts will do for us and we will also know that WCF is working on message system.

Service contracts

- Describe about the operation that service can provide. Example, Service provided to know the temperature of the city based on the zip code, this service we call as Service contract. It will be created using Service and Operational Contract attribute.

Data contract

- It describes the custom data type which is exposed to the client. This defines the data types, are passed to and from service. Data types like int, string are identified by the client because it is already mention in XML schema definition language document, but custom created class or datatype cannot be identified by the client e.g. Employee data type. By using DataContract we can make client aware that we are using Employee data type for returning or passing parameter to the method.

Message Contract

- Default SOAP message format is provided by the WCF runtime for communication between Client and service. If it is not meeting your requirements then we can create our own message format. This can be achieved by using Message Contract attribute.

Policies and Binding

- Specify conditions required to communicate with a service e.g security requirement to communicate with service, protocol and encoding used for binding.

Service Runtime

- It contains the behaviors that occur during runtime of service.

• Throttling Behavior- Controls how many messages are processed.
• Error Behavior - Specifies what occurs, when internal error occurs on the service.
• Metadata Behavior - Tells how and whether metadata is available to outside world.
• Instance Behavior - Specifies how many instance of the service has to be created while running.
• Transaction Behavior - Enables the rollback of transacted operations if a failure occurs.
• Dispatch Behavior - Controls how a message is processed by the WCF Infrastructure.

Messaging

- Messaging layer is composed of channels. A channel is a component that processes a message in some way, for example, by authenticating a message. A set of channels is also known as a channel stack. Channels are the core abstraction for sending message to and receiving message from an Endpoint. Broadly we can categories channels as

• Transport Channels

  Handles sending and receiving message from network. Protocols like HTTP, TCP, name pipes and MSMQ.

• Protocol Channels

  Implements SOAP based protocol by processing and possibly modifying message. E.g. WS-Security and WS-Reliability.

Activation and Hosting

- Services can be hosted or executed, so that it will be available to everyone accessing from the client. WCF service can be hosted by following mechanism

• IIS

  Internet information Service provides number of advantages if a Service uses Http as protocol. It does not require Host code to activate the service, it automatically activates service code.

• Windows Activation Service

  (WAS) is the new process activation mechanism that ships with IIS 7.0. In addition to HTTP based communication, WCF can also use WAS to provide message-based activation over other protocols, such as TCP and named pipes.

• Self-Hosting

  WCF service can be self hosted as console application, Win Forms or WPF application with graphical UI.

• Windows Service

  WCF can also be hosted as a Windows Service, so that it is under control of the Service Control Manager (SCM).

Processing Data Queues in SQL Server with READPAST and UPDLOCK

Problem
One common processing problem that a DBA can encounter is processing rows from a table used as a data queue. Queue processing is functionality where one or more processes INSERTs rows into a database table representing a work queue with each row representing a business action that must be performed. At the same time, one or more processes SELECTs records from the same queue table in order to execute the business action required by the application while later deleting the processed row so it is not processed again. Typically, the reading processes use polling to interrogate the queuing table for any new rows that require execution of a business action. If done incorrectly, processing data queues can produce unexpected results and/or performance issues.

Solution
The following examples set up a process queue to be processed by two separate processes reading the same queue. This can be extended beyond two processes, but for this example we want to show you how two processes can work against one work queue. We’ll start with examples to illustrate issues that can be encountered.

First, let’s create a sample table and populate it with 10 records to be processed.

-- create an example queue table CREATE TABLE DBO.QUEUE ( QUEUEID INT IDENTITY( 1 , 1 ) NOT NULL PRIMARY KEY, SOMEACTION VARCHAR(100)) GO -- seed the queue table with 10 rows DECLARE @counter INT SELECT @counter = 1 WHILE (@counter <= 10) BEGIN INSERT INTO DBO.QUEUE (SOMEACTION) SELECT 'some action ' + CAST(@counter AS VARCHAR) SELECT @counter = @counter + 1 END

Encountering unexpected results
Open 2 separate query windows and issue the following statements in each session:

DECLARE @queueid INT BEGIN TRAN TRAN1 SELECT TOP 1 @queueid = QUEUEID FROM DBO.QUEUE PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR) -- account for delay in processing time WAITFOR DELAY '00:00:10' DELETE FROM DBO.QUEUE WHERE QUEUEID = @queueid COMMIT

As you will see, each session processed the same row! This is obviously unacceptable processing behavior, but what can we do about it?

We can eliminate this behavior by adding the UPDLOCK hint to the SELECT statement. The UPDLOCK hint tells the SQL Server query engine “Don’t allow any other reader of this row to acquire an UPDLOCK (“U” lock) because I will be promoting this lock to an exclusive “X” lock later in my processing”. It effectively reserves the row for your processing. However, as you will see, this can cause a new problem to arise.

Encountering blocking
The SELECT statement has been modified to use the UPDLOCK hint.

Open 2 separate query windows and issue the following statements again.

DECLARE @queueid INT BEGIN TRAN TRAN1 SELECT TOP 1 @queueid = QUEUEID FROM DBO.QUEUE WITH (updlock) PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR) -- account for delay in processing time WAITFOR DELAY '00:00:10' DELETE FROM DBO.QUEUE WHERE QUEUEID = @queueid COMMIT

As you can see from the modified example, each session now processes separate rows. Good so far. However, the 2nd session took longer to execute than it did in the first example even though it now processes a separate row. Why is this? It’s because an UPDLOCK (“U”) lock has been placed on the row processed by the first session and the 2nd session is forced to wait on this lock to be released before it is allowed to retrieve the next row for processing. This is highly inefficient since multiple consumers of the queue must all wait until any locks are released. So, how do we get around this?

To get around the blocking encountered in the previous example, a READPAST hint can be used in conjunction with the UPDLOCK hint. The READPAST hint tells the SQL Server query engine “If you encounter any rows that are locked, just skip them… I want whatever is not currently being processed by anyone”.

Incorporating the READPAST query hint
The SELECT statement has been modified to use the READPAST hint in addition to the UPDLOCK hint.

Open 2 separate query windows and issue the following statements again.

DECLARE @queueid INT BEGIN TRAN TRAN1 SELECT TOP 1 @queueid = QUEUEID FROM DBO.QUEUE WITH (updlock, readpast) PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR) -- account for delay in processing time WAITFOR DELAY '00:00:10' DELETE FROM DBO.QUEUE WHERE QUEUEID = @queueid COMMIT

As you can see from this latest example, each session now processes separate rows and the 2nd session is no longer blocked as evidenced by the execution time (both sessions should complete at roughly the same time).

Using the UPDLOCK hint in conjunction with the READPAST hint gives the best performance for processing queues while eliminating unexpected results and blocking.

Putting it all together
Here is an example of the above code that takes it a step further and processes all of the records in the queue. To run this drop table dbo.queue and then recreate it by running the code in the very first code block above that creates the table and loads the data.

Open 2 separate query windows and issue the following statements again.

SET NOCOUNT ON DECLARE @queueid INT WHILE (SELECT COUNT(*) FROM DBO.QUEUE WITH (updlock, readpast)) >= 1 BEGIN BEGIN TRAN TRAN1 SELECT TOP 1 @queueid = QUEUEID FROM DBO.QUEUE WITH (updlock, readpast) PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR) -- account for delay in processing time WAITFOR DELAY '00:00:05' DELETE FROM DBO.QUEUE WHERE QUEUEID = @queueid COMMIT END

Next Steps

• When processing data queues, use the UPDLOCK hint along with the READPAST hint to get maximum throughput of your data queues.
• Read more information about UPDLOCK and READPAST in the SQL Server 2000 and 2005 Books Online under Locking Hints.
• Read more about Lock Compatibility in the SQL Server 2000 and 2005 Books Online
• Thank you to Armando Prato for providing this tip!

VS2010 Tutorial: Testing Tutorial (Step 2)

Last time I posted the Step 1 tutorial for creating a WPF application from scratch using Visual Studio 2010. In this post, I’m going to create a test plan and test case for the application using the new Visual Studio Test and Lab Manager project.

For this tutorial, I’m using Visual Studio Team Suite 2010 (which includes all of the roles and TFS access). I’ve already added the demo to TFS so I have full source control. For the sake of demonstration, I’ve commented out the final fix from the walk through so the label does not update:

When I run the application, the label is not updated:

The Tester

To create my test, I’m going to run the Test and Lab Manager tool from the start menu:

The main page has tabs for test plans, tests, and for tracking work items:

First I need to connect to my TFS server by click Add. My server is VLM13267036 (auto generated name by our internal Hyper-V testing tools):

I’ve already got a collection with my code stored in the Projects folder:

Next I’ll select Projects and choose the Connect option. This prompts me to set a context:

I’ll choose “Set context” which brings up the editor for my new context:

I’ll select New:

I can now edit all of the properties:

After all data has been entered, click Save and Close. The new item is now in our list:

Double clicking the item allows me to add a new test case to this test suite:

Here you can fill out all details for the test case:

Steps can now be added by clicking on the “Click here to add a step”:

I’ve added a few steps including launching the application, hitting the buttons, etc:

Now hit Save and Close to go back to the test case list. The Plan is now complete. We can run it any time a new build is produced, for each flavor of build, for different configurations, etc. To execute the test, change focus to the Test tab:

Our test plan and test case are already in the list. Right click the test case and select Run:

This will launch the test case. The manual test runner window docks itself to the left side of my desktop so I can see both the steps I want to run and the full Windows desktop:

The “Start test and record” option allows me to not only do the testing steps, but it will also allow recording a WMV of all the steps I do as well as recording my steps to help me author coded UI tests (big helper with automation). This is really handy if you want someone to see exactly what you did to produce a bug and automate testing in the future.

In this case I will select “Start test”. Notice the Test Runner now shows the steps I created above:

The first step is to “Launch the PicViewer application” which I’ll do by running the application. Since that worked, I’ll press the combo box status item behind the step and select ‘Pass’ from the drop down:

The item is now marked as passing:

I’ll repeat the process for the next two steps, so far so good:

When I get to my last step, I discover the file path isn’t actually set. That makes this item a failure. Select the drop down box and choose ‘Fail’ from the list. I’m automatically asked for comments on the failure:

Since I didn’t record a video of my steps, I would like to give the developer a screen shot of what went wrong. Select the camera tool bar button:

This will bring up a capture tool turning the cursor into a cross hair that allows me to select a region of the screen. I’ll select the top of the application to demonstrate the busted label:

Notice that the failed test now has a .png file added with the image:

I’ve got enough supporting data now so I’ll create a new bug using the toolbar:

I’m now prompted to create my bug with a description, etc:

Notice the detailed test steps I’ve taken have already been added to the bug:

As has my screen shot (the .png file):

I’ll now do a Save and Close which will commit the bug to TFS as a Work Item. Finally I’ll do End Test then Save and Close the test runner. This will return us to Test and Lab Manager.

as a tester, I could now double click the test case and see all of the same data I just saved for the failure:

I can also select My Bugs and see the bug filed for this issue (since I conveniently assigned it to me):

And just to show how everything is wired together, I can open Visual Studio, Team Explorer and look for bugs assigned to me there as well:

At this point my job as a tester is now done.

The Developer

As a developer, I can now open the bug and read through the issue. If I select Other Links I’ll find the .png which I can open to see the issue:

Sure enough, the label is not updated. If a WMV had been recorded, I could have actually watched the testing steps in action. Because the bug is quite simple to find and fix (some idiot commented out the update line!) I can simply make my fix and test it.

Now that things are fixed, I want to check in the bug fix and resolve the work item at the same time. Click on the Pending Changes tab in VS and select the correct work item:

Now we can Check In the fix:

I can now verify the bug has been Resolved:

In Summary

A key goal for Visual Studio Team System 2010 was to reduce the number of times a tester and developer wind up in a ‘no-repro’ situation. There are several things I’ve demonstrated in this tutorial which help:

• Test case steps are documented and set up for repeatable execution
• Pass/Fail steps are outlined and stored in bugs automatically
• Video capture is allowed to see all steps taken, and screen snapshots are easy to acquire and file with a bug
• System information including build number, OS, etc are recorded for you (System Info tab)
• Although not shown, I could also have collected all of the historical debugging traces from the run as well
• All data from test cases, results, work items, and source code are kept in TFS and can be shared by test and dev

I hope you’ll pick up Beta 1 and try this set of tutorials for yourself. Let us know how well it works for you and if you have any suggestions. I should also point out the work item tracking, auto resolve, etc are all part of VS 2008 so a great way to get prepared for the new version is to get TFS deployed today and get your projects into the system.

Enjoy!