Blog

Microsoft System Center App Controller 2012 provides a self-service portal for application owners to manage their IT services housed in private clouds and Azure-based public clouds.  It accomplishes this by using System Center Virtual Machine Manager (SCVMM) Service Templates. App Controller is a Silverlight-based, IIS website with a SQL Database back-end that connects directly to SCVMM.

The most anticipated App Controller feature coming in Service Pack 1 (SP1) is the ability to seamlessly migrate a virtual machine (VM) from a private cloud to Azure.  First, store the VM in the virtual machine manager (VMM) library and setup a virtual private network (VPN) between your network and Azure.  There are a number of ways to move a VM into Azure, either just the virtual hard disc (VHD), or the whole VM. The VM can be deployed as a stand-alone VM, or a scalable cloud service in Azure can be created to contain the migrated VM.

New Azure-Specific App Controller Features in System Center 2012 SP1

• Upload a virtual hard disk or image to Windows Azure from a System Center Virtual Machine Manager (SCVMM) library or network share
• Add a VM to a deployed service in Windows Azure
• Start, stop, and connect to VMs in Windows Azure
• Migrate a VM from Microsoft private cloud (SCVMM) to Windows Azure
• Deploy a VM in Windows Azure to create a cloud service
• Windows Server 2012 and SQL Server 2012 support
• Connectivity with other third-party private cloud solutions

Looking to implement the System Center App Controller? These new updates through Service Pack 1 bring some significant enhancements. Reach out to New Signature to learn how you can take advantage of them today!

What is FIM 2010 R2?

Microsoft Forefront Identity Manager (FIM) 2010 R2 is an enterprise-grade system for efficiently managing the life-cycle of identities across multiple heterogeneous systems.  One part of this is synchronizing data about objects across multiple disparate databases.

When might you use FIM 2010 R2?

Here are some scenarios where the use of Microsoft Forefront Identity Manager might be appropriate:

1. A large company with many new staff added each month.
2. A smaller company with high turnover.
3. Any company that needs to add identities for new staff to several different systems and have them managed and synchronized in an accurate and consistent way.

What is a typical use of FIM 2010 R2?

 Let us imagine that you have 3 systems that hold information about user identities, for example: a 3rd-party HR system, a Microsoft Active Directory domain and a Microsoft Exchange server.  With FIM 2010 R2 you could set up the following:

• When a new employee is entered in the HR system and her “employment status” attribute is set to “employed,” then a new user account will be automatically created in a specific OU in Active Directory.
• When the above happens, if the new employee’s “department” attribute in the HR system is set to “accounting”, then the new user in Active Directory will be automatically added to an Active Directory security group for the Accounting department.
• When a new user is added to a specific OU in Active Directory that is managed by FIM, then a corresponding email account is automatically created for her on the Microsoft Exchange server.

You can see that the goal in the above example, is that when a member of HR adds a new member of staff, the rest of their account provisioning takes place automatically.

What about ongoing identity maintenance?

Forefront Identity Manager uses a concept of sets that are similar to but not the same as AD security groups.  A set might be the group of identities that have their “manager status” attribute set to “true” in Active Directory.  With FIM you can define rules stating what will happen as identities transition in and out of sets.  As an identity transitions into a set they might be given access to specific areas of the file system through being added into a security group, and should they leave the set then another rule could state that they would then be removed from the same security group.

Using this type of functionality enhances system security by helping to ensure that staff have the security rights to do the job role they are currently fulfilling – no more and no less.  Should they move to another job role then their security rights will be adjusted automatically.

What about users’ passwords?

The Microsoft Forefront Identity Manager self-service password reset portal provides a web-based interface where users can reset their passwords.  They do this by identifying themselves through their answers to a series of questions that they had previously defined.  Alternatively, FIM also supports having a one-time password sent to the user via email or text message.  This can greatly reduce the volume of password resets that require assistance from help desk staff.

What about the end of the identity lifecycle?

When an employee leaves a company there can be a serious security risk if their account is not disabled promptly.  With Forefront Identity Manager you can automate the whole deprovisioning process through a set of rules that states what happens when the “employment status” attribute of an identity in the HR system is set to “terminated.”  Changes to the rights of access to multiple system that might have taken days manually might take only a few hours when automated through Forefront Identity Manager.

How can I track what is happening?

The new R2 version of FIM 2010 contains a new reporting component as standard.  You can, for example, generate a report that gives you the history of membership changes to a security group along with data on who approved the changes.  To take advantage of this functionality you will need to Install Microsoft System Center Services Manager (SCSM) 2010, as FIM 2010 R2 uses SCSM to capture data and provide reports.  (Note: SCSM 2012 is not yet supported with FIM 2010 R2). This means you will need at least one additional server dedicated to SCSM.  Like other features in FIM the reporting component is optional so you can choose not to implement it if it is not needed.

Where can I find out more?

Forefront Identity Manager 2010 R2 is a large product with many features that requires extensive research and preparation to implement successfully.  You can use the links below to learn more about the product and its capabilities.  Also, keep an eye out on this New Signature blog for further posts about specific functionality within FIM 2010 R2.

1.  Forefront Identity Manager Resources list by Microsoft:

http://social.technet.microsoft.com/wiki/contents/articles/399.forefront-identity-manager-resources.aspx

2. Test drive Forefront Identity Manager with hands on Virtual Labs at:

http://www.microsoft.com/en-us/server-cloud/forefront/identity-manager-trial.aspx

Note that some of the Microsoft pages about FIM 2010 on the web are outdated – they refer to the original version released in 2010, not the R2 version of FIM 2010 R2, released in 2012.  While it is the same product there are some big differences between the two versions.  For example, the FIM Reporting functionality is new to the R2 version of FIM.  In addition, some of the 2010 R2 pages talk about it still being in Beta, but it is now available.

3. Check out “Forefront Identity Manager 2010 R2 Handbook,” by Kent Nordstrom, Packt Publishing (2012): http://www.packtpub.com/microsoft-forefront-identity-manager-2010-r2-handbook/book

The Importance of Putting Content First

It is not uncommon for an organization to invest tremendous resources in developing the framework for a web site that is well-structured, well-designed and well-developed on a robust platform.

Surprisingly it is also not uncommon for the same organization to invest very little in the content that is to be featured in this web site. As a result, many sites suffer from insufficient, inadequate or inappropriate content. Yet, the primary reason users come to a particular site is content. Without effective, usable content, the value proposition for the customer cannot be delivered and the site is a failure.[i]

Organizations don’t intentionally set out to produce poor content. It’s just that most lack the processes, tools and resources to get content right. Clearly, content deserves more time and attention.[ii]  And that attention is needed up-front, in the planning stages. Failing to allocate the necessary resources to develop content along with the rest of the site risks: [iii]

• Rework (IA, design, database, etc.)
• Delayed timelines
• Blown budgets
• Frustrated stakeholders
• Stressed employees
• Bad content
• Bad usability
• Unhappy users
• Unsuccessful project

 Improve your Chances of Success [iv]

Creating content is a complicated process. The effort required to create and maintain good web content should not be underestimated. Planning, researching, [actually] writing and editing the content is just the beginning. Numerous stakeholder and legal reviews of each piece of copy can send production schedules into a tailspin. To improve your chances of success:

Think of yourself as a publisher. [v]
You, or someone you know, has to own the process of creating content for and managing content on the site. As a site owner, it is your responsibility to make sure fresh, relevant content keeps flowing to sufficiently satisfy users’ demand.

Create your content team.
The sooner you can identify a core set of individuals who will be part of your publishing process, the better. Give these individuals specific responsibilities and make it part of their official job.

Ruthlessly limit the amount of content on your site.
Do not bite off more than you can chew. It seems obvious that a small web site would be easier to manage than a large one [vi].  Yet, many sites are bloated with weak content. Focus on quality over quantity. Measure any requests for new content against your business goals. Your users will thank you.

Plan for maintenance.
Make sure you know what you are signing up for in the long term. Some ideas that sound great require far too much regular upkeep to keep them fresh and compelling. This includes blogs, newsletters and any daily, weekly, or even monthly promises of new content. Set up an editorial calendar that your content team can handle along with all of their other responsibilities. Consider the natural timing of information production in your organization and work with it.

Be prepared for change.
This is the web. What is true today will likely not be true in six months. Be nimble, be responsive and continuously ask your users what they want and need from your site.

Content is not a commodity and there are no shortcuts. Done well, content can build your brand, close the sale, improve retention, and win loyalty. Done poorly, it will cause you to lose your audience’s attention and trust. [vii]

To learn how New Signature can help your organization successfully plan and manage your site content, please contact us at creative-sales@newsignature.com.

This piece is derived from great work produced by some of content strategy’s best known stars.

[i] Rahel Bailie via Karen McGrane’s presentation “Content is King”
[ii] Kristina Halvorson, Content Strategy for the Web
[iii] Michelle Rach’s presentation “10 things every business person should know about content strategy”
[iv]Derived from Melissa Rach’s presentation “10 things every business person should know about content strategy”
[v] Joe Pulizzi via Karen McGrane’s presentation “Content is King”
[vi] David Hobbs via Karen McGrane’s presentation “Content is King”
[vii] Kristina Halvorson, Content Strategy for the Web

Having a Hybrid Exchange environment lets you move to the cloud on your terms.   You can co-exist with users on premise and in Office 365 for as long as you want and the user experience is virtually identical.   For your administrators, they do not have to re-learn a whole new set of tools and commands to manage users and can work with familiar Exchange 2010 snap-ins and PowerShell cmdlets.

Which brings us to the topic of today’s post.   If you have setup a hybrid organization, it’s likely because you have a well-established exchange organization and are using many of the features that are offered to you in Exchange 2010.   You’ve probably taken advantage of Unified Messaging, retention tags and policies or have allowed users to get away with storing large emails in their mailbox.   When moving to 365,  your users are going to expect things to work just like they did on premise and you’re going to want to make sure you can do it without performing a complicated run of tasks after every move.   Today we’ll go over a few steps you can follow to make sure your on boarding process to 365 is as seamless as possible.

Maintaining UM Mailbox Settings

If you are using Exchange UM for Lync or as a voicemail solution for your PBX you’ll need to make sure that you re-create your on-premise UM Policies in Office 365 to continue to provide voicemail services.   By default, you cannot move a mailbox that is UM enabled to Office 365 so you would have to first remove the UM feature from a user, start their mailbox move and then finish it when you are done.   This could potentially lead to a bad experience for a user if someone tried to leave them a voicemail while their mailbox was moving.   

Fortunately, there is a way to make the process seamless to the end user.   Hidden within the set-ummailboxpolicy cmdlet,  there is a flag called SourceForestPolicyNames,  what this will let you do is create a mapping between your On-Premise UM mailbox policy and your cloud policy.  For example: 

and then on premise

Using these you can now perform a mailbox move without turning off voicemail first.

IMPORTANT:   If you are not using Lync as your PBX, be sure to have the move request suspend before finishing the move. Otherwise the voicemail for a user will stop working until you have a chance to go back and update your PBX to point to the new voicemail location.

Skipping Large Items

Another area where administrators often run into problems is dealing with large items in user mailboxes.   Office 365 has a limit of 25MB on their transport servers and a soft limit of 35MB on data in the mailbox itself.  This gives you a little bit of leeway on moving items as if someone has an item near the limit it will still get into 365.  However you still can have users that may have sent messages larger than that in their on premise environment for whatever reason.   We’ve previously blogged about ways to find large items in mailboxes however making sure your users delete them all is another story.   Fortunately Office 365 provides a way to be able to move your mailboxes without worrying about a move failing due to large items.   That setting is largeitemlimit.

Similar to -baditemlimit, largeitemlimit can be configured to override the threshold for the number of items that will be skipped during a move without stopping the move outright.   This variable is only available via PowerShell so your going to have to kick off your moves with the new-moverequest cmdlet.   Using it would look something like this:

This will run a remote move request that will skip up to 40 corrupt items and 40 large items in the mailbox and then put it on hold right before you are done so you can fully control the migration experience.

Hopefully these quick tips will help you out as you are planning to move your email services out of your datacenter and to the cloud.

Among the many components that power the Drupal 7 CMS platform, one of the most difficult to master is render arrays.  These are PHP keyed arrays whose keys have special meanings, and which are “magically” converted into HTML markup.  In theory, this makes for an elegant, extensible format, where any number of manipulations can occur before the HTML is actually generated.  However, in practice, so many things can affect the final output of a render array that it can be difficult to make it do what you want.  If you look at a render array in code, it is difficult to guess how exactly the corresponding markup will look. Correspondingly, if it doesn’t look how you expect, it can be difficult to determine how to fix it.

The purpose of this guide is to help you understand how render arrays work and which options are available. You should then be able to look through Drupal’s built-in render types, defined in system_element_info() and leverage them more effectively in your own applications.

Types of keys

The first thing to make sure you understand is the difference between value keys and content keys.  Value keys always begin with a hash (#) and contain some value that is usually passed directly to a theme function or to Drupal’s rendering engine.  These always have special names with specific meanings.  On the other hand, child keys – those that do not begin with a hash – contain nested elements and can have any name. The rendering engine sorts any child elements using the '#weight' key, then recurses into them renders them first before rendering the outer elements. See element_children() for more on how the child elements are identified and sorted.

For example, consider the following:

In this example, '#type', '#attributes', '#markup' , '#title', '#href' and '#weight' are value keys which have specific meanings, while 'content' and 'link' are nested elements containing some text and a link to render. Each of these nested elements will be processed in turn.

Special Value Keys

While some value keys are standard for all render arrays or forms, most are actually dependent on the theme that ultimately renders each element. These keys can be found in drupal_render(), form_builder(), and element_children().

Any key that is not listed in one of these functions is instead used by the theme functions. The theme functions that make up forms try to do a good job of standardizing keys and reusing them across themes; these are documented here. However, this reference does not include non-form render array types, which may or may not use these same keys. For instance, in the example above, the 'container' type expects the '#attributes' key, but the 'markup' type does not, so passing an '#attributes' key to that element won’t do anything. Similarly, the '#title' and '#href' keys would be meaningless in the 'container' element.

Theme functions

Although all previous versions of Drupal use theme functions, Drupal 7 is the first to extend them to render arrays, using the special '#theme' key.  But, like many things in Drupal, there are multiple ways to implement them.

Variables

One way to define a theme is to list each of the variables that will be passed in.  Any value keys are stripped of their hash and are converted into variables within the theme function.  However, this sort of theme function most likely can’t handle nested elements. This means that any nested items need to be rendered completely before they are added to the render array.

For example:

See the complete implementation of theme_item_list().

When this page is rendered as HTML, it looks something like this:

Render Elements

Render element themes allow you to pass an entire render array into a theme function. These types of theme functions tend to work better with nested elements, or as theme wrappers (see below).

For example:

See the complete implementation of theme_container().

When this page is rendered as HTML, it looks something like this:

Theme wrappers

In addition to the '#theme' key, render arrays can also have '#theme_wrappers'. These take the output of the inner theme function and wrap additional markup around it. An element can have many theme wrappers; each will wrap the markup that was generated by the previous theme functions, which can be found in the '#children' key of the element.

Theme wrapper functions have access to the same keys in the same element as any theme functions used before on the same element, so it’s possible for a value key, such as '#title', to be used more than once in different theme functions. In Drupal’s built-in types, however, each theme function operates on a different set of keys.

Form Preprocessors

In Drupal 7, forms are just a special case of render arrays, but a lot of additional processing is applied to them. In addition to the main theme functions, a set of processor functions can be called first. This allows all sorts of customizations and mischief to occur.

Element Types

Since this is all very complicated and hard to remember, Drupal provides a mechanism for automating much it: the '#type' key. Each type is defined by hook_element_info(), which really just defines a set of default values for the render element.

For example:

Special case: if a render element contains a '#markup' key and no '#type' key, the type is assumed to be 'markup'.

Prefixes and suffixes

Another common set of value keys supported by all render elements is '#prefix' and '#suffix', which insert arbitrary markup around the rendered markup for the render array. These can be used for markup that is otherwise hard to produce using the built-in types, and without the need for a special theme or theme override. However, try to use render arrays to output nested markup where possible, since they are easier to edit, add classes to, etc.

For example, both of these produce the same result, but the first one is easier to override and add classes to:

When rendered as HTML, this produces:

Form fields use a theme wrapper function, theme_form_element(), that also accepts '#field_prefix' and '#field_suffix' as valid keys. This markup appears within spans before and after the form field. However, these are not standard for other types of elements.

Putting it all together

Render arrays are built and converted to markup in the following order:

• '#type' (string): Applies all default values defined in a hook_element_info() implementation. This can add any of the other processor types.
• '#process' (forms only) (array): Applies processing to form elements just after user input has been processed. These are typically used to expand an element into multiple elements.
• '#after_build' (forms only) (array): Applies processing to form elements after child elements have been built and processed.
• '#pre_render' (array): Applies processing to all render elements (inside or outside of forms) before the theme function is called.
• '#theme' (string): Applies a theme function to the element. Each theme function might have its own set of overrides, theme hook suggestions and other modifications.
• '#theme_wrappers' (array): Applies one or more theme functions to the results of the inner theme function. These manipulate the markup in the '#children' key.
• '#post_render' (array): Applies processing to the rendered markup emitted by the theme functions, in the '#children' key.

With the exception of '#type' and '#theme', which take a string, and '#theme_wrappers', which takes an array of strings, all the rest of these keys expect an array of function names. If the function exists, it is called and passed the render element as input.

Here, for example, is a type of element that contains many of these:

Everything must attach to a theme!

In order to show up on a page, every element and nested element of a render array must ultimately be attached to a theme function.

This could be done explictly by setting '#theme' and/or '#theme_wrappers', or implicitly by setting the '#type' or providing '#markup'. Or the element could be used within a theme attached to a parent element. Or the parent element could be used to group its child elements while not rendering any markup itself. But without at least one of these things, a portion of a render array will never actually be rendered. For example:

When rendered, this produces:

Further resources

Each of the features described above performs some special functionality that can appear to be “magic.” In fact, everything behaves in a rational manner; it just might require threading your way through multiple layers of code to understand it.

If you’d like to dig into the functionality, here are the Drupal functions that actually perform the magic:

• form_builder(): processes forms.
• drupal_render(): processes non-form render arrays.
• system_element_info(): a hook that defines the built-in render array types.
  This is your entry point into the built-in types!
• drupal_common_theme(): a hook that defines the built-in theme functions.

In addition, here is a reference to the available keys for all form element types. Unfortunately it does not cover other render types, nor show how these keys are actually used.

However, with this guide, the documentation for system_element_info(), and a lot of patience, you can find out how each of the render types is defined, what they do, and how to use them effectively.

Introducing Dynamics CRM December 2012 service update: Polaris

This week Microsoft officially released the December 2012 service update to Dynamics CRM, known as Polaris. Available both online and on premise, Polaris delivers improved performance and functionality. Accentuating the powerful collaboration tools already present in the system by reworking the user interface, the Dynamics CRM team has also made considerable strides in addressing customer pain points to deliver an even better experience in this latest release. In addition to some crucial bug fixes, Polaris provides robust cross browser support and introduces the new “Flow UI.”

Browser compatibility:

At a first glance, we were impressed with the ability to utilize the software on more platforms than every before. No longer exclusively residing in Internet Explorer, Polaris extends its usability to the popular Firefox and Chrome browsers on Windows systems. The previous lack of Mac OS-X support was a major limitation. Seeking to address this, the latest offers browser support to users running Mac users running Safari version 6 and up.

New interface:

Another notable change delivered in the latest release is the intuitive Flow UI form. The new user experience in these forms mirror the work flows that users take part in when using the system.

In the sales example shown here, forms in Polaris are designed to flow as you move through a specific process. A lead develops to an opportunity as you progress it through the pipeline. As you step through the process, the system presents you with next steps and users can “click to enter” additional data with in-line edit capabilities.

The new user experience forms are delivered on an opt-in basis and the December 2012 update delivers new forms for Leads, Contacts, Accounts, Opportunities and Cases.

Record wall:

One feature that New Signature and many of our clients have found particularly useful in previous versions of Dynamics CRM is the record wall. Recognizing the value of being able to quickly view details related to actions taken on a particular account or opportunity, Polaris puts the record wall front and center on the new forms as shown in the screenshot below.

Added collaboration: Skype

Polaris offers embedded Skype support, allowing better facilitation of conversations between users and customers. With Skype plugged directly into Dynamics, users have one less step to worry about when reaching out to clients and records of calls are automatically entered into the system. In this release, users are required to have Skype installed on their computer in order to use this feature.

What’s next?

As an offshoot of the Polaris release, Microsoft is also deploying two added features in February.

Catering to mobile sales users, the Dynamics team introduces the “iPad Sales Experience,” extending support to iPads in a larger capacity than ever before, including touch functionality, entry grids, and dashboards.

Polaris will soon offer Yammer integration to augment the social feature of the record wall, enabling collaboration with colleagues, as well as potential customers. In order to leverage this functionality, the Dynamics needs to be configured to synchronize with enterprise Yammer licenses.

By February 28^th, both the Yammer integration option and the improved iPad experience will be available globally.

Overall:

The noticeable improvements presented by the Polaris release make Dynamics CRM more approachable and engaging to use, which translates to significantly improved value for our customers. New Signature looks forward to both leveraging the system internally and guiding customers as they explore the new feature sets.

Email crmsales@newsignature.com to get started with a free trial of Dynamics CRM Polaris today!

The Windows 8 App store provides access to tens of thousands of paid and free apps.  However, administrators may be concerned because standard employees who are not local administrators can use the Windows 8 app store to install new applications.  This is a change from previous versions of Windows when a user would normally need to be a member of the local administrators group in order to install software on a workstation.

An app that a user installs from the Windows 8 App store might conflict and cause problems with an essential line of business application already on the workstation, thereby affecting productivity.  In this post we will look at how to prevent this problem by disabling the Windows 8 App store in an Active Directory domain environment by using group policy.

How do I configure the group policy settings?

Create a new Group Policy called “disable Windows 8 app store” and then open it for editing.  Within the editor navigate to the following location:

Computer Configuration => Policies => Administrative Templates => Windows Components => Store

Note that you’ll need to be editing the Group Policy on a Windows 8 computer or a server with the Windows 8 administrative template installed to see the “store” option.  Under “store” you will see three options on the right pane; you should choose the option for “Turn off the Store application” and set it to “Enabled” as shown in the screen shot below:

Once the Group Policy is applied to a workstation, then a user will see the following message if they try to access the App store:

Note that disabling the App store will also disable the updating of any Apps that had already been installed from the App store.  However, in an enterprise environment you would most likely have an alternative method and strategy for keeping applications updated (see below).

As with any Group Policy changes you’ll want to try out the above settings in a test environment before you deploy them to users’ workstations.

What about other software installation routes?

If, as well as disabling the Windows 8 app store, you also need to exert further control over what applications users can run on a workstation then you might benefit from Microsoft AppLocker which comes as part of the Windows 8 Enterprise edition.  Here are some of our recent blog posts on how to get the most out of Microsoft AppLocker:

• Microsoft Applocker – Strategies for implementation:
• http://www.newsignature.com/blog/2013/01/03/microsoft-applocker-strategies-for-implementation/
• Extending AppLocker beyond the workstation:
• http://www.newsignature.com/blog/2013/01/09/extending-applocker-beyond-the-workstation/

What about software that I need to install as network administrator?

When you disable the Windows 8 App store it applies to all users of the computer, so you will need an alternative method for installing applications.  For networks that are too small to use Microsoft System Center products, Microsoft has a very versatile and useful cloud-based service called Microsoft Intune.  As well as providing excellent anti-malware protection to workstations and allowing you to generate inventories and reports, Microsoft Intune also always you to package software and deploy it to workstations.  Because Intune is cloud-based, the workstations it manages do not need to always be attached to the corporate network to receive software that you allocate to them.

What if I have more questions?

New Signature has solid, in-depth experience with Microsoft Intune and with configuring Windows 8, so do please give us a call if you would like to discuss how we can help make the technology work for you.

Exam Ref 70-417 is written for a very specific audience that is already experienced with Windows Server 2008 or 2008R2, but is looking to learn about the new features introduced in Windows Server 2012.  With that in mind, J.C. Mackin has done an excellent job at keeping this book tightly focused only on the new features introduced in Server 2012 rather than write a monolithic book on every single feature in Server 2012.

Given that exam references are usually dry and rather esoteric, Mackin should be commended for putting together a concise and accessible overview of the new features. He lays out a logical course by introducing readers to Windows Server 2012 starting with the brand new Server Manager console and then progressing through the new features including Hyper-V 3.0, Direct Access, IPAM, and NAP, each with dedicated chapters.

The inclusion of practice questions at the end of each section will be especially helpful to those studying for the 70-417 exam. Readers will also be appreciative for the numerous ‘Exam Tip’ sections which highlight commands or features that are likely to be encountered as exam questions. Lastly, Mackin was kind enough to include guidance specific to readers that are familiar with Server 2008 but not Server 2008R2.

In short, readers familiar with Windows Server 2008 or 2008R2 will be well served by this well focused and concise review of the new and updated features in Windows Server 2012. Readers that are new to Windows Server technology will be much better served by 70-410 to learn the basics of Windows Server 2012.

Washington SmartCEO announced this week that Dave Charlton, New Signature’s Chief Operating Officer, is a 2013 Washington SmartCEO Executive Management Award Winner.  The Executive Management Awards (EMA) program recognizes the achievements of Greater Washington’s management all-stars: the Chief Financial Officers, Chief Information Officers, Chief Technology Officers, Chief Operating Officers, and other executive officers.  Winners are recognized for their creative management vision, leadership philosophy, innovative strategy and undeniable work ethic.  The award winners collectively generate over $2.58 billion in annual revenue and employ over 14,400 individuals in Greater Washington.  This year’s winners will be recognized in the March issue of SmartCEO magazine and celebrated at an awards ceremony on March 21, 2013 at The Fillmore in Silver Spring, MD.  ”The 2013 EMA winners are not only taking their companies and co-workers to new heights, but they are also leaders within the communities where we work and live,” says Jaime Nespor, group publisher of SmartCEO magazine, “We are honored to award each of these individuals and tell their stories of their achievements and contributions.”