Google PageSpeed

Make the Web Faster

Fast and optimized pages lead to higher visitor engagement, retention, and conversions. The PageSpeed family of tools is designed to help you optimize the performance of your website. PageSpeed Insights products will help you identify performance best practices that can be applied to your site, and PageSpeed optimization tools can help you automate the process.

What is PageSpeed Insights?

PageSpeed Insights analyzes the content of a web page, then generates suggestions to make that page faster. Reducing page load times can reduce bounce rates and increase conversion rates.

PageSpeed Insights Browser Extensions

PageSpeed Insights is available as an open-source browser extension for Google Chrome and Firefox. Webmasters and web developers can use PageSpeed Insights to evaluate the performance of their web pages and to get suggestions on how to improve them.

PageSpeed Insights performs several tests on a site's web server configuration and front-end code. These tests are based on a set of best practices known to enhance web page performance. Webmasters who run PageSpeed Insights on their pages get a score for each page, as well as suggestions on how to improve its performance. By following the suggestions you can make your site faster, keep Internet users engaged with your site, reduce your bandwidth and hosting costs and improve the web!

Google Chrome

In Chrome, PageSpeed Insights extension runs in the Chrome Developer Tools.
Supports Mac OS X (x86), Linux (x86 and x86-64), and Windows (XP and up)
Install Chrome Extension

Firefox

In Firefox (4.0 and higher), PageSpeed Insights extension runs in the Firebug web development tool (1.7 and higher)
Supports Mac OS X (x86 and x86-64), Linux (x86 and x86-64), and Windows (XP and up).
Install Firefox Extension

PageSpeed Insights extensions periodically checks for updates. If an update is available, the browser will give you the option of downloading the newer version of PageSpeed Insights to get the latest updates to the rules and functionality that is added by the community. 

Code optimization and Best practices for ASP.Net C# Developers

Last week I had a good time with code review, all the guys who did coding are 3-4 years of experience in Microsoft technologies. But still there is scope for Optimization and best practice. Here in this blog post I’ll show you some of them.

1] A field can be made read-only

Consider the following example, Admin_Settings class has a private object ObjDB (an object of class Database)

Code:

public partial class Admin_Settings : System.Web.UI.Page
{
    private Database ObjDB = new Database();
}

Here, this object can be Readonly, by marking this readonly, we get to ensure that this class will not inadvertently modify this object anywhere within its methods.

Code:

private readonly Database ObjDB = new Database();

The same can be applied for Variables if they they are only being assigned in the constructor and offers to create an additional safeguard

Buy Professional ASP.NET Design Patterns from Flipkart.com

2] Use 'var' keyword when initializer explicitly declares type

The var keyword is fairly contentious in terms of usage, but if there’s one instance where its use is sensible, it’s in initializations alike to the following:

Code:

DataSet DsPaidAmount = new DataSet();

Since the type is declared on both left and right-hand sides of the initialization statement, I suggest to remove the type on the left-hand side and replace it with var, i.e.:

Code:

var DsPaidAmount = new DataSet();

Or even further, you can remove redundant initializer and write it as

Code:

 DataSet DsPaidAmount;

Buy Pro ASP.NET 4 in C# 2010 from Flipkart.com

3] Use declaration closer to usage

Consider the following example, where many variables are declared which are not really closer to usage. The Database object DsPaidAmount is declared at the top, and used at the very bottom (so, declaration and usage are not closer).

Code:

public void Receipt()
{
        double PreviousPaidAmount = 0;
        double TaxAmount = 0;
        //variable declared here
        DataSet DsPaidAmount;
        double TotalAmount = 0;
        double PreviousDiscount = 0;
        
        . . . . . . 
        . . . . . . 

        if (some condition)
        {
            . . . . . .
            . . . . . .
        }
        else if (another condition)
        {
            . . . . . .
            . . . . . .
        }
        else if (!another condition)
        {
            . . . . . .
            . . . . . .
        }

        if (statement > 0)
        {  
            //Variable used here! tooooo far from declaration            
            DsPaidAmount = ObjReceipt.GetPaidAmount(somevalue);
        }
        else
        {
            //statement
        }
}

Here, we can move declaration closer to it’s usage, as follows:

Code:

if (statement > 0)
{  
    //Declared and used at same place!
    DataSet DsPaidAmount = ObjReceipt.GetPaidAmount(somevalue);
}
else
{
    //statement
}

Further, for better memory management we can use the “using” constructor, and also remove the type on the left-hand side and replace it with var as follows:

Code:

if (statement > 0)
{  
   using (var DsPaidAmount = ObjReceipt.GetPaidAmount(somevalue))
   {
       // some statements
   }
}
else
{
   //statement
}

Buy Beginning Ajax With Asp.Net from Flipkart.com

4] Remove unneeded 'else' keyword

Some if-else conditions can have their else clause removed. Consider the following method:

Code:

public double roundNum(double num)
{
   double floorValue = Math.Floor(num);
   if ((num - floorValue) > .5)
   {
      return (floorValue + 1);
   }
   else
   {
      return (floorValue);
   }
}

In the above, the else statement can be safely removed because its if clause returns from the method. Thus, even without the else, there’s no way you’ll be able to proceed past the if clause body. We can write it as follows:

Code:

public double roundNum(double num)
{
   var floorValue = Math.Floor(num);
   if ((num - floorValue) > .5)
   {
      return (floorValue + 1);
   }
   return (floorValue);
}

Even better; we can write it by converting it to “?:” operator

Code:

public double roundNum(double num)
{
   var floorValue = Math.Floor(num);
   return (num - floorValue) > .5 ? floorValue + 1 : floorValue;
}

5] Join declaration and assignment

Consider the following example, where Type can use Implicitly typed local variable declaration and Join declaration and assignment

Code:

if (Page.IsValid)
{
     List<string> ServiceList = new List<string>();
     ServiceList = GetChecked(ChkService);
}

Finally by removing redundant initalizer, using Implicitly typed local variable declaration, joining declaration and assignment and with a good naming convention for local variables, we can write this as follows:

Code:

if (Page.IsValid)
{
   var serviceList = GetChecked(ChkService);
}

6] Convert “IF” statements with “?:” operator

Consider the following example

Code:

if (GvVisit.Rows.Count > 0)
{
   BtnCompleteFollowUp.Visible = true;
}
else
{
   BtnCompleteFollowUp.Visible = false;
}

Can be written with pretty optimized version using “?:” operators as follows:

Code:

BtnCompleteFollowUp.Visible = GvVisit.Rows.Count > 0 ? true : false;

Or even better by removing unneeded conditional ternary expression usage. Since condition returns a boolean value

Code:

 BtnCompleteFollowUp.Visible = GvVisit.Rows.Count > 0;

Best Practices for ASP.NET MVC 3 - Model Suggestions

This blog post presents a set of coding guiding principle intended at helping the ASP.NET MVC developer build concrete applications. Of course, it's up to you as the developer to choose which of these guiding principles are suitable for your application

Model Suggestions

The model is where the domain-specific objects are defined. These definitions should include business logic (how objects behave and relate), validation logic (what is a valid value for a given object), data logic (how data objects are persisted) and session logic (tracking user state for the application).

DO split the model its own project with a separate assembly.

For applications with a large complex model, it's a good initiative to create a separate assembly for the model to avoid accidentally mixing concerns. You can then reference the model assembly in your ASP.NET MVC project

DO place all business logic in the model.

If you put all business logic in the model, you protect the view and controller from making business decisions concerning data. You also harvest the following profits

• Fewer duplicated business logic
• The view is easier to read when there is no business logic present
• Testing business rules is out-of-the-way to the model

For example, if you have a business requirement to display a user's full name, you could put the logic in the view as follows

@if (String.CompareOrdinal((string)TempData["displayFullName"], "on") == 0)
    { 
        <text>Model.firstName, Model.lastName</text>
    }
    else
    {
       <text> Model.firstName</text> 
    } 

However, you would have to duplicate this logic in every place this business requirement was needed. Instead, you could put the business logic in the “display Full Name " rule in the model by adding a property to the model that encapsulates the business logic as follows

public string combinedName
{
   get
   {
       return (displayFullName ? firstName + " " + lastName : firstName);
   }
   private set
   {
      ;
   }
}

This would greatly simplify the view as shown

<p>Welcome,  @Model.combinedName</p>

DO place all validation logic in the model

All input validation should occur in the model layer. This includes client side validation, which is essential to performance. However, client side validation can be circumvented (with, for example, tools like Fiddler)
You can use ModelState to add validation checking. The following example shows how to add validation checks to ModelState explicitly

if (String.IsNullOrEmpty(pageName))
{
   ModelState.AddModelError("pageName", Resources.AddPage.PageNameError);
}  

Nevertheless, given the advances in .NET Framework, the System.ComponentModel.DataAnnotations should be the favored method for validation. These annotations are added as attributes to the properties of a model class, as the following example shows

public class Page
{
   [Required(ErrorMessageResourceName = "nameRequired", ErrorMessageResourceType = typeof(Resources.Page))]
   public String pageName { get; set; }
       ...
}

DO define interfaces for data access

It is favored that interfaces be used to expose methods on a provider for data access. This strengthens the loosely coupled component design of ASP.NET MVC.
Consider using the Entity Framework or LINQ to SQL as the means of creating wrappers around calls to a database. Both Entity Framework and LINQ to SQL allow the use of stored procedures as well

DO place all session logic in the model.

It is outside the scope of this blog discussion to travel around in depth the different mechanisms for storing session state in the model. As a starting point, here are a few of possibilities of session state storage:

• In Process
  • Strengths : No extra setup needed.
  • Weaknesses : Does not work if the web site needs to balance
• Session State Service
  • Strengths : Lightweight service runs on each machine in a web farm. Faster than database session storage
  • Weaknesses : Session data is lost if the service goes down
• Database
  • Strengths : Session data is persisted
  • Weaknesses : Slower than session state, Management cost is relatively high

In Next Blog Post, I'll discuss on View Suggestions
Happy Coding!!