In our previous articles, Introduction to SQL Server 2012 and Windows Azure Overview, we made references to Microsoft’s SQL Azure service. In this article we will take a closer look at its main features in more detail.

SQL Azure is a relational database solution with the capability to support both Windows Azure and on-premise applications with minimum latency. It is considered a managed service and it’s offered by Microsoft to allow you to build applications without concerning yourself about the storage they’ll use. Being a cloud service, SQL Azure gives you all the benefits of the cloud including:

-          The hardware and software that support the SQL database are all managed by Microsoft

-          Patching and maintenance are also managed by Microsoft

-          High availability and fault tolerance are guaranteed by an SLA (Service-level agreement)

-          Per usage billing and the availability to scale up or down whenever you have the need

All these features contribute to SQL Azure’s eased management. The service-level agreement is backed up by powerful and extremely secure datacenters offering you maximum protection of your databases. SQL Azure is built entirely on top of SQL Server and offers most of SQL Server’s features, such as the Tabular Data Streams (TDSs) for connecting, databases with tables, views, stored procedures, indexes, etc. They are all managed using the standard T-SQL language. SQL Azure allows you to store up to 150 GB of information in your database. If you need more storage for a database, you will have to spread it out over multiple databases and use parallel queries

In our previous article in the .NET series we discussed the how to optimize String operations in .NET. In this article we’ll focus on optimizing arrays.

Arrays provide basic functionality for grouping types. Every language implements array syntax in its own way, although the following considerations apply regardless of language:

• Arrays have a static size. The size of the array remains fixed after initial allocation. If you need to extend the size of the array, you must create a new array of the required size and then copy the elements from the old array.
• Arrays support indexed access. To access an item in an array, you can use its index.
• Arrays support enumerator access. You can access items in the array by enumerating through the contents using the foreach construct (C#) or For Each (Visual Basic .NET).
• Memory is contiguous. The CLR arranges arrays in contiguous memory space, which provides fast item access.

In the last post of the series, we saw how to use the Monitis JMX agent to collect JDBC connection pool metrics from JBoss. While the connection pool performance is often the most important thing to monitor, there are a multitude of other metrics available in JBoss that are worth exploring.

AJP vs HTTP Connectors

As you probably know, JBoss contains a built-in HTTP request processor to enable it to serve HTTP requests. In production environments however, the application server usually does not handle HTTP requests directly. This task falls on a dedicated web server – most often Apache. This division of labor allows Apache to serve static content (think large image files) and do the heavy-lifting for HTTPS, while letting your app server concentrate on what it does best – generating dynamic content and business logic processing. Apache and JBoss communicate via the AJP protocol – which involves a separate listener in JBoss (actually in JBoss Web – a version of Tomcat, which serves as a web container for JBoss). The AJP processor is very similar to the HTTP one – which is hardly surprising given how similar AJP and HTTP are.

Last time we mentioned two fundamental principles while monitoring any object:

1. The monitor should collect as much important information as possible that will allow to accurately evaluate the health state of an object.
2. The monitor should have little to no effect on the activity of the object.

Sure, these two principles work against each other in most of cases, but with Node.js they work together quite nicely because Node.js is based on event-driven technology and doesn’t use the traditional threads-driven approach. This technology allows to register many listeners for one event and process them in parallel almost independently. To avoid even a small effect on the production server, it was decided to separate the monitor into two parts – the first is the javascript module-plugin that listens to all server events and accumulates necessary information and the second is the Linux shell script that periodically runs the monitor-plugin by using the REST technique for collecting, processing, and sending information to the Monitis main server.

In our previous article, SQL Server 2008 Overview, we looked over the different features that the Microsoft SQL Server provides. In this article we will focus on the new and advanced features of the latest SQL Server release – SQL Server 2012. They include, but are not limited to, the new High Availability solution AlwaysOn, improved security, and the capability of syncing with the cloud.

AlwaysOn consists of two main components – AlwaysOn Availability Groups and AlwaysOn Failover Cluster Instances. Let’s first focus on the Availability Groups. An availability group is a combination of databases that are hosted on a primary server and up to four secondary servers. Each availability group member is capable of replying to clients’ requests in the event that the primary group member is unavailable. All the databases in an availability group fail over to another group member together. This functionality is built on top of the Windows Server Failover Clustering feature and requires its installation.

To answer this question we need to take a closer look at the requirements for a server system to be considered cloud ready and then investigate the different features of Windows Server 2012 that does or does not meet these requirements. Windows Server 2012 is the official name of Windows Server code name “8” and is now on its Beta stage of development.

The first thing to consider here is the ability of the operating system to virtualize its resources, meaning to make them available as part of a shared pool and managed by an administrator. The main features Windows Server 2012 has here are:

-          Hyper-V extensible switch – the Hyper-V switch from Windows Server 2008 is now enhanced to support extensions. It is a platform for you to extend the functionality of a virtual switch to whatever your organization needs.

In our previous article in this series we discussed Iteration and Looping. In this article we’ll focus on optimizing string operations.

The .NET Framework provides the System.String data type to represent a string. Intensive string manipulation can degrade performance. Every time you perform an operation to change string data, the original string in memory is discarded for later garbage collection and a new one is created to hold the new string data. Also note that the String type is a reference type, so the contents of the string are stored on the managed heap. As a result, strings must be garbage collected to be cleaned up.

As a server administrator, you want to make sure you create the best possible experience for users. For users to reliably gain access to Active Directory, it must be managed and monitored to make sure it functions properly.

Monitoring Active Directory is essential to ensure that directory data remains consistent and users have uninterrupted access to their account and domain resources they require access to.

First, let’s make it clear what an endpoint is. In Microsoft’s world this term represents any client computer, server, or laptop in an organization. Forefront Endpoint Protection is a line-of-business application developed by Microsoft to provide defense against viruses, worms, and other threats.

Forefront Endpoint Protection (FEP) 2010 was closely tied to System Center Configuration Manager (SCCM) through the infrastructure. This was beneficial for organizations which had already adopted SCCM, but was a challenge for ones without it implemented.

In this article in the optimizing .NET code series, we’ll discuss “Iteration and Looping”. Non-optimized code within loops can lead to performance issues, ranging from increased memory consumption to CPU exhaustion. This section summarizes guidelines that will improve iteration and loop efficiency:

Avoid Repetitive Field or Property Access

If your data is static for the duration of the loop, obtain it before the loop instead of repeatedly accessing a field or property. The following code shows a collection of orders being processed for a single customer.

for ( int item = 0; item < Customer.Orders.Count ; item++ ){

  CalculateTax ( Customer.State, Customer.Zip, Customer.Orders[item] );

}

Note that State and Zip are constant for the loop and could be stored in local variables rather than accessed for each pass through the loop as shown in the following code.

string state = Customer.State;

string zip = Customer.Zip;

int count = Customers.Orders.Count;

for ( int item = 0; item < count ; item++ )

{

  CalculateTax (state, zip, Customer.Orders[item] );

}

Note that if these are fields, it may be possible for the compiler to do this optimization automatically. If they are properties, it is much less likely. If the properties are virtual, it cannot be done automatically.

Optimize or Avoid Expensive Operations Within Loops

Identify operations in your loop code that can be optimized. Look for code that causes boxing or allocations as a side effect. The following code causes side effect strings to be created for each pass through the loop.