Our Blog

By Vladimir, a .NET developer on Muranosoft’s team.

The new Microsoft Visual Studio 2010 raises the development of SharePoint projects to an absolutely new level. You won’t need to install any special extensions like those in Visual Studio 2008. Visual Studio 2010 supports all the necessary tools, which really help to improve the development process.

So let’s take a look at the new SharePoint development features that Visual Studio 2010 offers.

New Project Templates

First of all, the VS 2010 supports many different templates for the SharePoint projects, such as:
•    Blank Site Definition
•    Content Type
•    List Definition
•    State Machine Workflow
•    WSP Import
•    Business Data Catalog Model
•    Deployment Module
•    Event Receiver
•    Sequential Workflow
•    Web Part

After selecting any of these templates, you have to go through some steps to configure your development environment, of course.

SharePoint Solution Architecture

Any project type will include two key nodes that you can’t remove, relocate or rename. There are Features and Package nodes. These ones will be available in a project, even if your project doesn’t contain any feature or package definition.

The “Features” node contains all your project features. If you want to add a new feature, just right click on this node and select “Add Feature.” You can use the new Feature Designer tool to manage a corresponding feature.

The “Package” node contains only one *.WSP file, which describes the deployment rules of your SharePoint project. Double clicking on this file affects the Package Designer tool, which allows you to configure all deployment aspects.

In addition to these nodes, the VS 2010 contains the package explorer, which also allows you to manage your SharePoint items. For example, you can group files into features or packages, raise the Features/Packages designer, or move files from one feature or package to another.

Changes in the Server Explorer

Now the Server Explorer supports a new node called SharePoint Connections. This node contains the URL to all your SharePoint sites. You can add the new site by clicking on the SharePoint Connections node, clicking “Add Connection” and entering the URL to the SharePoint site. This will allow you to browse the contents (such as features, lists and sites) and configure the SharePoint server settings.

Development

Some few features are directly linked with a development process.  These include the new Client Object Model, LINQ to SharePoint, Sandboxed Solutions and “External Data Lists.”

• Client Object Model allows us to have direct access to the object model by using JavaScript, Silverlight or .NET code without calling Web Services.
• LINQ to SharePoint provides  an ability to use usual LINQ-queries to manipulate with SharePoint lists. Now we can forget about foreach’es and other redundant code in many cases.
• Sandboxed Solutions allow us to deploy our Web Parts without having an administrative privilege. It was one of the biggest problems in previous versions of the SharePoint environment. This is achieved by running solutions in a separate process that is restricted by .Net CAS policy. So the framework can control solutions and shut down any of them automatically.
• External Lists (formerly known as the Business Data Catalog) is a powerful mechanism to organize collaboration your SharePoint project with other applications or data sources. You should describe an entities structure and link with a data source. After that, you can use received data in your SharePoint project.

Debug and Deploy Process

As you may know, the debug and deploy processes were quite difficult in the previous versions of Visual Studio. The newest one dramatically changes this work, offering us an absolutely new way. Now you shouldn’t deploy your package on the server, deactivate and uninstall all features, retract the solution manually, etc. You shouldn’t install an additional Visual Studio on your SharePoint server, either, just to debug your code.

After configuring your SharePoint solution, you just press the F5 button and the installation of your package will be done automatically, even if an old solution has been installed on the server. All work (deactivating, retracting, etc.) will be done automatically. Amazing, isn’t it?

After installing the new package, the Visual Studio’s debugger will be attached to the Windows SharePoint services process. To enable this, you should run you project in the debug mode (when you first debug, VS suggests to modify your web.config file accordingly). Please note, you could use it on your development side, not on the SharePoint server side!

Resources

If you want to get more information, you can watch this video or follow this link to read the official documentation. There is another great article about new tools for SharePoint development in the VS 2010, written by Steve Fox, senior technical evangelist. Also, I suggest you take a look at the short training courses provided by Channel 9.

Enjoy!

Numerous research reports and analyses have been devoted to the benefits and challenges of using virtual software development teams. The most significant and indisputable benefit of the distributed-development model is the ability to staff your team with the talent of the highest caliber at a much lower price than an on-site team. This is actually the main reason why millions of startups, small companies, midsize businesses  and global tech companies have remote workers within their teams. Additional advantages of virtual teams include a 24-hour development cycle, an increase in productivity and a shorter time-to-market.

While some experts in global software development share their success stories, their opponents complain that the quality of software developed  by a distributed team often suffers from time lags, language and cultural differences, lack of control, and communication problems. The negative impact of the distributed-development model on software quality is one of the most widely spread beliefs in software project management so far. Microsoft’s ESM group (Empirical Software Engineering and Measurement Research Group) members were concerned about the issue and recently decided to run their own study.

In their empirical study, they looked for statistical evidence that components developed by distributed teams resulted in software with more errors than components developed by collocated teams. Guess what? Christian Bird, University of California, Davis; Nagappan Premkumar Devanbu, University of California, Davis; Harald Gall, University of Zurich, and Murphy found that the differences were statistically negligible!

The study measured diverse component characteristics, such as code churn, complexity, dependency information and test code coverage. “Teams that were distributed wrote code that had virtually the same number of post-release failures as those that were collocated,” the report says.

Moreover, the ESM group wanted to verify the results and conducted an anonymous survey, asking engineers if they ran into problems. Most people preferred to talk to someone from their own organization 4,000 miles away, rather than someone only five doors down the hall but from a different organization. Organizational cohesiveness played a bigger role than geographical distance. In other words, if your local and remote team members work in the same management environment and have access to the same resources, you will most likely reap the benefits of your virtual team, rather than face the negative side. That’s why, at Murano, we were always big believers in the dedicated team model where an offshore provider manages administrative and logistical issues while the offshore team becomes a cohesive part of the client’s engineering organization.

By Sergey and Maxim, a Quality Assurance Manager and a .NET Developer on Murano Software’s team.

If you have ever worked with Selenium, you may find XPath a convenient alternative to walking through document trees. In case you are using Firefox, XPath remains an opportune and fast way to find specific elements without walking the DOM manually. Unfortunately, it works tremendously slowly in IE 6 and IE 7. Recently, we faced this problem, and now we’re happy to share our elegant solution with you.

To solve the speed problem in IE, we tried to replace XPath selectors with CSS ones. It gave us a 10x speed up in IE. Impressive, but by using CSS, we lost a very useful feature that XPath offers. In Xpath, we can use the ‘..’ expression to select the parent of the current node. This feature is necessary when you need to click a button next to the element having a particular name in the list of elements. See the sample below.

<table class="style">
    <tr class="somestyle">
        <td>SomeName1</td>
        <td>
            <input type="submit" value="Edit" class="btn" />
        </td>
    </tr>
    <tr class="gvAlternatingRowH35">
        <td>SomeName2</td>
        <td>
            <input type="submit" value="Edit" class="btn" />
        </td>
    </tr>
</table>



All the buttons have the same attributes.  If you want to click the “Edit” button next to SomeName2, you can easily complete this task in selenium by using XPath and its parent feature:

selenium.click("//td[text()='SomeName2']/../td/input[@value='Edit']")



As we mentioned above, this won’t be that easy to do with CSS because it doesn’t have the appropriate feature. So, we used the JQuery parent() function to have the ability to select the parent of the current node. It works really fast in all browsers, since JQuery uses CSS. 

We added  Jquery’s library to the Selenium server (see steps 1 and 2 below) and executed JQuery script directly from Selenium. To execute JQuery script, you can use selenium.getEval(someJS) if you need the return value, or selenium.runScript(someJS) if you don’t.

But that was not enough for us. We wanted to select the parent element by using the easy syntaxes of CSS locators. To use them, we had to add a new custom locator to Selenium. Below, find the three easy steps that we took to add a custom locator.

1. Add Jquery’s library to Selenium server.

Add JQuery’s library (‘jquery.min.js’) to your selenium-server.jar (‘selenium-server.jar\core\scripts\’ folder). To do that, open ‘selenium-server.jar’ by using one of the archives — for example, 7-Zip — and drag-and-drop ‘jquery.min.js’ in the mentioned folder.

2. Add script reference to JQuery library.

Add script reference to ‘jquery.min.js’ to the ‘<head>’ section of the RemoteRunner.html (‘selenium-server.jar\core\’).

<head>
...
<script language="JavaScript" type="text/javascript" src="scripts/jquery.min.js" />
...
<\head>



3. Add new JQuery locator to Selenium core.

You can add a new JQuery locator to the Selenium core in the runSeleniumTest() function of the selenium-remoterunner.js file. All you need to do is to add a call of selenium.doAddLocationStrategy() method before Selenium property initialization of the window object. See the sample below for more details.

function runSeleniumTest() {
    ...
    selenium.doAddLocationStrategy("jquery", "
var loc = locator;
var attr = null;
var isattr = false;
var inx = locator.lastIndexOf('@');

if (inx != -1) {
    loc = locator.substring(0, inx);
    attr = locator.substring(inx + 1);
    isattr = true
}

var selectors = loc.split('<');
var found = $(inDocument);

for (var i = 0; i < selectors.length; i++) {
    if (i > 0) {found = $(found.parents()[0]);
}

if (jQuery.trim(selectors[i]) != '')
    found = found.find(selectors[i]);
}

if (found.length > 0) {
    if (isattr) {
        return found[0].getAttributeNode(attr);
    }
    else {
        return found[0];
    }
}
else {
    return null;
}
    ");
    ...
}



The first parameter of the selenium.doAddLocationStrategy method (“JQuery”) is the new Selenium locator’s name. The second one (“var loc = locator…”) is the new custom Selenium locator. If you want to, you can write your own implementation for the locator. To call the JQuery parent() function, we used the '<' custom symbol . 

Finally, let’s take a look at how you can use the new JQuery locators, instead of the XPath ones.

XPath locators:
•    xpath=//a[contains(@href,'#id1')]
•    xpath=(//table[@class='stylee'])//th[text()='theHeaderText']/../td
•    xpath=//input[@name='name2' and @value='yes']

JQuery locators:
•    jquery= a[href*='#id1']
•    jquery= table[class='stylee'] th:contains('theHeaderText')<td
•    jquery= input[name='name2'][value='yes']

We hope you’ll find our experience useful to you. Also, we’d be happy to answer your questions if you have any!

October 27, 2009 has become a significant date in the cloud battle. Amazon released its answer to SQL Azure offered by Microsoft.  Amazon Web Services is out with a relational database service, the Amazon RDS (Amazon Relational Database). Amazon RDS is a fully MySQL 5.1-compatible database as a service offering and now in beta.

Amazon RDS allows users to select from 5GB to 1TB of associated storage capacity and supports five DB instance classes:
•    Small DB Instance: 1.7 GB memory, 1 ECU (1 virtual core with 1 ECU*)
•    Large DB Instance: 7.5 GB memory, 4 ECUs (2 virtual cores with 2 ECUs each)
•    Extra Large DB Instance: 15 GB of memory, 8 ECUs (4 virtual cores with 2 ECUs each)
•    Double Extra Large DB Instance: 34 GB of memory, 13 ECUs (4 virtual cores with 3,25 ECUs each)
•    Quadruple Extra Large DB Instance: 68 GB of memory, 26 ECUs (8 virtual cores with 3.25 ECUs each)

* One ECU provides the equivalent CPU capacity of a 1.0-1.2 GHz 2007 Opteron or 2007 Xeon processor.

Now let’s look at each of them closer and examine them by feature:

* Windows Azure is currently in Community Technology Preview (CTP), and the services are free to evaluate through January 2010.