Seattle Career Fair Sep-14th 2010

THE SEATTLE CAREER FAIR
Tuesday, Sept. 14, 2010
10:30am to 2:00pm
The Seattle Center
(Northwest Meeting Rooms)

Click here for Seattle Career Fair Details


LOCATION MAP:
Held at the Seattle Center Northwest Rooms (NW corner of Key Arena), corner of 1st ave. N and Republican St.

Good Luck!

What are the contents of Service1.asmx

To know more about the contents of Service1.asmx file follow the blog post...

Where is WebService template in Visual Studio 2010

If you want to know how to create WebService using Visual Studio 2010 click here to follow the post

Understanding Bug Triage– Severity & Priority

Triage, is a medical term. It refers to dividing wounded or sick people into three categories: those who will die no matter what you do, those who will recover even if unaided, and those who will recover only if aided. In a situation where there's too much to do, you must concentrate on the third group.
Bug Triage Meetings (sometimes called Bug Councils) are project meetings in which open bugs are divided into categories. The most important distinction is between bugs that will not be fixed in this release and those that will be

There are three categories for the medical usage, software also three categories - bugs to fix now, bugs to fix later, and bugs we'll never fix

Triaging a bug involves:
Making sure the bug has enough information for the developers and makes sense
Making sure the bug is filed in the correct place
Making sure the bug has sensible "Severity" and "Priority" fields

Let us see what Priority and Severity means

Priority is Business; Severity is Technical

In Triages, team will give the Priority of the fix based on the business perspective. They will check “How important is it to the business that we fix the bug?” In most of the times high Severity bug is becomes high Priority bug, but it is not always. There are some cases where high Severity bugs will be low Priority and low Severity bugs will be high Priority.

In most of the projects, if schedule drawn closer to the release, even if the bug severity is more based on technical perspective, the Priority is given as low because the functionality mentioned in the bug is not critical to business.

Priority and Severity gives the excellent metrics to identify overall health of the Project. Severity is customer-focused while priority is business-focused. Assigning Severity for a bug is straightforward. Using some general guidelines about the project, testers will assign Severity but while assigning a priority is much more juggling act. Severity of the bug is one of the factors for assigning priority for a bug. Other considerations are might be how much time left for schedule, possibly ‘who is available for fix’, how important is it to the business to fix the bug, what is the impact of the bug, what are the probability of occurrence and degree of side effects are to be considered.

Many organizations mandate that bugs of certain severity should be at least certain priority. Example: Crashes must be P1; Data loss must be P1, etc. A severe bug that crashes the system only once and not always reproducible will not be P1, where as an error condition that results re-entry a portion of input for every user will be P1

Microsoft uses a four-point scale to describe severity of bugs and three-point scale for Priority of the bug. They are as follows

Severity ---------------
1. Bug causes system crash or data loss.
2. Bug causes major functionality or other severe problems; product crashes in obscure cases.
3. Bug causes minor functionality problems, may affect "fit anf finish".
4. Bug contains typos, unclear wording or error messages in low visibility fields.

Priority---------------
1. Must fix as soon as possible. Bug is blocking further progress in this area.
2. Should fix soon, before product release.
3. Fix if time; somewhat trivial. May be postponed.

Two Main() function in an application?

Is it possible to have two Main() function in a program?

What is a Service?

Service refers to any software component that provides functionality and is an independent building block that can be integrated together collectively to
represent an application.

Each service is responsible for its specified role in its own domain. In the business sense the service focuses on a specific business function or possibly a group of functions. This model allows for the creation of isolated units of business functionality that can be easily reused throughout development. The loosely bound services help to provide freedom within the architecture.

In the past service orientation was created using services though increasingly today SOA (Service Oriented Architecture) refers to the use of XML Web services. This is because of the vendor neutral implementation and its interface/implementation provide as an ideal model for SOA.

What is a Web Service?

In 2000, the World Wide Web Consortium (W3C) accepted a submission for the Simple Object Access protocol (SOAP). This XML-based messaging format established a transmission framework for inter-application or inter-service communication via HTTP. As a vendor neutral technology, SOAP provided an attractive alternative to traditional proprietary protocols, such as CORBA (Common Object Request Broker Architecture) and DCOM (Distributed Component Object Model).

In the following year, W3C has accepted and published the WSDL specification. WSDL (Web Service Description Language) is implemented through XML and acts as the interface in the interface/implementation model of Web service. It is essentially a language that is used to describe the interface of the Web service.

The interface is further supplemented by the Universal Description, Discovery and Integration (UDDI) specification. The UDDI much like a yellow page directory allows users to perform dynamic searches on the directory for a specific service implementation.

Since then, XML Web services has received industry wide acceptance. The support for XML Web services has furthered the popularity and importance of a service oriented design principle.

Purpose of Metadata

Metadata has many uses. Here are some of them:

• Metadata removes the need for header and library files when compiling, because all the information about the referenced types/members is contained in one file along with the IL that implements those type/members. Compilers can read metadata directly from managed modules.
• Visual Studio uses metadata to help you write code. Its IntelliSense feature parses metadata to tell you what methods a type offers and what parameters that method expects.
• The CLR code verification process uses metadata to ensure that your code performs only “safe” operations.
• Metadata allows an object’s fields to be serialized into a memory block, remoted to another machine, and then deserialized, recreating the object and its state on the remote machine.
• Metadata allows the garbage collector to track the lifetime of objects. For any object, the garbage collector can determine the type of the object, and from the metadata it knows which fields within that object refer to other objects

Azure Session Resources

Motivation Behind the term Azure
Features of Windows Azure
Checking the Health Status of Windows Azure services
Great Azure Example
Windows Azure Platform site
Azure Pricing
TCO Calculator
Connecting with SQL Azure through SSMS

Talk on windows azure

This is the talk session held on Sunday 23rd May 2010 in the Pearl Solutions LLC's conference room at 14040 NE 8th ST Bellevue WA.

Presenter- Vidya Vrat Agarwal
Attendees - Anubha, Kajal, Nanjunda, Sumeet, Varun, Madhuri and Swathi.

Talk on Windows Azure

Date - Sunday 23rd May 2010
Agenda - This session will discuss the emerging Microsoft technology named Windows Azure. Its features, technical jargons associated with it and what are the scenarios it best fits into.
Location - 14040 NE 8th St Bellevue WA 98007 (Pearl Solutions LLC conf room)
Start Time - 12:45 PM
End Time - 1:45 PM
Contact Person - Vidya Vrat Agarwal
Contact Number - 425-516-2058

CLS Compliance - Problem Scenario & Solution

CLS (Common Language Specification) is a very important component of .NET architecture. CLS complaince helps language-interoperability to take place on a common ground, so an application written a any .NET compliant language can be exposed other application writtent in a .NET compliant language.

Scenario:- Consider you are building a C# dll, which is going to be used by .NET client application written in VB .NET. By nature C# is case-sensitive and VB .NET is case-in-sensitive.

Due to this specific casing behavior of these languages, C# has power to declare class members (methods, variables etc) in case-sensitive manner. I.e Deposit(), deposit() and dePosit() are three different methods which can be created in C#.




But this is not how VB .NET works. VB .NET can't allow this because VB .NET is case-insensitive and so can't differentiate that these are three different methods.

Problem:- The problem occurs when the C# dll is being consumed by a VB .NET, and so none of the functionality from C# is exposed to VB .NET, even though its successfully built in C#. Reason of this is that VB .NET don't see those methods of C# as three different methods and so can't decide which one to display in the Intellisense.




Solution:-

The solution of this problem has to take place in C#, because C# has case-sensitive nature.

If you are building a reusable dll which can be easily consumed by any .NET compliant language eveb by those which are not case-sensitive like C# in which the dll has been developed.

You need to enable the CLS Complaince in C# application, by default its set to false.
Once you enable it then any member of a class which differs by case is listed in the CLS-complaince warning.



Now the fix for this is to resolve these CLS warnings and fix the function names, lets rename them rather being different in case only.



After the change in function's name, now there are no member functions in the C# class which differs by case only.

Now VB .NET client can see these functions

Chart your Career

Follow this url to know how can you create a road map for your careep planning.
Chart your Career

What is an Exception, how do you achieve Exception Handling in .NET?

What is versioning? Can Versioning be applied to Private assemblies?

Refer GAC concepts for this question.

What is Metadata and Manifest?

What is Managed code?

What is the difference between an Assembly and a Namespace?

Abstraction and Encapsulation Defined

Abstraction

Abstraction is the ability to generalize an object as a data type that has a specific set of characteristics and is able to perform a set of actions.

Object-oriented languages provide abstraction via classes. Classes define the properties and methods of an object type.

Examples:

You can create an abstraction of an Employee with characteristics, such as FirstName, LastName, Department, Experience etc. and actions such as AssignTask, PerformTask and ReportTo etc. The characteristics are called properties, and the actions are called methods.

Encapsulation

Once you have your class properly design then you can create an object out of it. Object now contains the data and behaviors defined in the class, so a client application can treat this object like a black box accessible only through its interface (which mean its properties, methods/functions etc). This is a key object-oriented concept called Encapsulation.

The idea is that any programs that make use of this object won't have direct access to the behaviors or data – but rather those programs must make use of our object's interface.

Examples:

Employee objEmp = new Employee();
objEmp.FirstName = "Vidya Vrat";
objEmp.LastName= "Agarwal";

objEmp.AssignTask(objEmp.FirstName, objEmp.LastName);

Note: - consider that this function will do so check on your time availabilty and the allocate you some task to the employee provided to this function as an argument.

Finalizer in .NET

Besides we have .NET Garbage Collection to do the memory cleanup. But still in some cases you may wish to have your own Finalizer to do the cleanup.

There are some questions around it.

1 -When do I need to implement a finalizer on my class?
2- Should I always do it, or only when I'm holding onto unmanaged resources?
3- Should I always implement the IDisposable interface when I have a finalizer, and vice versa?

Explaination:-

Finalizers only need to be implemented when you hold onto resources that need cleaning up. For example, a FileStream which holds onto a native file handle. Unfortunately, finalizers place a significant amount of performance-hit and pressure on the GC and should be used only when it is absolutely needed.

What is IDisposable

The IDisposable interface allows users of your class to deterministically (as you know GC is Non-deterministic) do the clean-up. Therefore, any class that implements a finalizer should also implement IDisposable.

Scenarion: - Consider a scenario where my managed class has a FileStream as a private member. FileStream holds onto unmanaged resources and implements both IDisposable and a finalizer. When no more references to the instance exist, this FileStream will be similarly unreachable and will be available for finalization.

There's no reason for my class to be in the queue of objects that have registered for finalization since the instance of FileStream will be there. But my class should provide a way for a user to immediately release all resources it holds onto, either directly or indirectly, and therefore my class should implement IDisposable.

My implementation of Dispose will simply call the FileStream's Dispose method. Note, though, that you need to be careful not to dispose of shared resources (resources used by other instances, for example).

If you write a class that will dispose of a resource made available to it from an external source, make sure your documentation is clear on the subject so that others know whether they're handing over control of any resources they give you.

How to implement Dispose

If you do need to implement a finalizer in your class, your Dispose method should use the GC.SuppressFinalize method to ensure that finalization of your instance is suppressed.

This will remove the instance from the set of objects that require finalization, reducing the pressure on the GC during the collection process through heap.

A common pattern implemented throughout the Microsoft® .NET Framework is to add to a class a Dispose method that takes a Boolean as a parameter.

This Boolean indicates whether the class is being disposed because the IDisposable.Dispose method is called or because the finalizer is run (both the finalizer and IDisposable.Dispose delegate to this method).

If it's being disposed deterministically, GC.SuppressFinalize is invoked. If it's being called from a finalizer, avoid using managed members of your class that implement finalizers as they may have already been finalized.

What are the access modifiers C# supports and their purpose?

What is the difference between Abstract class and an Interface?

How do you achieve multiple inheritance in .NET?

What is the advantage of "sealed" keyword in real-world of software development?

What are the features Inheritance offer above an object creation?

Would you write your own finalizer/destructor or let .NET GC do the cleanup?

Limitations of GAC deployed assembly

1- Strong name key (.snk) musts be assigned to the assembly.
2- Only a .dll can be deployed in the GAC.
3- User created .dll will not be listed under "Add Reference --> .NET tab.
Only Visual Studio .NET specific assemblied are listed in there.

How to use a GAC deployed assembly in an application

Steps to use a GAC deployed assembly

1- A user created assembly deployed in the GAC can be seen Browse tab by navigating to the C:\Wiindows\Assembly
2- When your application needs to add the GAC deployed assembly you need to browse to the \bin\debug folder of the source .dll project.
3- It will be then listed under References folder.

Steps to deply an assembly in the GAC

GAC (Global Assembly Cache) is the .NET provided folder location to contain all the shared assemblies across .NET Framework and applications.

One of the basic and mandate requirement before any assembly could be deployed in the GAC is to Sign the assembly with Strong name.

---------------------------------------------
Steps to deploy an assembly into the GAC
---------------------------------------------
1- Sign the class-Library project generated .dll with Strong name.
Select the Class-Library project--> Right-click--> select Properties, under Signing tab, create a new Strong name key by passing a name you would like to have.
2- It will create a file with the provided name having .snk as file extenion.
it will be saved under the same project folder
3- Now if needed you can create various versions of the same assembly (.dll) by
giving desired version number to the assembly file in the AssemblyInfo.cs
4- When you Build the solution, it will generate the .dll with the provided version number (default is 1.0.0.0) in the application root's bin\debug folder.
5- After each build (ver 1.0.0.0 and 2.0.0.0) to separate folders, as its the same .dll and only version if different and \bin\debug doesn't differentiate between two versions.
6- Drag-drop the MathLibrary 1.0 and 2.0 into the GAC.

What is the difference between loading behavior of .exe and .dll ?

Why would you choose an .exe over a .dll ?

Difference between .NET assembly and a .dll/.exe

What is the difference you see between a .NET assembly and any other .dll or .exe?

Talk on .NET assemblies

This is the talk session held on Sunday 4th April 2010 in the Pearl Solutions LLC's conference room at 14040 NE 8th ST Bellevue WA.

Presenter- Vidya Vrat Agarwal
Attendees - Mohd Shams,Purna, Naksha, Priyanka, Upasana, Ekta and Sukhpreet.

Talk on .NET Assemblies

Date - Sunday 4th April 2010
Agenda - This session will discuss the .NET assemblies and various aspects to deploy them and let client applications know about their locations.
Location - 14040 NE 8th St Bellevue WA 98007 (Pearl Solutions LLC conf room)
Start Time - 1:45 PM
End Time - 2:45 PM
Contact Person - Vidya Vrat Agarwal
Contact Number - 425-516-2058