Software Development

Setting up Git as your Version Control System

Wed, 09 May 2012 20:21:00 GMT

Version control is an essential task to be performed not only on coding projects but also in any creative process such as writing or designing, and becomes even more important when it is a collaborative process. Git is a Distributed Version Control System that has become very popular not only in Open Source projects, but also in many other types of coding projects. Its versatility and processing speed are turning it into a must-have tool in web development. However, its documentation (as with any other software tool) can be rather difficult, even obscure at times, to read and assimilate.

The first step is to install Git. You can get the installer for your operating system at Git’s homepage. If you are on Windows, the .exe installer will give you a couple of options and will install several tools as the Git Bash. The Git Bash is a command prompt to run Git that can run other Unix commands as well.

In Mac OSX, if you have installed Xcode, then you already have Git. If not, there are some .dmg files on Git’s homepage corresponding to the latest versions of OSX. With this installed, you are ready to start tracking versions of your local projects’ files

To start doing this, just go to directory where your files to be tracked reside, using the bash in OSX or the Git Bash in Windows, and type the following command:

git init
The command prompt should respond with a confirmation message like the following:

Initialized empty Git repository in /path/to/your/project/.git/
This will create a hidden .git folder that will be used to keep track of changes in your directory.
Then just add the folders and files you want to track and, when ready to do your first commit, return to the bash and use the following command:

git status
This will output a list of current changes such as untracked files, modified files and deleted files.
You can then add the changes you want to commit to your staging area, also called index, by using the command:

git add file1 file2 file3
Then you can effectively create a new revision of your folder by committing what’s on the index:

git commit –m “This is a message summarizing the contents of this commit”
Then you can check the history of your project by using the following command:

git log
The output should be something like this:
- commit 3692dff96ec63a66b379a4fa90c08de45f7dfa4f
- Author: dvergara <dvergara@oshyn.com>
- Date: Mon Feb 6 19:33:50 2012 -0500
- Third version, second on this branch
- commit a84128fbab6e5cb791660b082bb0a38ab46987ab
- Author: dvergara <dvergara@oshyn.com>
- Date: Mon Feb 6 18:24:48 2012 -0500
- version 2
- commit 4acb6bf8f245dfa471ea1a4cdb176941aa798494
- Author: dvergara <dvergara@oshyn.com>
- Date: Mon Feb 6 18:07:00 2012 -0500
- Initial Commit
Finally, you can see the commit key in case you want to change to a different revision. Let’s say we want to go back to the first commit. We need to execute:
git checkout 4acb6bf8f245dfa471ea1a4cdb176941aa798494

Note that I’m using the SHA1 key of the first commit as its identifier. It also works with just the initial characters of the string. Now we are on the state of the initial commit of out project. There we can perform changes and create a new commit, or just get back to the latest commit with the following command:

git checkout master

These few steps are the basics of what you need to know to start working with Git. In a future post, I will explain more about one of Git’s most interesting features: branches. Play around with them and start leveraging the advantages of this versioning system on your next project.

Version Control Systems: Distributed vs. Centralized

Wed, 09 May 2012 20:19:00 GMT

One fundamental tool in any software project is a Version Control System (VCS). A VCS helps you keep track of features, bug tickets, and any other changes in your project. It is also very helpful to keep backed-up versions of your work just in case anything goes wrong. There are quite a lot of tools available to meet this need, including: Perforce, Mercurial, SVN, Git, CVS, etc. and they can be classified into two classes:

Distributed VCS: Git, Mercurial.
Centralized VCS: CVS, Perforce, SVN.

The main difference between the two classes is that Centralized VCSs keep the history of changes on a central server from which everyone requests the latest version of the work and pushes the latest changes to. This means that everyone sharing the server also shares everyone’s work. Sourceforge.net uses this type of versioning in their projects.

On the other hand, on a Distributed VCS, everyone has a local copy of the entire work’s history. This means that it is not necessary to be online to change revisions or add changes to the work. “Distributed” comes from the fact that there isn’t a central entity in charge of the work’s history, so that anyone can sync with any other team member. This helps avoid failure due to a crash of the central versioning server. Open source projects, such as Mozilla Firefox, tend to use this type of versioning.

After having worked with both of these systems (SVN and Git) my personal impression is that there is not such thing as a clearly superior system. On one hand, a Centralized VCS allows more access control via folder permissions or by allowing checkout of just the needed sub tree from the repository tree. Also these systems are more prone to be backed up regularly, allowing for a more reliable environment of work. The quantity of development tools and Integrated Development Environments (IDEs) integrating with them is considerable. On the other side, a Distributed VCS, like Git, is considerably faster and easier to work with when it comes to creating and merging branches and tags. Also, they allow for flexible workflows, tailored to one’s project and team needs.

However, both systems have room for improvement. Tools like SVN are slow when it comes to process transactions and working with tags and branches can be very tricky as well. Also, when someone on the team checks-in buggy code that takes down the project’s application, the whole team’s work is potentially affected since everyone has to have the same codebase.

However, a Distributed VCS, on the other hand, doesn’t allow for partial check out of the repository. Also, integration with many IDEs and other development tools (like file comparers) are not yet the rule nowadays and, since there are little repository managers with a Graphical User Interface for Distributed VCSs, it can be very hard in the beginning to be efficient and proficient with this type of Distributed VCSs.

There are some other factors to consider before choosing a VCS like the workflow you’ll be using, available hardware, etc. However, the current trend is to switch to Distributed VCSs to manage coding projects since VCSs like SVN are growing obsolete quickly. Try Git on your next project (not only coding project, it can be any type of collaborative project like a book or a paper) and you will realize the great advantages this system provides.

Jira new plugin: Bonfire for Agile Testing

Wed, 09 Nov 2011 22:57:00 GMT

At the Atlassian Summit 2011, Andrew Prentice, Atlassian QA Manager, presented a new Jira plugin that allows for more efficient reporting of bugs. As discussed in my previous post, in projects using the Agile model bugs need to be reported as soon as possible. Any tool that helps you to accomplish this, will be very useful for testers.

When reporting an issue you need to provide the most details possible so developers are able to reproduce them; for example, when testing a web application you usually provide this information: browser and platform where you find the bug, URL, screenshots. Not all bugs need screenshots, but a screenshot can help developers to see the problem and can provide useful information in the future. The disadvantage of providing more details when reporting a bug is that it takes time. In the Atlassian Conference, Prentice emphasized the idea, “Agile Testing, it’s about time.” He also mentioned that testers spent 16% of their time reporting bugs. That is a lot of time, especially in Agile development where time is critical.

To enhance the process of testing and reporting issues, Atlassian offers the following features in the new Jira plugin:

1. Fastest way to create bugs with screenshots
2. Create issue templates with dynamic content
3. Build test sessions and assign them to Jira tasks
4. Track time of test sessions

How to install Bonfire:

This plugin is installed in Jira server and then each user needs to install browser extensions. Currently you can get Bonfire free, for 30 days. To install Bonfire in Jira server, you have to follow the steps outlined here: http://confluence.atlassian.com/display/BONFIRE/Bonfire+Installation+Guide

After installing it, you have to get a license (even for the free trial), just follow these steps:

If you don’t already have one, create an account in https://my.atlassian.com

Login in Atlassian and go to “New Evaluation License”
Select the product “Bonfire” and copy the license text
Click on “Generate License”
Copy the license text
Go to Jira > Administration> Plugins
In the left side menu, click on “Bonfire License”
Paste license and click on “Add”

Now that Bonfire is installed in the Jira Server, testers or anyone on the team can download the browser extensions to start reporting issues. Browser extensions are supported in these browsers: Internet Explorer, Firefox, Chrome and Safari (Bonfire User Guide, 2011).

How to use Bonfire:

I prepared a video to show Bonfire features, it contains the following sections:

Install Bonfire browser extension in Chrome
Create a test session for a Jira task
- For the task, “Testing Oshyn’s site”, I will create the test session “Testing Blog posts”
- Create a template with variables
  - I will create two variables: “platform” and “lastDateModified”
  - Template will contain a description with dynamic content
  - Create an issue using the template and adding a screenshot
  - End the test session and log the time spent testing
  - Check all the test sessions of the task “Testing Oshyn’s site”

What are the Advantages of using Bonfire?

The two Bonfire features that allow testers to save time are: creation of templates and attaching screenshots directly from the browsers. Usually when reporting bugs, you need to select the same bug properties many times (like Affects version, Fix version, Assignee, Priority, etc.). With Bonfire, you can just select a template and all the repeated fields will be pre-populated. Additionally, Bonfire allows you to use JavaScript variables in your templates, so you can have dynamic information in your bugs. You can add variables depending on your needs; for example, in the video I added a variable to get the user’s platform. Creating an issue with a Bonfire template saves you time and adding a screenshot is very simple and quick. You don’t need to use a graphic tool to crop, blur, put an arrow or text to show the bug; you can just use the Bonfire toolbar in the same browser window.

Test sessions is another useful feature; not only for testers but also for the whole team. Testers and developers can check issues reported when testing a particular area of the product and Project managers can verify the time spent in a test session.

Bonfire is a great way to save time when reporting bugs and allows organizing testing activities in your Jira Project.

References:

Bonfire User Guide: http://confluence.atlassian.com/display/BONFIRE/Bonfire+User+Guide

Agile Testing: It's about time - Atlassian Summit 2011: http://www.youtube.com/watch?v=dYFzeh

Bonfire for Jira: http://www.atlassian.com/en/software/bonfire/video

Google App Inventor: An Android Mobile App Developer for Everyone

Wed, 09 Nov 2011 22:57:00 GMT

Google has launched the application "Google App Inventor" aimed towards people of all backgrounds, ages, and experience levels in computer programing. To achieve this goal, Google offers a graphical interface that allows the user to experiment creating a fully-functional Android app, for a mobile device running the Android platform, by snapping together visual programing blocks.

Now all you need to build an Android application to be used on a mobile device is access to a computer and an internet connection. The App Inventor is a simple but powerful web application. A Google account is needed to use it.

App Inventor provides access to all the mobile device features so you can create your own applications to solve aspects from your personal life, home, school, or work, instead of being limited to the apps available in the Android Market.

It could be used as a great tool for education; allowing teachers to easily create educational software to help students prepare for a test or aid students with disabilities using features like TextToSpeech or Media Player.

In the future, I hope to see Google develop some kind of training program that is more in-depth than its current online tutorial system for App Inventor. This way, more users could take advantage of it, thus turning it into a widespread educational tool.

Watch an app being built using App Inventor
http://www.youtube.com/watch?v=8ADwPLSFeY8

More information is available here:
App Inventor for Android: http://appinventor.googlelabs.com/about/

Reference:
http://en.wikipedia.org/wiki/App_inventor#External_links
http://blog.wareseeker.com/all/iphoneapps/google-app-inventor-with-writing-applications-for-android/
http://www.techpoweredmath.com/android-app-inventor-education/
http://www.linuxinsider.com/story/Googles-Android-App-Inventor-Help-or-Hindrance-70397.html?wlc=1290803058
http://www.appinventor.org/what-you-can-do-with-app-inventor

Agile Testing and Test Management

Wed, 09 Nov 2011 22:58:00 GMT

Recently, I attended to a webinar called “Where Agile Testing and Test Management Collide” http://www.pushtotest.com/agile-testing-test-management, that mainly focused on two tools for Test Management and testing: Zephyr and TestMaker. Basically, Zephyr is Test Management software and TestMaker is a tool for performance and automated testing (the demo of these two products took most of the time of the webinar, my opinion is that it was missing more information about how Agile Testing is performed).

In this post I will first analyze what Agile software development is, how testing in this model is achieved, and what features are needed in a Test management tool.

Agile Testing basically adapts to Agile software development. If you do a search for Agile development you will find the “Agile Manifesto”, written by a group of developers in 2001. According to the Manifesto, there are 12 principles of the model:

10.

11.

12.

Agile Manifesto

In the Agile model, a project is divided in iterations that include: analysis, design, development, testing and acceptance testing when the product is demonstrated to stakeholders. Each one can last up to four weeks. The measure of progress is working software, so the goal of each is to have an available release with the minimum amount of bugs. At the end of each iteration, stakeholders and a customer representative need to review the progress and redefine the priorities of the project. (Wikipedia – Agile Model )

In Agile development, a project needs to adapt to changes quickly, there is not enough time for detailed documentation. When developers find questions, a customer representative needs to be available to respond and stakeholders need to produce documentation as required. As principle #6 in the manifesto mentions, face-to-face conversation is the most efficient way to obtain information; this applies to communication with the client as well as within the team. In Agile projects, there is usually a quick, daily meeting attended by the whole team, a customer representative and any other stakeholder. During these meetings, each member reports what they did the day before, develops the plan for the current day and reports any blocker. (Wikipedia – Agile Model )

In an Agile model, the testing team needs to adapt to a rapid development cycle, test with a customer perspective and have a constant communication with the whole team. Testers need to provide testing results as soon as possible so the developers can resolve any bugs; thus producing the least number of bugs at the end of an iteration. As mentioned before, in the Agile model communication is essential; therefore, the testing team needs to have a good relationship with the developers.

In Agile development, the test manager needs to ensure that the testing team is reporting issues, communicating these issues to the development team and giving daily reports about critical issues. See the testing cycle in the following graphic:

(Zephyr)

In this scenario, a test management tool ideally needs to have the following features:

Divide testing into Releases/Iterations
Link test cases with requirements
Assign test cases to testers
Create, edit and reuse test cases
Link test cases with bugs
Reporting
Allow sharing of the results with the whole team

These features will help the Test Manager to adapt testing to a rapid development cycle and to keep the team updated with the current status of the project. In an Agile model, “the measure of success is working software”, so it is very important that the Test Management tool helps to keep the team informed about critical issues in each iteration.

Finally, I feel that a good Test Management tool is very helpful in Agile Software development; however, the Test Manager should never lose attention of the other aspects, like testing with end-user perspective and having good relationships with developers and clients, needed to achieve a collaborative and successful project.

References

Agile Alliance: http://www.agilealliance.org/

Agile Manifesto: http://agilemanifesto.org/

Wikipedia Agile Sofware Development: http://en.wikipedia.org/wiki/Agile_software_development

Wikipedia Agile Testing: http://en.wikipedia.org/wiki/Agile_testing

Manage Agile Testing Methodology Effectively with Zephyr: http://www.getzephyr.com/resources/zephyr_qa_methodologies.php

.Net Source Code Quality Tools – Part 3: Analyzing Code

Wed, 09 Nov 2011 22:58:00 GMT

Analyzing Code

(Continued from Part 2)

There are several tools that allow Hudson to collect output from quality metric rules and then show them for every build and then the results can displayed in a trend graph.

When building a .Net Project, is recommended to use FxCop. This is a free static analysis tool from Microsoft that allows analyzing managed code assemblies against more than 200 different possible coding standards violations in the following areas:

Correctness
Library design
Internationalization and localization
Naming conventions
Performance
Security

Many of the issues concern violations of the programming and design rules set forth in the Design Guidelines, which are the Microsoft guidelines for writing robust and easily maintainable code by using the .NET Framework.

This tool could be useful to developers to adapt them and get used to the .Net Framework development best practices and coding standards.

To install this tool, you have to go to the Microsoft Windows SDK folder, generally located at “%ProgramFiles%\Microsoft SDKs\Windows\v7.0A” and find the “FxCop” folder that contains the installer.

Once installed, this tool offers both, graphical and command line interfaces, this last one is the one we will use as part of the automated build process.

Configuring FxCop in Hudson

Go to the project “Configure” page and under the Build section click the “Add build step” button and select “Execute Windows batch command”.

Fill in the “command” filed with the command parameters depending on how you like to execute the tool, as:

"%ProgramFiles%\Microsoft FxCop 1.36\FxCopCmd.exe" /file:"HudsonQualityTools\bin\Release\*.dll" /out:fxcop-result.xml /console

More information about the FxCopCmd and its parameters visit Using FxCopCmd.

This command will execute the FxCopCmd command and check the .dll files found in the “Release” folder. Besides it will record the results in a file named “fxcop-resul.xml” and display those results in the console.

To finish, check the “Report Violations” check box under the “Post-build Actions” and set the fxcop field to: “fxcop-result.xml”.

Save the changes and build the solution. Then check the Build to get a summary and check the state of the solution.

And then click on the graphic to get a more detailed version of the solution analyzed by FxCop.

To step into the reported violations, click on any of the files listed on the lower part of the site.

And there we will have access to the violations and the codes where it has occurred.

We can integrate Hudson to show those issues into an issue tracking solution as JIRA by installing the plug-in from the “Plugin Manager” and configuring it on the “Manage Hudson” menu option.

This allows the submitter and watchers to quickly find out which build they need to pick up to get the fix. Besides hudson can update JIRA issues with backpointers to builds by cheching the “Update relevant JIRA issues” check box under the “Post-build Actions” in the “Configure” section.

In conclusion there are several good tools in store to ensure the .Net source code quality along the entire software development process, and Hudson is one of them, having a vast variety of easy to install and use plug-ins to automate tasks and make the development process more efficient. As shown above, it does not take too much configuring effort to start building a project using Hudson. The best approach to measure the source code quality is to start building the project, and then focus on running unit tests and other quality metrics so you can monitor the quality progress on your project.

Using WMDRM on your Application – Part 2

Wed, 09 Nov 2011 23:21:00 GMT

Getting data form your device using WMDRM API

To initialize a WMDRM interface, the application calls CoCreateInstance to obtain an instance of IWMDRMDeviceApp or IWMDRMDeviceApp2 for the extended DRM queries, as shown in the following example:

hr = CoCreateInstance(CLSID_WMDRMDeviceApp,

NULL,

CLSCTX_INPROC_SERVER,

IID_IWMDMDeviceApp2,

(void**)ppWMDRMDeviceApp2);

if (hr != S_OK)

{

printf ("! Failed to CoCreate IWMDRMDeviceApp2\n");

}

The next step is to obtain an IWMDMDevice instance to use as an input parameter for the IWMDRMDeviceApp and IWMDRMDeviceApp2 methods.

The process of deriving the WPD device instance is covered in detail by the WPD Sample Application in the Windows SDK and MSDN® documentation and will not be repeated here.

Each WPD device is identified by a unique Plug and Play Device Identifier (PnPDeviceID) string. Similarly, each WMDM device is also identified by a unique string known as the WMDM canonical name. If the two strings can be correlated for a given WPD MTP device, a matching IWMDMDevice instance can be retrieved from the list of enumerated WMDM devices.

To associate the PnPDeviceID string of a WPD device with its WMDM canonical name we have to follow the next steps:

1.) Replace the device interface globally unique identifier (GUID) with the WMDM interface GUID for the current WPD PnPDeviceID.

// Step 1: Converting a WPD PnP Device ID to a WMDM PnP Device ID

// (Error checking is omitted for brevity)

hr = pIPortableDevice->GetPnPDeviceID(&pszPnPDeviceID);

CAtlStringW strWMDMPnPID = pszPnPDeviceID;

// Truncate the WPD interface GUID

int pos = strCurrentWMDMPnPID.ReverseFind(L'{');

strWMDMPnPID = strWMDMPnPID.Left(pos);

// Append the WMDM interface GUID

strWMDMPnPID += L"{f33fdc04-d1ac-4e8e-9a30-19bbd4b108ae}";

2.) Enumerate devices by using the WMDM API and get the canonical name for each. Convert the canonical name to a WMDM PnPDeviceID.

// Step 2: Enumerating the WMDM Canonical Names

// (Error checking is omitted for brevity)

hr = pWMDeviceManager2->EnumDevices2(&pWMDMEnumDevice);

if (hr == S_OK)
{
IWMDMDevice* pWMDMDevice = NULL;

ULONG ulFetched = 0;

// Traverse the list of enumerated WMDM devices

while(pWMDMEnumDevice->Next(1, &pWMDMDevice, &ulFetched) == S_OK)

{

WCHAR wszCanonicalName[MAX_PATH] = {0};

IWMDMDevice2* pWMDMDevice2 = NULL;

hr = pWMDMDevice->QueryInterface(IID_PPV_ARGS(&pWMDMDevice2));

// Get the canonical name for the current WMDM device

hr = pWMDMDevice2->GetCanonicalName(wszCanonicalName,

ARRAYSIZE(wszCanonicalName);

CAtlStringW strTestPnPID = wszCanonicalName;

// Truncate the WMDM virtual device index

int pos = strTestPnPID.ReverseFind(L'$')

strTestPnPID = strTestPnPID.Left(pos);

// Do Step 3 here …

}

3.) Call IPortableDevice::Open on the WMDM PnPDeviceID obtained from enumerating the WMDM canonical names to get the PnPDeviceID.

Although the PnPDeviceID returned from IPortableDevice::GetPnPDeviceID is the same literal string as the original WMDM PnPDeviceID from Step 1, this test “closes the loop” by ensuring that both WPD and WMDM can access the same WMDM device identifiers.

// Step 3: Verify that the WMDM Device ID converted from the

// Canonical Name can be accessed by WPD

// (Error checking is omitted for brevity)

IPortableDevice* pPortableDeviceTest = NULL;

IPortableDeviceValues* pClientInfo = NULL;

LPWSTR pszWPDPnPDeviceID = NULL;

// CoCreate a new instance of IPortableDevice (not shown) …

// CoCreate and populate client information (not shown) …

hr = pIPortableDeviceTest->Open(strTestPnPID, pClientInfo);

if (hr == S_OK)

{

hr = pIPortableDeviceTest->GetPnPDeviceID(&pszWPDPnPDeviceID);

// Compare the result with our WMDM PnP ID

if (strWMDMPnPID.CompareNoCase(pszWPDPnPDeviceID) == 0)

{

// Found a matching IWMDMDevice instance

}

4.) Now that you have found the IWMDMDevice pointer that has the correct canonical name, you can use that IWMDMDevice as the input parameter to call IWMDRMDeviceApp or IWMDRMDeviceApp2 methods on that device.

For example, the following code snippet queries if the current device supports WMDRM:

hr = pWMDRMDeviceApp2->QueryDeviceStatus2(pWMDMDevice,

WMDRM_QUERY_DEVICE_ISWMDRM,&dwStatus);

if (hr == S_OK)

{

bool bSupportsWMDRM = (dwStatus > 0)?true:false;

}

.Net Source Code Quality Tools – Part 2: Configuring the Build

Wed, 09 Nov 2011 23:21:00 GMT

Configuring the Build

(Continued from Part 1)

The next step is to build the solution using MSBuild. We can use any other plug-in we want to achieve this goal.

First of all, we have to set-up the plug-in so we can select the path where the .Net Framework is located. We will build this project using the .Net Framework 4.

In “Configure System” page, localize the “MSBuild Builder” section and set the name and the path to “MSBuild.exe” where this tool has been installed:

Name: “MSBuild .Net Framework 4”

Path to MSBuild.exe: “C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe”

After this, go to the “Configure” page in the project’s main menu and under the Build section, click on the “Add build step” button and then select “Build a Visual Studio project or Solution using MSBuild”.

MSBuild Version: “MSBuild .Net Framework 4”

MSBuild Build File: “HudsonQualityTools.sln”. This is the name of the solution file we want to build.

Command Line Arguments: “/p:Configuration=Release”. The parameters we want to use to build this solution. To read more information, go to MSBuild Command Line Reference.

To test those configurations, save the settings and build the solution. While the build is running you can check the console log that is updated as the build goes on.

Using WMDRM on your Application – Part 1

Wed, 09 Nov 2011 23:23:00 GMT

Using WMDRM on your Application – Part 1

Windows Media DRM (WMDRM) is a Digital Rights Management service for the Windows Media Platform, it’s used to manage multimedia files in a way that the distributor can control how that content is used. The content delivered with the WMDRM encryption is not universally accessible but limited to those users running Microsoft Windows.

This service supports portable media players running Media Transfer Protocol (MTP) that implement WMDRM-PD.

To create a Windows Portable Devices application, you must have the Windows Software Development Kit (SDK) installed on your computer.

The SDK provides the following interfaces for devices that support Windows Media Digital Rights Management 10 for Portable Devices (WMDRM-PD):

IWMDRMDeviceApp, which enables an application to meter, synchronize licenses, and update DRM components on the device
IWMDRMDeviceApp2, which extends IWMDRMDeviceApp and enables an application to query a specific DRM status or capability on the device.

The WMDRM API offers a sample application we can use to work and interact with portable devices. To build this application we need to complete the next steps:

Install the Microsoft Windows SDK for Windows Vista (or superior)
Install the Windows Media Format SDK version 11 (or greater)

The console application has the following files we can use to modify and customize according to what we want to achieve:

WpdApiDrmSample.vcproj: This is the main project file for VC++ projects generated using an Application Wizard. It contains information about the version of Visual C++ that generated the file, and information about the platforms, configurations, and project features selected with the Application Wizard.
WpdApiDrmSample.cpp: This is the main application source file.
DeviceEnumeration.cpp: This file contains examples of how to enumerate portable devices.
ContentEnumeration.cpp: This file contains examples of how to enumerate content on a portable device.
ContentTransfer.cpp: This file contains examples of how to transfer content to a portable device.
WmdmEnumeration.cpp: This file contains examples of how to initialize WMDM on a portable device that supports WMDM.
WmdrmDeviceApp.cpp: This file contains examples of how to call IWMDRMDeviceApp methods on a portable device.
WMDMProgress.h: This file contains an example implementation of IWMDMProgress3, used when updating the device's secure clock
AppKey.h, AppKey.cpp: These files define the application certificate and key used for protected content transfers. To authenticate your application, modify AppKey.cpp to set your application's private key and certificate values obtained from Windows Media Licensing.

.Net Source Code Quality Tools – Part 1: Setup

Wed, 09 Nov 2011 23:23:00 GMT

Setup

Software quality is strongly connected with the source code quality. Coding standards may be very helpful in order to assure the high quality of the code, especially that they are supported by many applications tools. Now we are going to review some tools for checking the .Net source files.

As we are talking about .Net technologies, our first option would be to talk the Visual Studio Team Foundation System, due to its integration with the visual studio IDE and its flexibility managing and tracking the development activities across multiple branches. It allows to set-up a distributed and automated build process that quickly validates that every code check-in maintains product quality before the changes are committed to the sources repository.

Besides we have some other open source options we could use to ensure the code quality, the advantages of this approach are that we have a good cohesion with .Net tools and that we can use those tools for free.

There are different tools to work at any level of the development life cycle, due to our environment configuration we will use a Hudson’s plug-ins to check the code and get reports about the reported issues. Our Hudson environment is going to be configured to achieve the following goals:

Get the source code from the Subversion repository.
Build the project using MSBuild.
Execute FxCop on an assembly and show warnings and a trend graph.

Download plug-ins

To get the Hudson plug-ins we use in this document and some more, please visit those URLs:

http://hudson-ci.org/download/plugins/

http://download.hudson-labs.org/plugins/

https://wiki.jenkins-ci.org/display/JENKINS/Plugins#Plugins-Buildtools

Plug-ins Installation

Once we have downloaded the plug-ins, the next step is to upload the .hpi files to install the plug-ins from outside the central plug in repository from the “Advanced” tab in “Manage Plugins” in the “Manage Hudson” main menu option. Then restart Hudson and the plug-ins are ready be configured and work.

Setting up the Source Code Management

I have created a console solution in visual studio and uploaded it to SourceForge. Hudson supports CVS and SVN out of the box, but there are many other plug-ins we can use. After checking out the files from the repository, Hudson will show the new change sets since the previous build in the Build page. The Changes page contains a detailed view of changes sets such as the developer name, comments and the files that were changed.

To configure we have to access to the “Configure” page located in the project’s main menu.

Under the Source Code Management section, select Subversion option.

Set the “Repository URL” field, in this example: “https://sourcequality.svn.sourceforge.net/svnroot/sourcequality/HudsonQualityTools/trunk”
Set the “Local Module Directory” to: “.”.
Set the repository browser to its default option: “Auto”.

To test that this configuration is correct, save the changes and build the solution. The source code will be downloaded from the repository and then located into the Workspace. Accessing to the “Workspace” page, we can measure that the files had been checked out.

ClickOnce Deployment - Creating a Custom Installer

Wed, 09 Nov 2011 23:24:00 GMT

ClickOnce is a Microsoft technology that lets you easily deploy and update your Windows application, weather it is a Windows Forms, Windows Presentation Foundation (WPF), Console application or an Office solution (VSTO).

The application can be deployed using 3 different ways: from a Web Page, from a Network File Share or from media such as CD-ROM.

There is plenty documentation and examples out there that show you how to deploy an application using ClickOnce. In this blog I am going to show you how to create a custom installer for a ClickOnce application.

A custom installer could be required in case we need to provide custom user experience to our default ClickOnce installation process. Custom logic may include among others, system requirements checks, license agreement screen, customs messages, etc.

In order to facilitate this, Microsoft has provided us with the System.Deployment.Application namespace which contains classes that let us customize the install and update behaviors in our ClickOnce application.

The following steps will show you how to create a Custom Installer that installs an already existing ClickOnce application. Make sure you have a ClickOnce application deployed to either a web server location or a network share. If not, please look here for instructions on how to do it.

1. Create a Windows Forms or WPF application and specify a name for it. I am using a Windows Forms application named ClickOnceCustomInstaller for this tutorial.
2. Place a Label, a ProgressBar Control and a Button on the default form. Set the Modifiers property of the Label and ProgressBar to Public, so you can access them from the custom installer class logic added in the following steps.

3. Add references to System.Deployment and System.Windows.Forms if needed.
4. Add the following class to your project CustomInstaller.cs. This class handles the logic to install the application. It uses various methods in the InPlaceHostingManager which belongs to the System.Deployment.Application namespace mentioned above.
5. Now let’s add some logic to invoke the installation process from our form. Use the following code for the button’s click event.

private void button1_Click(object sender, EventArgs e)
{
    const string deployManifestUri =
    "http://localhost/ClickOnceDemoApp/ClickOnceDemoApp.application";
    CustomInstaller installer = new CustomInstaller();
    installer.InstallApplication(deployManifestUri);
}

In the code above the variable deployManifestUri represents the Uniform Resource Identifier (URI) to the deployment manifest of the application that will be installed or in other words the location of the manifest where the ClickOnce application was deployed to.

6. Run the application and click the Install button.
The application will be downloaded from the server and installed on the local machine. You will see the following screen.

The application has been installed on your computer and you can now run the application from the Start menu link, or the desktop shortcut if one has been created.

If you try to run the installer again, you will get the following message.

So now you can use this as your starter code to build your own Custom Installer, adding the forms and related logic needed for your application.

Also, please note that you can use the same ClickOnce Deployment API to override the default update behavior and check for updates using your own custom logic.

Build Automation for Windows Presentation Framework (WPF) and Silverlight Applications

Wed, 09 Nov 2011 23:24:00 GMT

In this post, I want to share a way to do automated builds for Microsoft WPF Applications. The idea is to easily compile and deploy this type of application when the same code needs to be deployed to different environments, but applying different configuration files depending on the environment. For this technique I am going to use NAnt and the .NET framework 4.0.

Suppose that you have a .NET application and you want to deploy the same code to different environments. The difference between deploying to one environment and another is the configuration files that need to be applied. So in this case, the app.config file values changes according to which environment deploy. Consider that your configuration file have an entry like:

<add key="serverUri" value="http://www.integration.com"/>

Where the value of “serverUri ” needs to change according to which environment is under compilation. To archive that we need to create a parameterized NANT script that receives as a parameter which environment to compile and applies the desired configuration file.

The first thing that I suggest is to create a Configuration Manager structure inside your code versioning. So suppose that your project code is on svn in the location:

trunk\Code\<Project Name>

In your versioning repository you should create a folder structure like:

trunk\ConfigurationManagement\BuildFiles\ (Put here the nant scripts)
trunk\ConfigurationManagement\Environments\<Project Name>\app.format.config
trunk\ConfigurationManagement\Environments\<Project Name>\Integration\ EnvBuild.property
trunk\ConfigurationManagement\Environments\<Project Name>\QA\ EnvBuild.property
trunk\ConfigurationManagement\Environments\<Project Name>\Production\ EnvBuild.property

Where app.format.config is the configuration file of the application, and it contains tokens like:
<add key="serverUri" value="http://${dnsServer}"/>.

The value of “serverUri” is defined inside each property file EnvBuild.property and this value changes according to which environment is under compilation. So each EnvBuild.property file contains the entries respectively:
<property name="dnsServer" value="integration.oshyn.com" />
<property name="dnsServer" value="qa.oshyn.com" />
<property name="dnsServer" value="production.oshyn.com" />

In order to do that here is a very simple example of a NAnt script that needs to be located inside the folder trunk\ConfigurationManagement\BuildFiles\default.build.

Click here to get the build sample File

The following command should be used to execute the NAnt script from cmd:

nant -buildfile:default.build -D:ftpserver=ftp.host.com -D:ftpuser=user -D:ftppass=password -D:ftpdestinationprefix=/PublishedApplication "-D:ftpsourceprefix=c:\installer" -D:project.name=Player -D:propertyfile=EnvBuild.property -D:sourcefile=app.format.config -D:environmenttag=QA -D:destinationfile=app.config ftpdeploy

Important Components Requirements:
1)   You need to have installed and configured NAnt in order to build your .NET 4.0 projects. Check http://nant.sourceforge.net/.
2)   You need to install and configure NAntContrib in order to do some operation on your scripts like loadtasks, msbuild, etc… Check http://nantcontrib.sourceforge.net/
3)   For the FTP deployments, you need to you use NAnt Task http://www.spinthemoose.com/~ftptask/.
4)    The machine that is going to compile the .NET application needs to have all the necessary .NET components required for the compilation like the .NET framework, etc.

Important Notes about the Sample NAnt Script
1)   The NAnt Settings section provides information of the NAnt task to include like the FTPTask and NAntContrib. Also it sets the target .NET framework version.
2)   To define a property in a scrip you can use
<property name="project.name" value="invalid.project" overwrite="false"/>, the overwrite=false shows that if that property were not defined upper or was not passed as parameter like -D:project.name=Player, the value assigned is going to be invalid.project.
3)   The target “build” has a dependency of the target “configMerge” in charge of the replacements of the tokens defined on the EnvBuild.property files into the app.format.config according to the property “environmenttag”. That dependency means that first is going to be executed the target “configMerge” and then the target “build”. Target build is executed by default if you do not specify any target at the moment of the execution of the NAnt script.
4)   Inside the msbuild task, the example is performing a ClickOnce compilation. For more details check http://msdn.microsoft.com/en-us/library/ms165431%28v=vs.80%29.aspx.
5)   The target “ftpdeploy” have a dependency to the target “build” that means that the target “configMerge”, “build” are going to be executed before the target “ftpdeploy”.

As I exposed here, this is an example of how to automate deployments for WPF applications. Notice that this script sample receives the parameter environmenttag to decide which configuration file to apply and deploy. In order to automate the execution of NAnt commands you can create .bat files that download the latest code using a svn client and execute the NAnt command.

Mac OS X iTunes Development - Easy Cocoa Integration with iTunes

Wed, 06 Oct 2010 02:09:00 GMT

You CAN integrate your mac application with iTunes, this post assumes you have basic knowledge of Objective-C. The Cocoa frameworks makes it very easy to add animations, link an action to a button, play videos, audio files and much more. You can use the QTKit framework to embed a QuickTime player in your application, but when it comes to iTunes integration, there is no framework to play with like there is for QuickTime. Nevertheless, that doesn’t mean you can’t integrate your app with iTunes. The solution is AppleScripts.

The concept of AppleScripts is very simple, its a scripting language developed by Apple that can control other applications. Cocoa can run, send data and get data from applescripts. Lets look at the most simplest example applescript that simply opens iTunes:

tell application "iTunes"
   run
end tell

This scripting language is very easy to write. This script tells iTunes to run like you can probably figure out by just reading the code. To run this script we use event descriptors, there are several lines of code required to run scripts and running them with arguments is very different to running them without arguments. I built this manager class (ScriptManager.h,ScriptManager.m) to do all the dirty work for us, its a very simple class with three methods:

(void) executeScript:(NSString *) name;

You can use this method if you simply want to run a script that takes no arguments, the name argument is the script filename you have added to your Cocoa project.

(void) executeScript:(NSString *) name withArguments:(NSArray *) args;

When you have a script that takes one or more arguments, you call this method and send the arguments as an NSArray.

(NSMutableArray *) getResults;

This method returns a mutable array with all the results that the most recently executed script returned.

You will also see a method called “arrayFromDescriptor”, don’t pay any attention to that one, its just an internal method.

So how do we use this class? In a nutshell, first you add the applescript to your project, adding it to the Resources folder is not enough, you need to drag and drop the script to the Copy Bundle Resources group in the Targets tree, under your project’s name. Otherwise the manager wont find your script. Once you have done that you simple import the ScriptManager class to your project, and make an instance of the class to run any number of scripts.

Lets build an example Cocoa project called ScriptDemo, we will have our AppDelegate main class header and main file (ScriptDemoAppDelegate.h,ScriptDemoAppDelegate.m). We add the ScriptManager.h and ScriptManager.m files to our project, and on our ScriptDemoAppDelegate header class, we add the required lines (in bold and color);

#import <Cocoa/Cocoa.h>
#import "ScriptManager.h"

@interface ScriptDemoAppDelegate : NSObject <NSApplicationDelegate> {
    NSWindow *window;
   ScriptManager *manager;
}

@property (assign) IBOutlet NSWindow *window;

-(IBAction)startiTunes:(id)sender;

@end

We create a ScriptManager object, and the IBAction to trigger the applescript with a button.

Open MainMenu.xib on Interface Builder and place a button (Push Button) anywhere in the window, change its label to “Start iTunes” and link it to the action startiTunes.

Next, open the ScriptDemoAppDelegate main class, and place the IBAction definition:

#import "ScriptDemoAppDelegate.h"

@implementation ScriptDemoAppDelegate

@synthesize window;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
   // Insert code here to initialize your application
}

-(IBAction)startiTunes:(id)sender{
   manager = [ScriptManager new];
   [manager executeScript:@"startiTunes"];
}

@end

All we do here is create an instance of the ScriptManager class and call the executeScript method to trigger an applescript without sending any arguments. Make sure the applescript is called “startiTunes” and its placed on the Copy Bundle Resource group under Targets like I mentioned before.

Build and run your project, click on the Start iTunes button and iTunes should run!

Here are the used files:

ScriptDemo XCode Project
ScriptManager Class
startiTunes.scpt

I ope this small example was helpful, feel free to post any comments or questions.

Video element on HTML5

Wed, 09 Nov 2011 23:24:00 GMT

Introduction

HTML5 is introducing many new features, APIs, and elements; one of them is the video element which we’ll discuss briefly on this post.

One of the biggest issues that web pages face is that video is not natively supported by any browser; normally you will need a plug-in like Flash player to reproduce videos. This is not a big deal if you use Firefox or Internet Explorer, but what happens if you have an iPhone or an iPad? Well, you can’t access these videos… that’s why HTML5 is so important, especially with the growing demand of mobile devices like the iPhone.

The purpose of the video element is to standardize playback for video on all browsers. This is not that easy, as you might imagine… The current HTML5 draft specification does not specify which video formats browsers should support. There are lots of video formats nowadays, and it’s hard to define which one to use; it should be royalty free of course, have a good compression, high quality image and it shouldn’t kill the CPU while decoding the file.

There are three main candidates:

- Ogg Theora

- H.264

- VP8

In my opinion browsers should support as many file types as they can, but the most important thing is to standardize this on all browsers.

Examples

Ok, now to give you an idea how this element works:

<video src="video.ogv"></video>

As you can see it’s pretty simple, and besides that basic markup you have some parameters that you could use, like controls, autoplay, etc.

I also found a couple of examples while researching this topic:

- http://double.co.nz/video_test/test2.html

- http://html5demos.com/video

These examples might or might not work depending on your browser. You can also find out which browser supports which file extensions here, together with some more info on HTML5 video.

How to configure Zend Framework with Zend Server to create modern PHP applications

Fri, 21 May 2010 18:17:00 GMT

This guide will guide you through configuring the Zend Framework which is a very popular and powerful MVC framework for PHP, the idea is to configure it using the libraries provided on the Zend Server package installer.

On a previous post I explained how to set up a Zend Server installation, follow it so you can have both, Zend Server CE and the Zend Framework installed on your system.

Once you have downloaded and installed all the necessary packages this is the folder structure where u can find the files for the Zend Framework, for this guide I'm using Zend Server version 5 which is at the moment the latest release and it comes also with the latest version of the Zend Framework v 1.10:

   /usr/local/zend/share/ZendFramework (root folder for the Zend Framework)

   /usr/local/zend/share/ZendFramework/bin (shell scripts folder, these scripts will help you handle                           your project config, I'll explain later)

   /usr/local/zend/share/ZendFramework/library/Zend (Framework library files)

Ok, now that we have all the tools, let's create our first PHP application using the Zend Framework, as I mentioned above, Zend Framework comes together with a shell script that will help creating or modifying element on our MVC project structure, in order to use this script we'll have to create first a link to it just for easy handling globally through the command line, on Linux you create a link by typing:

   $ sudo ln -s /usr/local/zend/share/ZendFramework/bin/zf.sh /usr/local/bin/zf

Let's now create a new PHP project in our home folder, we do so by typing:

   $ zf create project /home/username/my_first_project

the command will create the whole project structure including some initial config files that you can alter later while developing your project. Once the command is done the folder structure you'll see will look similar to:

my_first_project
   |-- application
   |   |-- Bootstrap.php
   |   |-- configs
   |   |   `-- application.ini
   |   |-- controllers
   |   |   |-- ErrorController.php
   |   |   `-- IndexController.php
   |   |-- models
   |   `-- views
   |       |-- helpers
   |       `-- scripts
   |           |-- error
   |           |   `-- error.phtml
   |           `-- index
   |               `-- index.phtml
   |-- library
   |-- public
   |   |-- .htaccess
   |   `-- index.php
   `-- tests
        |-- application
        |   `-- bootstrap.php
        |-- library
        |   `-- bootstrap.php
        `-- phpunit.xml

Now we need to link the Zend Framework's library files to our library project so we can make use of them, to do so we need to create a extra link that will point our library folder to our Zend Framework's current installation, type this in your terminal:

   $ ln -s /home/username/my_first_project/library path/to/ZendFramework/library/Zend

and voila! You are all set up to start coding your application with all the advantages that Zend Framework brings.

You can find more info about what the zf.sh script does by typing:

   $ zf --help