The full pointo of Surface RT came to me when I actually started using it in real life. Of course, I also made my own experiments on it just to find out other possible scenarios where Surface can be great help for me, but I will focus on other things on later posts.

Easy, quick and lightweight

First thing I noticed was that it is convenient to take Surface RT with me. I don’t even need bag with me because I can just keep it in hand. Opening Surface and accessing my work programs and systems is blazing fast – just open Surface, click button, log in and there you are. Typing is painless no matter if you use on-screen or attached keyboard. Yes, it takes some small time to get used with those new keyboards but it’s not something annoying. It took me two meetings to be intermediate level Surface keyboard gangsta.

Battery

Alhtough one of my friends faced bad issues with Surface RT battery time I have had no problems with Surface RT battery. If I don’t do anything that keeps CPU heavily loaded the battery lasts around two-three days for me. Of course, I have companion tool called Windows Phone 8 because Windows RT has no support for SIM-card.

Charger is weird creature by Microsoft and it’s impossible to get it somewhere if you are not in country where Surface RT is not available. There are no normal chargers or USB charging possible and this is something I consider as bad fail of Microsoft – if being online is mandatory for you when travelling then you still have to take some more fool-proof device for you.

Storage

I have heard many complaints about how Windows RT takes too much disk space on Surface. Well… it’s still dual operating system that is able to run some of your known applications from regular Windows and it comes with RT version of Office. Of course, it all takes some room.

Solution to problem is simple – you can buy MicroSD card to extend storage and keep big files on card. Current MicroSD cards provide disk space up to 64GB and Microsoft has told that they have made no limits to size of MicroSD. If you find some bigger MicroSD that has same communication interface as smaller ones have then it should work fine with Surface RT.

I bought 64GB MicroSD and still I have a lot of room available on main disk and on MicroSD. I think more and more that whining about disk space is just whining and it doesn’t come from real use.

Working on Surface RT

Now let’s focus on some work stuff too. I decided for Surface RT after considering many factors. I need access to my systems, I need to communicate with my teams and customers and I must be able to work with documents. This far Surface RT is served me well on following things:

• accessing Jira OnDemand to monitor tasks and issues for current systems
• accessing SharePoint on Office365 where we host our project sites
• using Skype – experience is damn kinky but it works
• I can work with e-mails using e-mail application for Metro, it’s very primitive but it works so I get everything done
• Office documents – yes, I can work wih Word, Excel and PowerPoint – applications are not as powerful as their full versions but I can still get my work done
• OneNote for touch – I’m using it to protocol customer meetings (damn convenient – just type your memos and when you are back on your work machine your memo is already waiting there)
• Remote Desktop – yes, Surface RT comes with Remote Desktop and if needed I can access my servers from Surface RT (not very convenient due to small screen but it works well)
• SkyDrive – yes, I can work with files on cloud and as most of my stuff is on cloud then SkyDrive is great help for me

There are some things I’m not very happy with. SharePoint client integration is missing, Office applications on RT are not very touch oriented and OneNote is missing many text formatting options or at least I have not found these. These issues are not show stoppers but they take time to get around.

Conclusion

Surface RT is not replacement for laptop. It is companion tool that is somewhere between laptop and smart phone and if you treat it like this then you will be happy with it. If you want replacement to your laptop then you have to buy the new laptop. This far Surface RT has been great help on my business trips and it also helps me when I have out-from-office days. I can most important things done, I can keep up communication with teams and customers and I can manage my servers. Cloud integration makes working with same files on different devices very convenient. If you need just device that helps you to keep up business side of your office then Surface RT is very good choice.

The post Surface RT–first impressions appeared first on Gunnar Peipman - Programming Blog.

Why Windows Azure?

This is the first question that developers from other companies ask me when they hear about my heavy use of Windows Azure. I have experiences from past – based on server and shared hosting – and I can say that Windows Azure makes my life way easier. Main reasons are here:

• no hardware costs – I don’t have to rent or buy servers, I don’t have to monitor their physical health and it’s not my responsibility to buy more hardware, replace broken parts or buying new machines when old ones need to be retired,
• no maintenance costs – I don’t have to spend my time on deploying updates, make fancy configuration changes and other administrative work I had to buy in before or in the case of over-shared shared hosting I had to have endless discussions with tech support to get test sites run at normal speed,
• no backups – what’s on cloud will stay on cloud – I don’t have to worry about installing my systems again when some environment crashes because it is up to Windows Azure service to keep my machines alive and backed up,
• control over server – something you don’t get with shared hosting is control over server environment – on Windows Azure I can access my virtual machines over Remote Desktop to detect problems or made some simple configuration changes,
• small or zero expenses- if you have small company and you have MSDN Ultimate subscription you have Windows Azure as part of your development environment for free (of course, if you spend more resources than the amount included to your MSDN benefit you must pay).

From practice. Windows Azure, by costs, is somewhere between shared and server hosting. Comparing calculations are not easy to do because when calculating expenses on your side you have to consider also people’s work related to supporting servers, operating systems etc. It’s possible you have cheaper model worked out. I’m owner of small company and I’m only happy when price and outcome are in very good balance.

It is easy to involve Windows Azure to your development processes and once it’s done you will definitely enjoy it.

Scenarios for Windows Azure

For me the most important scenarios in development processes where Windows Azure comes in are as follows:

• test environments – on test environments we do in-house or team testing,
• public test environments – here are also customers involved,
• demo environments – do demo our systems to possible new customers.

For all of these scenarios I like one common characteristic – it’s fire and forget deployment.

From practice. All these environments are important to us and other people who are involved in our work. Stability and availability must be very good and this is where Windows Azure is the best choice for us. We don’t need endless discussions and negotiations with tech support of services anymore – if we need more resources we can buy what we need.

Deployments to cloud environment

Deploying systems to cloud environment is damn easy. You can use Visual Studio for it and if you like to automate things then you can also use MS Build and PowerShell. Here are possible options for deployments:

• Cloud projects on Visual Studio,
• PowerShell scripts to build and deployment packages,
• MS Deploy – works also for Windows Azure web sites,
• Integration with Team Foundation Services.

From practice. I’m using mostly cloud projects and to some compute instances we deploy more than one separate system with one shot. We are using special deployment projects that include folder for each separate system and these systems are deployed to folders using Visual Studio file deployment. When systems are deployed to folders we run cloud deployment project that moves all new stuff to cloud. We do it around 4-5 times per day and preparation for deployment takes only some minutes,

Database deployments

With systems we must also deploy their databases. In most cases SQL Azure web database is more than enough for us. Visual Studio makes it extremely easy to deploy database updates from database to Visual Studio database project and from database project to different database.

It’s also possible to use database deployments where database is recreated before deployment. Test data can be part of database project – you can use post-deployment scripts to pump test data to database. There’s nothing complex. Just spend some hours on playing with database projects and you are there.

You can find some reading about database projects here:

• Using Visual Studio database projects in real life
• Using Visual Studio database post-deployment scripts in practice
• Comparing and updating database schemas using Visual Studio 2010

From practice. Visual Studio database projects are very powerful tool to synchronize changes between databases. Of course, it’s not silver bullet that solves all your problems but still it’s very good result if database deployment takes you couple of minutes instead of hours of manual update. SQL Azure is also supported, just make sure you set SQL Azure as target database.

Architectural changes in applications

Now comes the most complex part – in-premises and shared hosting applications are not usually built to handle file system, sessions and cache as services. If you write simple web applications then Windows Azure Web Sites should be enough for you – similar to shared hosting and fast deployments using MS Deploy.

For compute instances you need some tweaking. You have to build application the way that it works in shared hosting and on compute instance. This means using dependency injection to plug file access and session providers to your application depending on where it is running.

From practice. First time it takes time to get all those pieces together and function normally on Windows Azure. Consider two-three working days for some of your great developers for this task. When everything starts running and you have idea how things work then next times it takes you around hour to get all tweaks done for new project.

Conclusion

I started using Windows Azure when it was young platform and over time I have reached the point where Windows Azure is mandatory service in my development processes. There are many ways how Windows Azure can support your development processes and it’s not hard to get there. Visual Studio provides you with very good tools and making some more advanced use of database projects in Visual Studio you will work also deploy your databases very fast. Your first time on building up everything described here may take time and be painful for you but when you get things running you will never want to go back.

The post How my company uses Windows Azure in development process appeared first on Gunnar Peipman - Programming Blog.

If you go to Aloha Editor homepage you will find working example of editor and example HTML page with JavaScript that works as simple getting started guide. It took me couple of minutes to add Aloha Editor to my page and get it working.

Configure on page, use from CDN

You can include Aloha Editor files from their CDN and configure editor on your page. This is the block of JavaScript from my page:

<!-- load the Aloha Editor core and some plugins -->
<script src="http://cdn.aloha-editor.org/latest/lib/aloha.js"
                    data-aloha-plugins="common/ui,
                                        common/format,
                                        common/list,
                                        common/link,
                                        common/table,
                                        common/highlighteditables">
</script>

Notice how easy it is to say what functions you want to plug to editor. I mean even beginners should be able to get this editor work with no markable problems.

Visible only when needed

Here is one text field where simple HTML editing is needed:

When I move mouse to text area to start editing text then Aloha toolbar appears:

Toolbar is lightweight and doesn’t take space on screen when it is not needed. Toolbar like this leaves way more space for content on screen and it allows to focus better on information on form.

Conclusion

Aloha Editor is small, compact and easy to use. It may save markable amount of space on views where more than one WYSIWYG editor is needed. Files can be included from Aloha CDN and this way it possible to save some traffic and keep load of server lower. JavaScript you must add to your pages is short, simple and easy to understand. Alhtough I have been Aloha user for some hours I am very happy with it.

The post Aloha Editor–simple and easy to use WYSIWYG editor appeared first on Gunnar Peipman - Programming Blog.

References

This is not required topic. It’s here just to track previous steps of story so I can later remember where this solution came from.

• ASP.NET MVC: Implementing CheckBoxList
• ASP.NET MVC: Getting selected values from CheckBoxList
• ASP.NET MVC: Converting business objects to select list items

Main problems with previous solution were the facts that generating list of items for checkbox list and making updates to changed collection later were not very well implemented and these implementations didn’t defined simple enough interface to use for front-end developers.

Solution

In big picture our solution is simple (think that we create tag list for event):

1. We will create base class for business of model classes that we can use in controllers – it depends on your architecture.
2. We will write extension method that creates list of all tags and selects the ones that were already chosen.
3. We will write extension method to HtmlHelper that displays checkbox list to user. This extension method is used in view.
4. We weill write extension method to update event tags collection when user clicks save button in view.

It means that our solution has three generic interfacing points:

1. Create data source for checkbox list
2. Display checkbox list
3. Update data source

It is possible to go further and find the ways how to automate update process to move updating functionality to model binder by example but I don’t stop on tweaks like this here because I have no good idea right now if these tweaks make any good or are they just nice things that turn out to be too confusing for end users.

Base class for business or model classes

Before we implement full checkbox list functionality we need some preparations. My solution is not ideally generic and it has some requirements to avoid complex logic that involves reflection and smart code-level decisions. I don’t go deeper here as anyway you see later why we made this step.

Whatever you use in your MVC application – domain classes or mapped models – we need something static where we can link extension methods we will write at later steps. I’m using Entity Framework with POCO-s and this solution makes some use of Entity Framework features that maybe other mappers doesn’t support this way.

My base class for business classes is as follows:

public abstract class BaseEntity
{
    public int Id { get; set; }
}

And here is example business class:

public class Event : BaseEntity 
{
    public Event()
    {
        this.Tags = new HashSet<Tag>();
    }
 
    public string Title { get; set; }
    public DateTime Begins { get; set; }
    public DateTime Ends { get; set; }
    public string Description { get; set; }
    public string Url { get; set; }
    public string TitleForUrl { get; set; }
    public string Abstract { get; set; }
    public int Clicks { get; set; }
 
    public virtual ICollection<Tag> Tags { get; set; }
    public virtual ICollection<Party> Vendors { get; set; }
    public virtual ICollection<Party> Organizers { get; set; }
}

You can define also abstract property like DisplayName for business base class to make sure that all business classes have string presentation understandable to humans. But this is not very important fact here.

Creating source for checkbox list

Next step is to prepare data for checkbox list. We need two things:

1. Collection of items that can be selected
2. Collection of items that must be shown as selected

By example, when we want to let user select tags for some event we need list of all tags to show and list of current tags to know what tags exactly must be shown as selected.

To meet these needs I wrote simple extension method to business base class type of collections:

public static IEnumerable<SelectListItem> ToCheckBoxListSource<T>(this IEnumerable<T> checkedCollection, 
                                          IEnumerable<T> allCollection) 
                                          where T : BaseEntity
{
    var result = new List<SelectListItem>();
 
    foreach (var allItem in allCollection)
    {
        var selectItem = new SelectListItem();
        selectItem.Text = allItem.ToString();
        selectItem.Value = allItem.Id.ToString();
        selectItem.Selected = (checkedCollection.Count(c => c.Id == allItem.Id) > 0);
 
        result.Add(selectItem);
    }
 
    return result;
}

This method creates list of SelectListItems for allCollection and uses checkedCollection to find out if current item must be displayed as checked or not. Example of controller comes below.

Displaying checkbox list

Now as we have data for checkbox list we can focus on displaying it. I created simple extension method for HtmlHelper so we can display checkbox list like any other control on edit form.

public static MvcHtmlString CheckBoxList(this HtmlHelper helper, string name, 
                                         IEnumerable<SelectListItem> items)
{
    var output = new StringBuilder();
    output.Append(@"<div class=""checkboxList"">");
 
    foreach (var item in items)
    {
        output.Append(@"<input type=""checkbox"" name=""");
        output.Append(name);
        output.Append("\" value=\"");
        output.Append(item.Value);
        output.Append("\"");
 
        if (item.Selected)
            output.Append(@" checked=""checked""");
 
        output.Append(" />");
        output.Append(item.Text);
        output.Append("<br />");
    }
 
    output.Append("</div>");
 
    return new MvcHtmlString(output.ToString());
}

As you can see here I chose pretty safe data source for checkbox list. We use safe collection of SelectListItems that makes no calls to database. Also it doesn’t have any additional logic involved behind the scenes.

Saving changes back to collection

When user saves data checkbox list is sent to controller as array of integers. We have to update some collection of business object and make sure we don’t confuse mapper anyhow. We have to add items that are currently missing from collection and remove items that are not needed anymore.

NB! It is easier to clear collection and add selected values back there but this is not safe thing to do. Mappers handle this move differently and you may introduce negative side effects in code this way. By example, mapper may delete all current event tags and insert them back again.

Now we have second place where we need base class to make collection updating functionality available for all business classes. For collection updating I wrote this extension method:

public static void UpdateCollectionFromModel<T>(this ICollection<T> domainCollection, 
                                                IQueryable<T> objects, int[] newValues) 
                                                where T : BaseEntity
{
    if (newValues == null)
    {
        domainCollection.Clear();
        return;
    }
 
    for (var i = domainCollection.Count - 1; i >= 0; i--)
    {
        var domainObject = domainCollection.ElementAt(i);
        if (!newValues.Contains(domainObject.Id))
            domainCollection.Remove(domainObject);
    }
 
    foreach (var newId in newValues)
    {
        var domainObject = domainCollection.FirstOrDefault(t => t.Id == newId);
        if (domainObject != null)
            continue;
 
        domainObject = objects.FirstOrDefault(t => t.Id == newId);
        if (domainObject == null)
        {
            continue;
        }
 
        domainCollection.Add(domainObject);
    }
}

This extension method takes collection we need to update, query of all objects that can be added to collection and selected id values from model. It uses these parameters to make safe updates to collection of business object.

Using checkbox list

Now let’s focus on how to use checkbox list. I’m using my old good event tags example for this. Both of these classes use BaseEntity as their base class.

Now let’s go through event editing flow in ASP.NET MVC application.

1. Display edit form

We display event in edit mode and provide view with model that has also list of tags. Some of these tags are selected because I selected some of these before.

[HttpGet]
public ActionResult Edit(int id)
{
    var evt = Context.Events.FirstOrDefault(e => e.Id == id);
    if (evt == null)
        return HttpNotFound("Cannot find event with id " + id);
 
    var model = new AdminEventEditModel();
    model.AllTags = evt.Tags.ToCheckBoxListSource(Context.Tags);
    Mapper.Map(evt, model);
 
    return View(model);
}

2. Display checkbox list

In view we have to display checkbox list to user.

<div class="editor-label">
    @Html.LabelFor(model => model.TagIds)
</div>
<div class="editor-field">
    @Html.CheckBoxList("TagIds", Model.AllTags)
</div>

This is just simple call to our extensions method.

3. Updating tags collection

When user saves event then selected tags are returned as array of integers. We need current event, tags collection and selected tags id-s to update tags collection of event.

[HttpPost]
public ActionResult Edit(AdminEventEditModel model)
{
    // ...
    var evt = Context.Events.FirstOrDefault(e => e.Id == model.Id);
    if (evt == null)
        return HttpNotFound("Cannot find event with id " + model.Id);
 
    evt.Tags.UpdateCollectionFromModel(Context.Tags, model.TagIds);
    Context.SaveChanges();
    // ...
}

Now we have all flow of checkbox list covered.

Conclusion

I was not hard to build extension methods to implement checkbox list functionality. We had to use base class to write generic extension methods that cover whole domain. We also wrote method to generate data source for checkbox list, method to display it and method to update event tags collection later. We ended up with three extension methods – one for every step in flow. The solution is simple and common enough to use it in real projects.

The post Better solution for ASP.NET MVC checkbox list appeared first on Gunnar Peipman - Programming Blog.

Overview

With cloud project it is possible to set up everything needed to deploy SSL site to compute instance (certificates, end points, host headers etc). Changing of IIS settings during or after deployment is not so easy. Start-up script that you can specify in cloud service definition file is run before sites are set up on IIS and the only way to modify IIS settings seems to be the moment when web role starts.

NB! In this posting I expect that you already know how to deploy SSL site to Windows Azure and you are familiar with service definition and configuration files. You can find more from Windows Azure page Configuring SSL for an application in Windows Azure.

Solution

As a solution we make changes to IIS configuration when web role starts. For this moment sites on IIS are set up and we can access them. To access site settings we need library for IIS management and elevated privileges for web role. Under these conditions we can modify site settings.

1. Reference Microsoft.Web.Administration

Right click on web application and add NuGet reference to Microsoft.Web.Administration package.

2. Add WebRole entry point

Add new class called WebRole.cs to web application that you want to deploy to Windows Azure. Code is taken from Manu Cohen-Yashar posting Client Certificates in Windows Azure.

public class WebRole : RoleEntryPoint
{
    public override bool OnStart()
    {
        try
        {
            using (var server = new ServerManager())
            {
                var siteNameFromServiceModel = "Web"; // TODO: update this site name for your site. 
                var siteName = string.Format("{0}_{1}", RoleEnvironment.CurrentRoleInstance.Id, siteNameFromServiceModel);

                var config = server.GetApplicationHostConfiguration();
                var accessSection = config.GetSection("system.webServer/security/access", siteName);
                accessSection["sslFlags"] = @"Ssl,SslRequireCert";
 
                server.CommitChanges();
            }
        }
        catch (Exception ex)
        {
            // handle error here

        }
        return base.OnStart();
    }
}

If you need different settings for SSL then take a look at SSL flags list in IIS.NET.

3. Run web role in elevated privileges

Now open ServiceDefinition.csdef file from your Windows Azure deployment project and add the following XML there:

<Runtime executionContext="elevated" />

Insert it right below <WebRole> node.

Now you are ready to build your solution and try out if deployment works as expected.

NB! Before deploying SSL site to Windows Azure make sure you have certificates uploaded and DNS settings done. Otherwise you may face hard to debug errors and there is no free official tech support anymore.

If everything went well then you should see the following screen when opening your Windows Azure IIS settings over remote desktop:

Same way you can also modify all other IIS settings for your web role.

Conclusion

As start-up scripts run in some too early phase of deployment we cannot use them to modify site settings as IIS site is not deployed yet. We were able to use web role start method to make changes to IIS. We used spacial Microsoft.Web.Administration library to keep code simple. Maybe it’s not the best way how to do things but it works in most cases and I was able to deploy the site that authenticates users using Estonian ID-card.

The post Using client certificates on Windows Azure appeared first on Gunnar Peipman - Programming Blog.

General Windows Azure updates

1. Develop/test in the cloud
   • No Charge for Stopped VMs
   • Pay by the Minute Billing
   • MSDN Use Rights now supported on Windows Azure
   • Heavily Discounted MSDN Dev/Test Rates
   • MSDN Monetary Credits
   • Portal Support for Better Tracking MSDN Monetary Credit Usage
2. BizTalk Services – EDI and EAI in the cloud, nice addition to service bus. Find out more here.
3. Per-Minute Billing and No Charge for Stopped VMs - no compute charges for stopped VMs
4. SSL Support with Web Sites – yes, we have no full SSL support on Web Sites and we can even use SNI
5. Active Directory: Updated directory sync utility, ability to manage Office 365 directory tenants from Windows Azure Management Portal
6. Free Trial: More flexible Free Trial offer – With a free trial, you now get a monthly Windows Azure credit of $200. This credit can be applied to any service of your choice

Find out more from ScottGu blog post Windows Azure: Announcing New Dev/Test Offering, BizTalk Services, SSL Support with Web Sites, AD Improvements, Per Minute Billing.

New MSDN benefits

1. No Charge for Stopped VMs
2. Pay by the Minute Billing
3. MSDN Use Rights now Supported on Windows Azure (run your MSDN software on Windows Azure virtual machines)
4. Heavily Discounted MSDN Dev/Test Rates
5. MSDN Monthly Monetary Credits
6. Portal Support for Better Tracking MSDN Monetary Credit Usage

More about MSDN benefits and good overview of financial stuff can be found from ScottFGu blog post Windows Azure: Announcing Major Improvements for Dev/Test in the Cloud.

Windows Azure Pack

Windows Azure Pack is something for companies who want to host Windows Azure on their own infrastructure. As far as I know it’s great help for companies and governments who doesn’t want USA agencies to have access to their data. With Windows Azure Pack infrastructure is offered by some Microsoft partner and Microsoft just manages Windows Azure on partner infrastructure for customers. This way Microsoft is just service provider and not service hoster.

Windows Azure Pack contains the following components:

• Management portal
• Service management programming interface
• Web sites service
• Virtual machines service
• Service bus

Find out more from Mary Jo Foley’s article Microsoft finds a new way to deliver a private cloud in a box.

The post Windows Azure updates, new services and MSDN benefits appeared first on Gunnar Peipman - Programming Blog.

TFS 2013: Example Team Room with some chat.
Click on image to view it at original size.

Room reminds a little bit web based IRC client built to SharePoint but it seems to be pretty good idea to get started with extending TFS with direct team communication. As it is early preview then there are not much to highlight yet but as Build conference is coming I’m sure Microsoft has some surprises for us.

Team Room features

Here are current features:

• #Taskid in char creates link to task with given number (take a look at #29 at screenshot above – it’s link to task umber 29)
• If you want to make message to somebody more easy to notice then use @username at chat and user with give user name will see his or her name highlighted (take look at line that starts with orange @gunnar at screenshot)
• You can browse chat by date. There’s dropdown calendar on top of chat window.
• If somebody writes messages then browser beeps. You can click on megaphone icon to turn off beeping.

As this is fresh preview and sometimes I see TFS error messages there I’m sure that Microsoft came out with limited set on things to show in Team Room chat. Over next weeks I hope to see more stuff coming to feed.

Speculations

As Team Foundation Service seems to run on SharePoint and make use of new application model I think it’s possible to integrate Yammer style feeds to TFS and enable also team document in-place reviews, notifications about new commits, task changes etc. Also search would be nice to have because teams who start really using Team Rooms every day need chat search very soon. I see here a lot of room for improvements and integrations. One interesting scenario would be integration with Office365 SharePoint to get project documents to chat.

Conclusion

TFS Team Rooms is new interesting chat feature that helps teams to communicate real-time and keep chat logs. Today the solution offered as part of Team Foundation Services is simple and easy to get started. Although there is room enough for tons of interesting features today is the first day of new service and I hope we will see many more features coming over next weeks.

The post TFS 2013 Team Rooms appeared first on Gunnar Peipman - Programming Blog.

Main features:

• Agile portfolio management
• Updates to Team Explorer and version control
• Lightweigh code commenting
• Indicators in code editor to find easily more information about code objects
• Creatig and modifying test plans, suites and shared steps on the web
• Cloud load testing
• Acquired InRelease software for release management
• Team collaboration and conversations

Code indicators at Visual Studio 2013.

Read more from Brian’s blof posting Visual Studio 2013.

The post Visual Studio 2013 announced! appeared first on Gunnar Peipman - Programming Blog.

Life-cycle of post-deployment script

Post-deployment script, like any other thing under development, has its own life-cycle. The following diagram shows how the process goes.

Steps are as follows:

1. Developer makes modification to database, by example developer adds new table and some new relations.
2. System code is modified to reflect changes in database.
3. Modifications are tested to make sure that functionality is not broken.
4. Data for new table is added to post-deployment script.
5. Database deployment with post-deployment script is run on developer machine to make sure that database deployment works. Of course, it’s only good idea to try also code out after changes to post-deployment script.

Post-deployment script changes mostly with database but there is one exception – over time test data is replaced by real or at least close-to-reality data and after these changes post-deployment script must be tested again.

Post-deployment script must be up to date

If post-deployment script is not updated with database then soon it will live its own life and it gets more and more out from synch with database. As post-deployment script doesn’t work anymore then developers start keeping their current copy of database and make only structural updates there. Soon it turns to fear against database deployments as more and more issues raise when database must be deployed again. And, of course, after every deployment all data must be inserted to database again.

Up to date post-deployment script has some serious benefits:

• Developers are more brave when working with database,
• Deployment and data related errors come out early.
• All developers have up to date version of database and test data – they don’t waste time to fix problems related to some earlier version of database that is deprecated.
• It is easy to deploy database with test data also to other environments like test server, continuous integration server etc.
• Typical problem of customer – do I have to insert this data again after update – is solved once and forever.

What if some guys refuse to use database scripts?

Do they also refuse to write quality code? I mean how they can do their job if the only way to get up to date database is to deploy this database to their development machines?

If they refuse to use last version of database and data then the quality of their code comes down, they spend a lot of time on fighting with newer codebase and their current database incompatibility problems and soon they probably understand that they get badly stuck this way.

Okay, even if they move fast there’s still problem – other team members move way faster with their tasks.

Post-deployment script in practice

I’m using database projects with post-deployment scripts almost in all active projects. Post-deployment script helps me to be sure that developers work on with latest data and if latest data introduces problems then they can focus on solving these problems because these problems have high appearing probability on test and staging environments.

Usual post-deployment script managing activities are these:

• Make sure database deployments with data succeed.
• Solve all database deployment problems ASAP – don’t stop developers work.
• If customer has added new important data to test database then migrate this data to post-deployment script.

These steps doesn’t waste your time a lot and same time you keep development smoothly running.

Getting started

Actually database projects and post-deployment scripts are not something complex and huge. Play with them a little bit and try to use them with some sample application to get better idea how to use them. Of couse, if you have DBA in your team then also tell him what you are planning and find out together how he can support developers work.

In the beginning it’s all new for team – give them some time to get used with new tools and if possible then organize them small in-house training with practical examples. This way you can get also valuable input from developers that makes whole process easier for everybody.

Conclusion

Visual Studio database projects that provide fresh data to developers have worked for me very well. Although it’s not something you can start right on minute it still has a lot of benefits you don’t want to miss. Making life with database and data easier for developers helps them save time for coding and also guys who are responsible for deployments are happy because they can do everything way faster than before.

The post Using Visual Studio database post-deployment scripts in practice appeared first on Gunnar Peipman - Programming Blog.

Years ago I had honor to witness one debugging session where one lengthy method threw NullReferenceException. It was actually one SharePoint form or web part that threw exception and the exption message was shown to user. The developer who worked on debugging this form or web part had also stack trace available for exception. One more thing to mention – two years of experience on .NET and university degree in software development were also written to CV of this guy.

Let’s start. NullReferenceException means that code is trying to use some object that is null. When attaching debugger to process then it is easy to step through problematic method and find out where exception occurs.

But what I saw was something new to me – the guy was just watching the message and then looking at different parts of source code to find out where things can go wrong. No, he was not investigating this one method but whole code in solution. Why is he doing something like this and why takes solving of this problem more time than half of day?

Well, here is how exception can be understood:

This is just arbitrary exception I stole somewhere from web.

• important information – this is the information that gives us details about bug and based on this information all debugging can be done,
• technical information – is… well… just techinal information like you can see when operating system crashes or ATM goes mad or your tablet has hardware fault – it is there, it is important but it’s just this technical information like all technical information everywhere else (maybe somebody needs it some day).

Of course, after short lecture about exceptions the problem got solved with ten minutes but the memory remains…

The post Understanding exceptions artistic way appeared first on Gunnar Peipman - Programming Blog.