Reporting is the heart of most business applications. And SQL Server Reporting Service (SSRS) is a preferred choice while MSSQL Server is the database back-end. Apart from ready to use services, SSRS provides different and useful scalability and extensibility options.

On the other end, lately, MS Silverlight has generated positive heat amongst varied business applications.

So you got the point. I’m talking about the marriage between SSRS and Sliverlight.

It started with challenges as the whole concept was an unknown devil which we were able to tame in the end.

The problem was simple – Microsoft doesn’t have any SSRS report-viewers for Silverlight – but its impact was not so. Initially, it was apparent that we cannot use SSRS with Silverlight.

So, I Googled (and then Bingged also – both the technologies are from Microsoft ) to find out the following two possibilities out of my one hour of investment:

1. Use Third Party Report Viewer Controls
2. Use ASP.NET application and invoke it from Silverlight application

Each option has its own distinctions. Here are those:

1. Third Party controls: We can use third party report viewers which support SSRS reports. Right now there is only one such software provider Perpetuum Software is available. They provide SSRS report viewer for Silverlight which is also Silverlight 4 ready. There are other report viewers provided by other major component providers like Telerik however they do not support SSRS reports at present. Instead, they support their own reporting ways from within Silverlight application.
2. ASP.NET Application: In this approach, we have to create an ASP.NET web application for hosting SSRS reports. The web application will use default report viewer control. To integrate this web application into the Silverlight application there are two possible options as below:
   1. Using Html Viewer: We can use HtmlViewer control to view reports hosted as an ASP.NET web application. Though, Silverlight 3 does not have in-built html viewer control, there are third party controls available like one from Telerik. The good news is that Silverlight 4 does have in-built html viewer control.
   2. Using JavaScript: We can use client side JavaScript functions to open new window or IFRAME from within Silverlight application which will show reports hosted as an ASP.NET web application.

I am sure Microsoft will come up with a better solution to this problem in the coming days. Until that any of the above options can be used. I used option #2 – ASP.NET application – considering the client needs of flexibility and it worked well.

Print Friendly

As developers, we all probably know what a NULL is in SQL Server. NULL is not a specific value but it stands for UNKNOWN value. In other words, NULL represents the ‘absence of data’.

The behavior and treatment of NULL in SQL server is very interesting in different context and part of T-SQL language. Let’s have a quick look on how it is treated in different ways by SQL Server.

When you use NULL (UNKNOWN value) in Arithmetic operations or in String Concatenation operations, the result is always UNKNOWN because the value which is being operated is not available or UNKNOWN. So, all the following statements yield the result of NULL:

SELECT 5 + NULL
SELECT 10 / NULL
SELECT 'Gateway' + ' Technolabs' + NULL

So beware when you are trying to do something similar as shown below:

DECLARE @TOP INT
DECLARE @SQL NVARCHAR(100)
SET @SQL = 'SELECT TOP ' + CAST(@TOP AS VARCHAR(10)) + '* FROM HumanResources.Employee'
EXECUTE SP_EXECUTESQL @SQL

The above query will never execute. Guess why?  Because you forgot to initialize @TOP variable and due to that it will contain NULL. So when you try to concatenate the value of @TOP with the value of @SQL, the resulting query is UNKNOWN.

Unlike other programming languages, SQL Server follows the rules of “Three-Valued Logic” which means that the result of a condition in T-SQL can have any of three possible values viz. TRUE, FALSE and UNKNOWN. If NULL is one of the operands in condition composed of comparison operators like =,>,<,>=,<=,<>, then the result of the expression is NULL or UNKNOWN.  For example, the result of all of the following conditions is UNKNOWN:

… WHERE 100 = NULL

… WHERE NULL > 5

… WHERE NULL < 10

Even following statement yields NULL as per SQL-92 Standards:

… WHERE NULL = NULL

Let’s create a simple table and insert some records in it.

CREATE TABLE tblPerson
(
PersonID INT
,PersonName VARCHAR(50)
,Age TINYINT
)
GO
INSERT INTO tblPerson
SELECT 1,'Person-1',25
UNION
SELECT 2,'Person-2',NULL
UNION
SELECT 3,'Person-3',35

We have a table which contains three rows.  The second row has NULL in Age for Person-2. Now, execute the following query:

SET ANSI_NULLS OFF
SELECT * FROM tblPerson WHERE Age = NULL

The above query will return 1 row for Person-2. Notice the use of SET ANSI_NULLS OFF which is not recommended way because it does not conform to SQL-92 standards. Microsoft encourages the usage of SET ANSI_NULLS ON which is considered best practice and which is also the default behavior of SQL Server. Now, consider following query:

SET ANSI_NULLS ON
SELECT * FROM tblPerson WHERE Age = NULL

The result of the condition in WHERE clause in above query will be UNKNOWN. It is neither TRUE nor FALSE. But, in this case SQL server treats NULL as if “NOT EQUAL TO” and evaluates the result of the condition to FALSE and will not return any rows. Note the use of SET ANSI_NULLS ON, which is SQL Server default.

If you want to fetch rows where Age is NULL, you should use ‘IS’ operator with ANSI_NULLS set to ON instead of using ‘=’ operator with ANSI_NULLS set to OFF. So, the preferred query should be as follows:

SET ANSI_NULLS ON
SELECT * FROM tblPerson WHERE Age IS NULL

As you can observe from above examples that using comparison operators (=,<,>,>=,<=,<>) in condition with NULL as one of its operands appearing in WHERE clause yields UNKNOWN result when you don’t specify ANSI_NULLS option or if it is set to ON.

But this is not the case when NULL appears in condition for a CHECK constraint. To see this, let’s add a CHECK constraint to our table so that age must be greater than zero when a record is inserted or updated.

ALTER TABLE tblPerson
ADD CONSTRAINT CK_tblPerson_Age CHECK (Age > 0)

Now, add new row with NULL in Age as shown below:

INSERT INTO tblPerson VALUES (4,'Person-4',NULL)

The age for newly inserted row is NULL which is not greater than zero because it is UNKNOWN. But, SQL Server treats NULL differently in this case and evaluates the CHECK constraint condition as if it is TRUE and inserts new row to the table.

You saw that the condition WHERE NULL=NULL yields NULL because both the values are UNKNOWN and due to this comparison is not possible. Thus, the result will always be UNKNOWN. But again, this is not always the case. To prove my point, let’s add a UNIQUE constraint on PersonID column.

ALTER TABLE tblPerson
ADD CONSTRAINT UK_tblPerson_Age UNIQUE (PersonID)

Now insert a new row where PersonID is NULL as shown below:

INSERT INTO tblPerson VALUES (NULL,’Person-5′,30)

Because PersonID column allows NULL values, SQL Server will insert this new row. Now, try inserting one more row where PersonID is NULL:

INSERT INTO tblPerson VALUES (NULL,'Person-6',35)

As you may probably have guessed, because of UNIQUE constraint on PersonID SQL Server will not allow inserting another row with NULL for PersonID because tblPerson already contains one row with NULL in PersonID column. In this case, SQL server treats NULL even differently and considers all NULLs as if they are equal and does not allow a second NULL to be inserted. Even when SQL Server groups or orders rows by a column, it considers all the NULLs in one group as if they are all equal.

I hope this discussion will help many of you in understanding the behavior of NULL in SQL Server. Thank you for taking time to read this article. Readers’ valuable comments are always welcome!

Print Friendly

LINQ is one of the most exciting enhancements made in the Microsoft.NET languages in the recent years.

Essentially, it’s a new way to represent different data models in OOPs notation.

While working extensively with LINQ in last couple of years on mission critical .NET projects, I’ve observed the following five performance enhancement possibilities.

1. Lazy Loading & Eager Loading

Lazy Loading:

By default LINQ loads the related objects lazily. Lazy loading means Loading Object with that associate Objects.

For example, If I have two tables called User (UserId, Name) and User_Car  (UserId, CarID, CarBrand), whenever we initiate a User object, it will automatically load User_Car object details also as shown in the code below.

var userObj = from user in DataContext.User
              Select user;

The above query returns the User Object with the details of associate object of User_Car.  E.g.

Int carId= userObj.User_Car.CarID;

The above statement will fire two queries on database.

First one will be fired when we write query on User Object. E.g.

var userObj = from user in datacontext.User
              Select user;
(Select ID, Name from User)

And second query will fired when we try getting the value from User_Car object.

E.g

Int carId=userObj.User_Car.CarID;
(Select User_Car.CarID, User_Car.User_ID, User_Car.CarBrand
from User_Car where User_Car. User_ID =@userID)

This leads to more round trips to the database. Instead, we can opt for Eager loading.

Eager Loading:

Defining associate Objects  which are require in advance.So when LINQ execute query then it fetch only that objects.And LINQ fire a single on database.

For Example,

DataContext dc= new DataContext ();
DataLoadOptions options = new DataLoadOptions ();
option.Loadwidth<User> (U => U.User_Car)
dc.LoadOptions = options; 

(Here, User_Car object as pre-fetch object. So when we write query on User Object then automatically User_car records get fetch.)

e.g

var userObj = from user in DataContext.User
               Select user;

SQL Query is,

(Select User.ID, User.Name, User_Car.CarID, User_Car.User_ID,
User_Car.CarBrand from User join User_Car on
User.ID=User_Car.User_ID)

And when we write

Int carId= userObj.User_Car.CarID

It fetches the record from memory only. So Eager Loading reduce the Database round Trips and Improve the performance.

2. Use DataLoadOption.AssociateWith ()

In Eager Loading, When association of Master object and child object are based on non PrimaryKey then use DataLoadOption.AssociateWith (). It will optimize SQL query and give better Performance.

3.Set ObjectTrackingEnabled = False

LINQ objects are use only for data retrieval (No insert, update, delete operations are required) then make this flag off.It will avoid Identity Field(Auto-Increment Field) management process.

4. Set Delay Loaded = True

Field which is not in use or huge in size of contain for particular object then set this property as True.So we access the field then only data get  load.

5. Use Compiled Query

Compiled Query skip the steps of  generating Expression Tree and generating SQL Query  of Process Life Cycle.When First time query get executed, the expression tree and SQL query is generated and next time system will use same for execution.

e.g

Public static Func<DataContext, int, IQueryable<User>>
    UserByID=
	    CompiledQuery.Compile ((DataContext db, int UserID) =>
            From U in db.User where U.ID == UserID select U);

When we call Function first time the expression tree and SQL query will be generate and next time system will use the same to execute query on database.

After applying one or more of the above tips, a LINQ application will definitely perform better and thus will ensure faster response times to business needs.

Print Friendly

For whom the client side scripting becomes a headache OR for those who loves client side scripting… jQuery is a great way of doing client side scripting with ease and fun. Playing with HTML DOM elements using jQuery is really a fun and as easy as writing ABCD

Introduction: jQuery is actually an Open Source cross-browser JavaScript library which allows faster and easier JavaScript development then the traditional JavaScript development.

There are 8 things which gives power to the developers for building robust and excellent client side scripts.

1 – Cross browser support :
Those who have ever written traditional JavaScript, they must have faced problems with diff. browser support and it becomes a tedious stuff for detecting browser behaviors and writing separate logics for all , but jQuery has wiped out all those problem by giving cross browser support. So no more cross-browsing compatibility issues here.

2 – jQuery selectors , manipulation & Traversing
Every web developers must have used CSS and its syntax for defining styles by class (with DOT) / elements  / element ID (using #), jQuery also uses all common CSS syntax for selecting a set of DOM elements which is called jQuery Selectors.

i.e. $(“#sample”)  will return all the DOM elements with [ ID = sample ]
$(“div.xyz span#abc”) will return only those <span> elements with ID= abc and are child of a <div> with class name “xyz”

To learn more you can visit : http://api.jquery.com/category/selectors/

3 – jQuery EventBinding
jQuery supports all such events like click ,mouse over/move,load, etc. Writing event on any set of DOM elements are also becomes easier with JQ, by just passing a function as a parameter in event binding.
its as easy as this : $(“#sample”).click(function(){ alert(‘Hi there !’); });
To learn more you can visit : http://api.jquery.com/category/events/

4 – Callback functions
jQuery also facilitates the callback functions in many methods which becomes useful while working with animations or any timer based functionalities.

i.e.  $(“#sample”).show(“slow”, [ optional callback function ] );

5 – Utilization of JSON
JSON stands for “JavaScript object notation”. Use of JSON everywhere as an optional parameters makes jQuery more flexible and powerful for passing a set of parameters.
Jquery utilizes JSON format widely in most of inbuilt functions ,all AJAX methods and in jQuery plug-in development as well.

i.e.  $(“#sample”).css({height:”40px”, color:”black” });

6 – jQuery AJAX
jQuery gives a variety of AJAX functionalities to the developers with extensive use of callbacks for different AJAX events, and a good thing about jQuery AJAX is that we don’t have to take care about cross-browser compatibility issues. and no need to take care of xmlHTTP object n all.
It gives different functions for all kind of developer’s needs

i.e. $(“#sample”).load( [ URL] ); – a very basic function, which will load the HTML from the specified URL into #sample.

To learn more visit : http://api.jquery.com/category/ajax/

7 – jQuery plugins
jQuery plug-in is a concept or we can say a mechanism of making our own functionality generalized by packaging it all together as a plug-in.
jQuery plug-in offers great portability to the code and of course code re-usability with ease.

To learn more visit : http://docs.jquery.com/Tutorials:Getting_Started_with_jQuery#Plug_me:_Writing_your_own_plugins

8 – JQuery UI
jQuery UI is an Open Source library which is built on core jQuery.
It can be used to built highly interactive web applications,
jQuery UI offers a wide range of inbuilt functions for animations, effects , themes mechanism , rich  UI widgets and complex behaviors like Drag-Drop , resizing , selection & sorting.

• jQuery UI categorizes all functionalities in main 3 section given below
  • Interaction: Covers complex behaviors like Drag-Drop elements, Resizing and Sorting. And provides a wide range of options for handling different behaviors and scenarios
  • Widgets: Fully functional rich UI elements (ultimately jQuery plug-ins) with a Rich User Interface and flexible theming options.
  • Effects: Enables supports of various animation and transition effects like slide,blind,bounce, drop,fade etc.

To learn more visit : http://jqueryui.com/demos/

Print Friendly

The Template Pattern uses the inheritance beautifully to take advantage of code reuse. No composition is used because of the strict nature of the circumstances where this pattern should be used. The subclasses are bound to implement the abstract behavior of superclass and give the implementation in their own way and yet the sequence of algorithm is made unchangeable by making the method, of superclass which has the algorithm, final.

Definition: Defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.

When to use it: When you have a fixed algorithm to execute from a superclass and which must not be changed in sequence but should behave differently in subclass specific way then its good to use this pattern for

1. Integrity reason of the algorithm’s sequence.
2. Code reuse, if there are many subclasses which all depend on superclass implementation of certain functions which are of similar nature.

How to use it: Superclass will have certain methods, whose implementation is given by superclass itself and some methods which are defined as abstract, and thus, must be implemented by the subclasses. In this pattern, a superclass will define a method, which has a fixed sequence in calling some methods, we call it template method or an algorithm. Define this template method as final in superclass so that, subclasses can not change the sequence of algorithm and still contribute subclass-specific way by giving their own implementation of abstract methods. So the client will call the final method of subclass, inherited from superclass, and get the implementation of the algorithm in the subclass-specific way.

Example: The diagram 1.1 shows the initial design, where two different classes has an algorithm which has same sequence of methods but each having its implementation of those methods in their own way. Here, the same code is scattered across the classes.

The diagram 1.2 shows the Template Method Pattern, where we take out the common behavior of subclasses into superclass creating a common point of change which will reflect to all the subclasses. We define the subclass-specific methods in superclass as abstract thus making mandatory for subclass to give implementation. Also, we create a new method, Template Method(on which the name is given to this pattern), by calling the methods in the sequence by which we want our common algorithm to be executed. And , defining it as final so that we are sure that no subclass can change the sequence and just give its own implementation.

Conclusion: To conclude, the sequence,which must be same throughout the subclasses, is defined by the superclass and some part of the algorithm is executed by subclasses .Such design is a very good example of secure algorithm ensuring fixed sequence but with added touch of subclasses who give their own implementation.

Print Friendly

As UI-creation technologies such as ASP.NET and Windows® Forms become more and more powerful, it’s common practice to let the UI layer do more than it should. Without a clear separation of responsibilities, the UI layer can often become a catch-all for logic that really belongs in other layers of the application. One design pattern, the Model View Presenter (MVP) pattern, is especially well suited to remove lost of logic from UI layer.

Some noteworthy benefits of MVP pattern:

• Platform independent: In this Pattern application make independent from its platform so when ever requirement comes to move to window to web or any other version its only need to change on code behind page for view Implementation, so later on required to any of the application portion convert in web to window or any other platform we can handle it by minimum efforts.
• Loose couples form UI: So application stays loose couples from code behind page (UI) to business layer or any other next latter.
• Useful to create automated unit test: MVP is purely loose couples from any plate form so that it is very use to prepare automated unit test cases.
• Increase code maintainability: Keeps code more maintainable throughout the lifetime of the project, especially during the maintenance phase.

Overall Application Architecture:

1. Model: Model is UI interface for how and what the data are needed to displayed.
2. View: Show the representation of model, that can be build in presenter
3. Presenter: Build all data for model and pass all data to model in form of view by communicating with services class( or business logic layer)

Below is the MVP patterns example with service class:

1. User Interface Layer

In this section contains actual UI, in .net terms its aspx or ascx pages.

2. Presentation Layer ( MVP :- Code behind + view (interfaces) + Presenter)

In this layer we have designed as MVP patters so it’s divided in below three parts.

a. View – It is interfaces. This interface contains signature of all properties and events that needs to implement in code behind page that will be use in presenter class.

I.e.

Public Interface Icustomer

ReadOnly Property CustomerName()

WriteOnly Property DisplayMessage()

End Interface

b. Code Behind (Model) – In this class we need to implement View.(No need to specify any logic). We are just implement properties which is defined in view.

#Region “Member”

Dim Presenter As CustomerPresenter

#End Region

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

Presnter = New CustomerPresenter(Me)

Presnter.LoadData()

End Sub

ReadOnly Property CustomerName() Implements ICustomer.CustomerName

Get

Return textCustomerName.Text

End Get

End Property

WriteOnly Property DisplayMessage() Implements ICustomer.DisplayMessage

Set(ByVal value)

Response.Write(value)

End Set

End Property

c. Presenter - In this class we are using all those members which we have specified in view and implemented in code behind. Presenter class is responsible for execute methods of business layer.

Public Class CustomerPresenter

Private iView As ICustomer

Private SessionProvider As ISessionProvider

Public Sub New(ByVal view As ICustomer)

Me.iView = view

End Sub

‘Public Sub New(ByVal view As ICustomer, ByVal SessionProvider As ISessionProvider)

‘ Me.iView = view

‘ Me.SessionProvider = SessionProvider

‘End Sub

Public Sub LoadData()

Me.iView.DisplayMessage = Me.iView.CustomerName

End Sub

End Class

Summary:

• MVP is little prolonged process to implement and understanding in the beginning, but later on it will be very useful as it provides application maintainability on application maintenance phase, increase code re-usability. A good thing about it is a clear distinction of different layers.  For example, all the code is separate from the user interface.
• MVP is a strong consideration candidate for large scale projects especially where project maintainability re-usability are the key success criteria. It suits well with automated test cases methods also.

Print Friendly

Microsoft SQL Server has an effective pool of shared memory which ideally is used for two purposes .

1. Data buffer;
2. Execution plan cache.

It is commonly known that a query executed second time always gives response faster than the first time. In this post I’m going to discuss what works behind this and how can we make sure that the shared memory is effectively used.

What works behind this?
The shared memory part which is commonly known as execution plan cache (also known as procedure cache) save the execution plans of all the queries executed in SQL Server. When a query is executed this area of memory is looked into to determine if any of the existing execution plan can be re-used for this query. If the plan is not found then the query is parsed, compiled, optimized for execution and then the execution plan of the same is stored in the execution plan cache. That is the reason of queries working faster in subsequent time than the first time.

How to make effective use of execution plans
For each query executed in SQL Server an execution plan is saved but its not necessary that the execution plan stored is useful enough that its used for other queries also. To better understand this lets have an look how SQL Server saves the execution plan.

SELECT UseCounts, CacheObjType, ObjType, ST.Text FROM sys.dm_exec_cached_plans
cross apply sys.dm_exec_sql_text(plan_handle) as ST
ORDER BY ST.text


In the above screenshot let’s concentrate on the area which is in red. These three execution plans are the result of non-parameterized ad-hoc queries executed from the code of application inside an iteration. In this case none of the execution plans are effective, for each query a new execution plan is required. The query in the code was written something like below.

string sql = “SELECT * FROM URls where urlid=” + a;
where “a” is the varying value of the iteration

Had this query been a parametrized query only one execution plan would have been created and used for all the iteration. Let’s take an example to understand this better. Now my query would be something like.

string sql = “SELECT * FROM URls where urlid=@a”;
SqlCommand cmd = new SqlCommand(sql, myConn);
cmd.Parameters.Add(new SqlParameter(“@a”, a));

Now let’s have a look at the execution plans

In the above screenshot you would realize that only one execution plan has been created and its “usecounts” is 3, that means this plan has been used three time. Reusable execution plans means lesser CPU utilization , lesser utilization of memory for execution plan cache there by leaving more memory available for data buffer.

Conclusion
Though SQL Server maintains the execution plan of each query but making effective use of it is some what in our hands. There should be no piece of code in the application which is making use of ad-hoc queries it should always be parameterized queries. Though I personally prefer to use stored procedure since allowing direct access to the tables can be a security risk.

Print Friendly

Whenever we develop a new application, lots of things play key role to decide application architecture. Among these, database interaction is the major. In earlier days of .NET 2.0, no significant tools were available from Microsoft to create data access layer for database interaction. People had to use third party utilities for conceptual data modeling over the physical database.

Realizing this need Microsoft introduced LINQ to SQL for conceptual data modeling, though it comes with limited set of functionalities and can be used by SQL Server database only. To overcome this situation, Microsoft has taken steps to release new feature called Entity Framework with ADO.NET 3.5 SP1 release.

ADO.NET Entity Framework is an Object – Relational Mapping (ORM) framework. It builds on the concept of Entity Relationship Model by introducing a conceptual model, called the Entity Data Model (EDM) which sits between your code and the underlying schema (database). This abstraction helps a lot to reduce the efforts as well the complexity for moving relational data to object oriented programming.

Entity Framework architecture:

Here is how the Entity Framework is layered to abstract the relational schema of a database and present a conceptual model.

	Data Source: It represents one or many databases.
	ADO.NET Data Providers: It will access data from data source.
	Entity Data Model (EDM): EDM contains entity classes, storage container and mapping of the entity with the table.
	Entity Client: It is an ADO.NET managed provider that supports accessing data described in an EDM.
	Object Services: This component enables you to query, insert, update, and delete data, expressed as strongly typed CLR objects that are instances of entity types.
	Entity SQL (ESQL): It is a derivative of Transact-SQL, designed to query and manipulate entities. Both Object Services and Entity Client components can execute Entity SQL statements.
	LINQ to Entities: It is used to query against entities defined in the EDM.

Advantages:

• You can use the Entity Framework against not only SQL Server but also Oracle, DB2, Informix, MySQL, Postgres etc with the help of its data providers.
• You can create data access layer with the ease of Entity Framework wizards. Developer can work with data rather than coding against rows and columns.
• It is truly a foundation stone for Microsoft’s data access platform. one of the use of this platform  is REST based ADO.NET data service aka Astoria.

How to build:

Visual Studio 2008 and onward have ADO.NET Entity Data Model (.edmx) template which can be used to generate entity relationship. Using the template, wizards helps you to generate the entity model relationship.

Conclusion:

ADO.NET Entity Framework is interesting technology for data accessing requirements. Microsoft has put a welcome step to reduce the developer headache.

This means that developers can focus more on solving business problems and contribute towards organization’s goals to help the customers by supporting their business effectively.

Stay tuned to explore more about Entity Framework in the following posts.

Print Friendly

Cloud computing means Internet based computing mechanism where Software, Hardware and other resources which are available in shared mode and can be utilized as and when required.  These are virtual resources which offer dynamic scalability over the web – this is the essence of the Cloud computing.

There are many cloud services that can be envisioned, but the main ones are IaaS (Infrastructure-as-a-Service), PaaS (Platform-as-a-Service), and SaaS (Software-as-a-Service).

Consider this scenario:

You have an E-Commerce application which sales grocery products. You have deployed it on a dedicated server which has high CPU speed, high memory and necessary disk space. You noticed that you have major traffic on your website every evening at around 6 to 8 PM and on weekends. During this period you receive 70% of your orders. Still there are many customers who would not order on your website due to over-traffic and connectivity issues. Either you need to add a new server or need to leave that chunk of business.

Here, Cloud Computing gives you the flexibility where in you can select extra resources for your peak business hours (which are 6 to 8 PM and the weekends in this case), there by avoiding the need of extra full-time servers for managing extra traffic. This way you will be able to save dollars on your hardware and infrastructure cost and keep your clients happy by giving them needed speed and better user experience.

Cloud computing offers great value in such situations.

Cloud at its best:

We are close to that virtual world where-in we will have very light-weight PCs and all the useful local machine data will be stored in some kind of a cloud, thereby giving access to the data 24×7, 365 days from any location. Web is going to be significantly different and more effective.

Cloud and SaaS:

If you are using a SaaS model application, you don’t need to buy that application. Instead, you only need to pay a subscription fee. You need not to worry about the maintenance of that application or server where it is hosted. All you need to do is to pay your subscription fee and start using that application. SaaS application providers host it on a set of servers and sell its subscriptions to the various customers. Tomorrow, if you come and ask the SaaS provider that you need to have an account for your additional few hundreds of employees for the same SaaS application you’re using, they will change it from SaaS model to the Cloud Computing. This is how Google works.

Cloud development tools:

Microsoft Visual Studio 2010 has cloud development tools which allows the developers to write their cloud centric web applications and services. Developing scalable web applications and services have become easier now and can be tested on Windows Azure simulation environment.

Microsoft SQL Azure is a cloud based relational database service built on SQL Server technology. It provides highly scalable database service.

Interesting thing is that, any existing ASP.Net application can be converted to cloud application in few steps, with the help of above tools. See here

Summary:

Cloud computing is a fantastic approach to manage your business applications. It’s really helpful to small, medium and big sized organizations to manage their data and infrastructure securely, easily and in cost effective fashion. HP, IBM, VMware, Amazon, Google and Microsoft are extensively using cloud computing. In fact they are cloud service providers as well.

Photo Credit: betsyweber’s Flickr photostream

Print Friendly

“Go GREEN” is Buzzword around the globe.

World celebrated “Environment Day” recently on June 5, 2010.

Always growing energy demand, requirements of higher productivity, greater and greater urbanization, mobility, smarter communication media and Environment Protection are few important challenges of our times.

While we are reading and brushing through ways for the environment protection, let’s see how each one of us can make a small contribution for the cause and be a part of big effect which will be for the benefits of everybody on mother earth.

Adopting a GREEN lifestyle at home is a best “first step” toward living healthier and helping to save the planet, but you can extend your influence even more by going green at work too.

Consider these ways to reduce fatal impact on the environment:

• Think twice before lowering the temperature in summers and increasing it in winter while programming the Air Conditioners. Each degree warmer you leave the thermostat in summer, and each degree cooler you set it in the winter can save 6 to 8 % in energy costs.
• Be a guardian of one potted plant in the home / office. Artificial greenery might be low-maintenance, but the real plants add liveliness and oxygen to your surroundings.
• Can we adopt a policy of “bring-your-own coffee mug” for the coffee breaks and avoid using the plastic cups. Your company will reduce plastic waste.
• Keep pushing for online meetings instead of personal meetings whenever possible, as virtual meetings can save lot of time, money and fuel.
• Reduce the use of energy for using computers by putting them on “Power Saving Mode”
• Save Paper and Ink. Avoid printing documents that could be emailed, and as far as possible print necessary papers on both sides. Producing a single sheet of virgin paper requires an average of 20 watt-hours
• Using one side printed “Not-So-Important” papers for internal note pads. Switch to recycled paper and water-based inks.
• Consider using LCD monitors or laptops in place of CRT monitors, which can use up to 70 % less electricity and generate less heat waste.
• Use Energy Star certified equipment for energy saving.
• Turn off all electrical equipment when not in use.
• Do not leave water taps dripping; make sure to close them tightly after use. One drop of water wasted every second amounts to 10,000 litres per year.
• Educate your colleague about the use of environment friendly work ideas if he/she is not following them.
• Use CFL bulbs, they consume 1/3 energy and last 10 times longer
• If you have option of multiple elevators, do not call all elevators at a time. See which one is nearer and call for use.
• Use Bicycles for shorter distance tavel
• Use cotton bags in place of plastic / paper bags
• I know it may sound pretty cliché, but if each of us would do just a couple of small things to reduce our impact, we could probably do a lot to help stave off the global environmental crisis

Anyone can go green; there are many reasons beyond protecting environment such as

1. Reverse Climate Change, reduce Global Warming and the hole in the Ozone Layer
2. To ensure the bright future of next generations
3. To preserve the limited amount of natural resources
4. To reduce pollution which harms us by contaminating Air, Water and Soil

If you like and follow these, you’re an” environmentally conscious” person. You reduce, reuse, and recycle in your home and office, and you’ve taught your children / Colleagues / Friends to do these things, too.

Go GREEN, Feel Proud.

Print Friendly