Geekswithblogs.net

Use the NotMapped Attribute with Entity Framework in Partial Classes

Aligned — Wed, 15 May 2013 09:32:32 GMT

Originally posted on: http://geekswithblogs.net/Aligned/archive/2013/05/15/use-the-notmapped-attribute-with-entity-framework-in-partial-classes.aspx

I wanted to add a property to send to my JavaScript class through WebApi, but didn’t want it in the database. I was getting an error telling me I had an invalid name on the EF 5 selection from the database. Adding the NotMapped attribute to the property did the trick. I get it on the JavaScript side as well. I found the answer (again) on StackOverflow.

Example:

public partial class ComponentAttribute
{
    [NotMapped]
    public bool IsModified { get; set; }
}

.NET Security Part 3

simonc — Thu, 16 May 2013 10:52:00 GMT

Originally posted on: http://geekswithblogs.net/simonc/archive/2013/05/16/.net-security-part-3.aspx

You write a security-related application that allows addins to be used. These addins (as dlls) can be downloaded from anywhere, and, if allowed to run full-trust, could open a security hole in your application. So you want to restrict what the addin dlls can do, using a sandboxed appdomain, as explained in my previous posts.

But there needs to be an interaction between the code running in the sandbox and the code that created the sandbox, so the sandboxed code can control or react to things that happen in the controlling application. Sandboxed code needs to be able to call code outside the sandbox.

Now, there are various methods of allowing cross-appdomain calls, the two main ones being .NET Remoting with MarshalByRefObject, and WCF named pipes. I'm not going to cover the details of setting up such mechanisms here, or which you should choose for your specific situation; there are plenty of blogs and tutorials covering such issues elsewhere. What I'm going to concentrate on here is the more general problem of running fully-trusted code within a sandbox, which is required in most methods of app-domain communication and control.

Defining assemblies as fully-trusted

In my last post, I mentioned that when you create a sandboxed appdomain, you can pass in a list of assembly strongnames that run as full-trust within the appdomain:

// get the Assembly object for the assembly
Assembly assemblyWithApi = ...    

// get the StrongName from the assembly's collection of evidence
StrongName apiStrongName = assemblyWithApi.Evidence.GetHostEvidence<StrongName>();

// create the sandbox
AppDomain sandbox = AppDomain.CreateDomain(
    "Sandbox", null, appDomainSetup, restrictedPerms, apiStrongName);

Any assembly that is loaded into the sandbox with a strong name the same as one in the list of full-trust strong names is unconditionally given full-trust permissions within the sandbox, irregardless of permissions and sandbox setup. This is very powerful! You should only use this for assemblies that you trust as much as the code creating the sandbox.

So now you have a class that you want the sandboxed code to call:

// within assemblyWithApi
public class MyApi
{
    public static void MethodToDoThings() { ... }
}

// within the sandboxed dll
public class UntrustedSandboxedClass
{
    public void DodgyMethod()
    {        
        ...
        MyApi.MethodToDoThings();
        ...
    }
}

However, if you try to do this, you get quite an ugly exception:

MethodAccessException: Attempt by security transparent method 'UntrustedSandboxedClass.DodgyMethod()' to access security critical method 'MyApi.MethodToDoThings()' failed.

Security transparency, which I covered in my first post in the series, has entered the picture. Partially-trusted code runs at the Transparent security level, fully-trusted code runs at the Critical security level, and Transparent code cannot under any circumstances call Critical code.

Security transparency and AllowPartiallyTrustedCallersAttribute

So the solution is easy, right? Make MethodToDoThings SafeCritical, then the transparent code running in the sandbox can call the api:

[SecuritySafeCritical]
public static void MethodToDoThings() { ... }

However, this doesn't solve the problem. When you try again, exactly the same exception is thrown; MethodToDoThings is still running as Critical code. What's going on?

By default, a fully-trusted assembly always runs Critical code, irregardless of any security attributes on its types and methods. This is because it may not have been designed in a secure way when called from transparent code - as we'll see in the next post, it is easy to open a security hole despite all the security protections .NET 4 offers. When exposing an assembly to be called from partially-trusted code, the entire assembly needs a security audit to decide what should be transparent, safe critical, or critical, and close any potential security holes.

This is where AllowPartiallyTrustedCallersAttribute (APTCA) comes in. Without this attribute, fully-trusted assemblies run Critical code, and partially-trusted assemblies run Transparent code. When this attribute is applied to an assembly, it confirms that the assembly has had a full security audit, and it is safe to be called from untrusted code. All code in that assembly runs as Transparent, but SecurityCriticalAttribute and SecuritySafeCriticalAttribute can be applied to individual types and methods to make those run at the Critical or SafeCritical levels, with all the restrictions that entails.

So, to allow the sandboxed assembly to call the full-trust API assembly, simply add APCTA to the API assembly:

[assembly: AllowPartiallyTrustedCallers]

and everything works as you expect. The sandboxed dll can call your API dll, and from there communicate with the rest of the application.

Conclusion

That's the basics of running a full-trust assembly in a sandboxed appdomain, and allowing a sandboxed assembly to access it. The key is AllowPartiallyTrustedCallersAttribute, which is what lets partially-trusted code call a fully-trusted assembly. However, an assembly with APTCA applied to it means that you have run a full security audit of every type and member in the assembly. If you don't, then you could inadvertently open a security hole. I'll be looking at ways this can happen in my next post.

Tech Learning–Always Start with Hello World

D'Arcy Lussier — Wed, 15 May 2013 07:20:01 GMT

Originally posted on: http://geekswithblogs.net/dlussier/archive/2013/05/15/152931.aspx

Remember Hello World? It was the program that we all started out with at some point. We did something that would make Hello World display somehow. But as we got older and more into our careers as developers, we’ve forgotten Hello World. Instead, we’ve replaced it with Contoso or Pet Store or whatever large, heavy, complex domain we decided would be a much better sandbox to frame learning a new technology with.

I was talking with an attendee at Prairie Dev Con about this last week, and how we can easily get caught up in fulfilling the domain rather than understanding the underlying tech.

Consider these two scenarios, both related to learning ASP.NET MVC with EF code first.

A doctor’s office wants a web site to schedule patient visits. This site will use forms authentication and will leverage MVC and Entity Framework Code First. We’ll use jQuery on the front end for the UI and SQL Server in the back for storing the data. The datamodel looks like this…<insert data model here> and the class diagram looks like this <insert class diagram here>.

Create a single view in an MVC project that uses EF to retrieve a simple value of “Hello World” from a database table and display it on the screen.

Now, if we were to do both of these we’d come to the same result of understanding EF and MVC, but with one difference – the example on the left comes with a huge and heavy domain that we’ve added in for no other reason than to feel like we’re building something of value. But here’s the thing – we’re not. When we’re learning a technology, its about the technology. The details of a pretend scenario do nothing but get in the way of the actual learning.

The value is in us understanding how the technology works so we can apply it to domain contexts later. Would we expect an apprentice carpenter who’s just learning to build a house as their first project to teach them framing? Of course not. So why do we expect it from ourselves as developers?

Unburden yourself from complex domain contexts when you’re starting out with something new. Start with Hello World and take it from there.

Live Coding During Presentations–Good or Bad?

D'Arcy Lussier — Wed, 15 May 2013 13:37:25 GMT

Originally posted on: http://geekswithblogs.net/dlussier/archive/2013/05/15/152933.aspx

This is a response/continuation of the discussion that Chad McCallum started over on his blog. He wondered what people’s view was on doing live coding within a presentation – for or against.

Where. To. Begin.

There is no right answer to the question. As developers, we like to look at things almost from a bit perspective – 0 or 1, yes or no, true or false. But humans aren’t computers and so to say that yes you should or no you shouldn’t use live coding demos isn’t a worthwhile argument because you’ll never get consensus from the most important group of people for a presenter – your audience.

Consider these two comments:

“I attended this session based on my experience from his other session. Great demos!”

and

“Number of presenters clearly didn't have any developer content prepared and re-used decks of the web and didn't get into any programming. [Speaker]’s was particularly bad.”

Note the last part of the second comment, about a certain speaker’s sessions being bad because they clearly didn’t have any developer content prepared? Well the first comment is about that speaker’s second session. I was in that session and yes, he showed code but didn’t write any. Huh. Two people, same session, different…expectations?

It’s Always About Expectations

I have learned this through much trial and tribulation – the sure way to ensure success in life is to set clear expectations as early as possible. Doing live code? Showing slides of code? Using copy/paste or snippets? Not having any code whatsoever at all? There is no discussion about whether one of these styles is better than the other. I’ve seen all these styles work and work well (I’ve also seen them all bomb just as well also, but I’ll get to that in a second).

So what we’re really talking about is audience expectations.

A few years ago some friends and I went out for Chinese food. One of our friends decided to buy a lobster for the table. He was invited into the kitchen to see it prepared. He came out pale and a little shocked. Why? Well, he was going to see a lobster get cooked – y’know, dropped in boiling water. Isn’t that how you cook a lobster? Not in this restaurant. In this place, you chop it with a huge knife while its still alive and then throw its pieces into a pan and stir fry it. Now had the cook set the expectation that he’d be seeing something else, he may not have gone into the kitchen.

The same thing happens with presentations. Why do people not like a presentation? Sometimes its because it was just a bad presentation. But most of the time, its because expectations weren’t set up front. If you don’t set expectations up front, you let the audience’s expectations become the baseline and you as a presenter have no ability to meet a room full of different expectations. If you set the expectations of what will be seen and the style, then the audience has two options: accept it (stay) or reject it (leave). Either way, you are in control.

So It Doesn’t Matter What Style I use (Live Coding/Snippits/Slides Of Code)?

Like any presentation, you need to use the best medium for communicating your message and address the risks associated.

Want to do live coding? Great! Make sure you set your font and IDE colour scheme, ensure that it’ll work and compile in its finished state (use the Julia Childe method*), test out the available wi-fi to ensure its reliable if your presentation requires it, ensure all updates and required components are installed to your machine/VM ahead of time, ensure all background running processes (virus scanner, auto updates, etc.) are turned off ahead of time, etc. etc.

Want to do slides of codes? Fantastic! Make sure you’re ready to answer questions about how to do things differently/more advanced than what’s on your slides. Make sure you check that your code is readable on your slides, the background/style doesn’t clash, and remember that if you’re using image snapshots of code that you can’t change the font on it so it better be big enough for the guy in the back row to read. Oh, and make sure that your version of PowerPoint or whatever tool you created your presentation with is usable with the version on the presentation computer (if its different than your own).

Presentations are Tools to Communicate Your Idea

I do a talk on how to give technical presentations as well as a presentation workshop, and the one thing I stress is that your PowerPoint, your code, your demos, your whatever isn’t as important as you. You and your knowledge is the reason people are coming to a presentation. You need to pick the tools and techniques that will ensure that you will communicate your message to the audience.

You won’t every please everyone that comes to your presentations. But if you set expectations and give thought to the tools/techniques you’ll employ, you can limit the negative comments and ensure more people leave understanding what you were trying to get across.

Nokia: Your vision is clouded

rodelljr — Tue, 14 May 2013 22:26:24 GMT

Originally posted on: http://geekswithblogs.net/rodelljr/archive/2013/05/15/nokia-your-vision-is-clouded.aspx

In the last week or so we have seen two new phones announced by Nokia: the Lumia 928 and 925. The 925 version looks to be the next evolution in Nokia’s lineup of Lumia devices while the 928 at a glance looks like a variation of the original 920, with maybe some parts of the 925 mixed in. You of course get a great camera experience with the low light PurView system.

While you can view the 925 specs here, I will note that unlike previous Lumia’s (including the 928), the 925 only has 16 GB of storage instead of 32 GB. This wouldn’t be a problem if it had expandable memory, but it doesn’t. That’s right, if you play games that take a lot of storage, or like to save music playlists on your device, this could be an issue. Most likely it won’t for the average user. That is really the only flaw I can see in the hardware itself. It looks stunning and if by some miracle I can get a unit to review, I will defiantly enjoy playing with it. I haven’t really done any phone reviews, but would love the opportunity to begin doing just that. As a developer, its nice to have that ability to play with new hardware and try testing your apps on it.

Now I mentioned flaw in hardware, but this article is more about Nokia itself. While I love their products; (I own a Lumia 800), I completely disagree with their distribution model. While they seem to be trying to be like Samsung and flood the market with handsets, they are doing it as if they are Apple. Please stop. If you really want to compete with Samsung, follow their model that they had done with their Galaxy S3 and S4 and build it for all the carriers. Stop doing this limited distribution. Releasing the 925 to only T-Mobile in the US is a mistake. Its bad enough that the 920 was restricted to AT&T, but to follow that same model again a year later is wasteful. Now before I get any comments, this also applies to Canada and other countries who are only getting partial carrier coverage

That whole exclusive type distribution model has only really worked once, and that was by Apple. Even HTC has learned their lesson somewhat with the HTC One, but that is a whole other argument. The Lumia line is basically THE best that Windows Phone has to offer, and as long as your vision is clouded, it may prove to be the end of Windows Phone. We can’t expect Windows Phone to get any market share increases with this limited distribution model.

This also doesn’t just apply to the 925, but should apply for a few of their other models. The midrange phones like the 820 would defiantly benefit from being on multiple carriers in the US and abroad. You could probably include the lower end tier and include the 620 or 521 in that list. Basically think of it as a small, medium and large model where you have three phones for all carriers. I also wouldn’t stop their. I would include the smaller market carriers like Cricket. Taking this approach will go along way.

With all this said and done, will I buy a 925 or 928? Unfortunately no. I carry a Galaxy S3 as my carrier doesn’t carry Windows Phone yet. And before any one asks, I can’t switch carriers for another year, and few months. I switched from AT&T for reasons I won’t explain here. Other than my minor rants, I really love the Nokia handsets and can’t wait to either review or use their developer borrow program to test my Windows Phone apps.

Extending Team Explorer 2012 – Associating Recent Work Items

Jakob Ehn — Thu, 16 May 2013 11:29:44 GMT

Originally posted on: http://geekswithblogs.net/jakob/archive/2013/05/16/extending-team-explorer-2012-ndash-associating-recent-work-items.aspx

Extension available at: http://visualstudiogallery.msdn.microsoft.com/9ed2d30c-a692-42b0-a21d-cdc8d2bf322c

I have been playing around a bit lately with extending Team Explorer 2012, mostly because it is fun but also to fix a little nagging feature that should have been there from the beginning. Often I (and a lot of other people) find myself wanting to associate several consecutive changesets to the same work item. The problem is that Team Explorer does not remember this, instead I have to either remember the ID or use a query that hopefully will match the work item.

Where is the work item that I just associated with?

True, when using the My Work page and the teams and sprint backlogs are correctly setup, you can find “your” work items there, but every so often this is not the case, and off I go to locate that work item again.

So this seemed to be a good feature to implement and at the same time learn a little about how to extend Team Explorer in Visual Studio 2012.

There is a great sample posted by Microsoft over at MSDN, it also talks about the main extension points and classes/interfaces that you need to know about. You can find it here: http://code.msdn.microsoft.com/windowsdesktop/Extending-Explorer-in-9dccd594. If you have developed extensions to Visual Studio before, you will be relieved to know that this new extension model for Team Explorer is purely based on standard .NET/WPF and MEF, no weird COM interfaces.

You can add new pages to Team Explorer, you can add new sections to existing pages and you can add navigation links to the Home screen. All these extensions are discovered by Team Explorer using the Managed Extensibility Framework (MEF). You just need to attribute your classes with the correct attribute and it will be found by Team Explorer. The attributes also control where your extension will appear. This extension is a Section that should appear inside the Pending Changes page:

Example of attributing a Team Explorer extension

The last property (35) is a priority number that controls when the extension is created and also where it will placed relative to the other sections. The existing Related Work Items section has priority 30, so 35 will place our extension right below it.

We also need to implement the ITeamExplorerSection interface, that contains properties and methods that needs to be implemented for anything to show up.

ITeamExplorerSection interface

The most interesting property here is the SectionContent property which is where you return the content of your extensions. This is typically a WPF user control in which you can add any controls you like.

This is how the extension appear inside the Pending Changes page. It will analyze your recent changesets in the current team project and extract the last 5 associated work items and show them in a list.
From the list you can then easily add a work item to the current pending changes by right-clicking on it and select Add. You’ll note that the work item will then disappear from the list, since you are not likely interested in adding it again.

Recently Associated Work Item section

I encourage you to read the MSDN article for more information about the possibilities to extend Team Explorer 2012. Also, try out the extension and let me know it you find it useful!

Special Tampa WPUG meeting - How I became a Millionaire writing apps!

Nikita Polyakov — Wed, 15 May 2013 04:48:44 GMT

Originally posted on: http://geekswithblogs.net/campuskoder/archive/2013/05/15/152930.aspx

DO NOT MISS THIS 5/21 6PM : Special Tampa WPUG meeting - How I became a Millionaire writing apps!

If you are in Tampa the night of 5/21 you should not have any excuses not to show up to this event. There should not even be any giveaways (especially this awesome) because I am sure this will be a sold out event. Be there (early) or be square.

http://tampawpugmay21.eventbrite.com/

Tampa Windows Phone User Group
Tuesday, May 21, 2013 from 6:00 PM to 8:00 PM (EDT)

Powershell functions to get an xml node, and get and set an xml element’s value, even when the element does not already exist

deadlydog — Thu, 16 May 2013 17:18:18 GMT

Originally posted on: http://geekswithblogs.net/deadlydog/archive/2013/05/16/powershell-functions-to-get-an-xml-node-and-get-and.aspx

I’m new to working with Xml through PowerShell and was so impressed when I discovered how easy it was to read an xml element’s value. I’m working with reading/writing .nuspec files for working with NuGet. Here’s a sample xml of a .nuspec xml file:

APress Deal of the Day 17/May/2013 - Pro HTML5 with Visual Studio 2012

TATWORTH — Fri, 17 May 2013 01:40:33 GMT

Originally posted on: http://geekswithblogs.net/TATWORTH/archive/2013/05/17/apress-deal-of-the-day-17may2013---pro-html5-with.aspx

Today's $10 deal of the day from APress at http://www.apress.com/9781430246381 is Pro HTML5 with Visual Studio 2012

"Pro HTML5 with Visual Studio 2012 is written to help ASP.NET developers make the leap to the inevitable and exciting world of HTML5. "

Why I Chose WordPress Over Geeks With Blogs, And Moving From WordPress.com To A GoDaddy Hosted Solution

deadlydog — Fri, 17 May 2013 17:57:31 GMT

Originally posted on: http://geekswithblogs.net/deadlydog/archive/2013/05/17/why-i-chose-wordpress-over-geeks-with-blogs-and-moving.aspx

A while back I wrote about some reasons why I didn’t like GWB (Geeks With Blogs) and was attracted to WordPress. 6 months later and I am confident that I made the right decision. GWB was good to me, but…

Exploiting the Non-Uniqueness of Guids

Chris Gardner — Fri, 17 May 2013 08:48:42 GMT

Originally posted on: http://geekswithblogs.net/freestylecoding/archive/2013/05/17/exploiting-the-non-uniqueness-of-guids.aspx

You know those seemingly random Guids? Guess what? They're not random.

I'll give your head a moment to recover from that bombshell.

Ok, back with me? Good.

I was digging DEEP in some hardcore specs when I stumbled upon this. I had a situation where I have a Guid as a unique identifier. This identifier had some subsequent child data that needed to refer to the global object but required different handling. Yes, I'm being slightly vague. I do have to respect company proprietary data.

Due to this dilemma, I had a really weird "hash table" to quickly find the identifier from the child object. While this solution worked, and was REALLY fast, it was very messy and complex. I decided I needed to hack something to reduce this complexity.

I know. I just said I wanted to reduce complexity, and that my solution was to hack Guids. The sick humor of this is not wasted on me. You knew what you're getting into when you read my blog.

Turns out, there is a status field in the Guid. I was scouring the Wikipedia article on Guids when I read the Binary Encoding section. Turns out 3 of the bits have a special meaning. More specifically, if you were dealing with the Guid 00000000-0000-0000-x000-000000000000, part of the hex value of x means something. Guids in .NET, generated by the System.Guid structure, are all "standard" Guids. As such, they will always have the bit mask of 00000000-0000-0000-8000-000000000000.

If you don't believe me, go do a select on your largest database column. That hex value will always be either 8, 9, A or B.

If we exploit this, we now have 2 bits in our 128 bit number which we can control. We know those 2 bits being 10 will refer to our master identifier. However, since they are fixed, we can use 00, 01 and 11 as attached, but still unique, child Guids. This child Guids will always point back to the parent Guid by restoring those 2 bits to 10.

Happy Friday, people.

I was surfing io13 and found this interesting article from google

foxjazz — Fri, 17 May 2013 00:08:42 GMT

Originally posted on: http://geekswithblogs.net/foxjazz/archive/2013/05/16/i-was-surfing-io13-and-found-this-interesting-article-from.aspx

http://readwrite.com/2013/05/01/10-technology-skills-no-longer-in-demand

copied here just in case the link breaks.

10. Something That Seems Secure Today

The TIOBE Programming Community Index lists C, Java, C++ and Objective-C as the programming skills most in demand right now. But here's the thing. In 2009, Objective-C was barely in use. The rapid success of the iPhone and iPad vaulted the language's popularity. Now, however, just over three years later, its popularity is already stabilizing.

In today's superheated technology environment, even the most popular, most secure seeming technology skills can suddenly become obsolete. That's just the way it is. No matter how in-demand your current skill set, you can never rest on your resume.

Learning Is The Key

Will highlighting the wrong skill set to a recruiter brand you as out of touch - or too expensive to hire? Perhaps. But don't expect anyone to tell you that's what going on. More likely, they may just won't return your call, or let your resume vanish into the ether. (There will probably always be a few legacy jobs in all these areas, but that's about it.)

The only solution is to keep learning - and keep showing that youcan learn. While the pace of skills disruption may well be increasing, learning new skills has never been easier. That includes formal schooling as well as free and low-cost resources like Khan Academy and CodeAcademy, for example.

Here's the bottom line: Since so much technology is fairly new to everyone, why should a company invest in experienced candidates - rather than someone just starting out? Writing forThe Wall Street Journal, business professor and entrepreneur Vivek Wadhwa, was brutally direct:

It may be wrong, but look at this from the point of view of the employer. Why would any company pay a computer programmer with out-of-date skills a salary of say $150,000, when it can hire a fresh graduate — who has no skills — for around $60,000? Even if it spends a month training the younger worker, the company is still far ahead.

It's not just about the money, of course. To justify any salary, it's not only about what you know - now - but what you can learngoing forward. The key to a long career in Silicon Valley, or anywhere in the tech world, is showing that you can learn and adapt - and master - constant change.

Good luck!

Things to Watch out for with a Production system in Microsoft Azure

ryanabr — Sun, 19 May 2013 02:27:34 GMT

Originally posted on: http://geekswithblogs.net/ryanabr/archive/2013/05/19/things-to-watch-out-for-with-a-production-system-in.aspx

At Industrack,we migrated our production backend to Azure. Our platform is a real-time data collection system of GPS data streaming from remote devices. For the most part it is working well, there are some gaps in services that I am expecting from Azure that hard are hard to find from external vendors. Microsoft has a 99.9% SLA on their Azure services that covers Maintenance windows an transient errors as well that arise from load throttling other intermittent connection failures.

I have notices that since Microsoft has been trying to get so much out into the hands of developers lately that they are sacrificing some of their historical consistency. For example, we decided to upgrade our Enterprise Library from 4.1 to 5.0. Ent Lib 6.0 was not an option for us at this point as we had dependencies on shard libs that have to work on Windows XP. Ent Lib 6.0 is compiled with .NET 4.5, which is not supported on Windows XP. That said, I ended up having to recompile the Azure TransientFaultHandling Block locally anyway as it had dependencies on an earlier version of the Azure SDK that I was using.

For those that are using any Azure services, you should be using the TransientFaultHandling block for handling retries to the service. It has some nice classes for allowing you to define different retry strategies.

SQL Azure has been working well, although we ran in to an instance where we ran our of space in the tier of database that we had (5GB) and we lost 2 hours of data before we noticed that connections were failing with an exception that described the problem, however, it seems like the admin on the Azure account SHOULD have received a notification of the condition so it could be resolved. It is an easy fix, go to the admin screen and pick the next tier of SQL and click save! But some notification here would have saved me some big headaches.

We are using the Service Bus to consolidate the data from the different endpoints we support which has also been working well. However, I recommend spending time learning about Prefetch, Deadlettering, and PeekLock to use the queues in an efficient manner

We are just starting to use SQL Reporting in Azure and so far this looks promising. If you do have a current installation of SSRS that you are thinking of migrating, make sure you look at the list of things NOT supported in SSRS for Azure to make sure you are aware of all the things in your current reports that might not work as well as scheduling and delivery.

So far my only real disappointment is in the Azure VM area. so far this has proven very unreliable with the VMs restarting unannounced on the order of 1 time per week or so. I have no idea why it restarts, but from what I have read it can happen due to hardware failures and the platform moving the VM to different hardware and restarting it. but again, with NO NOTIFICATION! We cannot manage something that does not alert us when actions like this are being taken.

In general the whole Monitoring area of Azure is missing. When you consider the tools that Microsoft has for monitoring, System Center, and the capabilities it brings to table, the fact that these features are missing from Azure is really disappointing. If that kind of monitoring was available out of the box, Azure would truly be a Word Class platform differentiating itself from Amazon, Google, etc.

SCCM2012SP1 – How to download prerequisites for offline installation

Waclaw Chrabaszcz — Sun, 19 May 2013 01:28:29 GMT

Originally posted on: http://geekswithblogs.net/Wchrabaszcz/archive/2013/05/19/sccm2012sp1--how-to-download-prerequisites-for-offline-installation.aspx

Sometimes your datacenter polices disallows to have Internet access from servers. Let's prepare ourselves for offline installation.

Go to ADK download site and save on your PC ADKsetup.exe http://www.microsoft.com/en-us/download/details.aspx?id=30652
Execute it with parameter
adksetup.exe /layout c:\ADK
Mount SCCM ISO and execute
H:\SMSSETUP\BIN\X64\setupdl.exe C:\SCMMprereq

time for coffee …

PowerShell Idiosyncrasy Explained

PointsToShare — Sun, 19 May 2013 03:59:23 GMT

Originally posted on: http://geekswithblogs.net/PointsToShare/archive/2013/05/19/powershell-idiosyncrasy-explained.aspx

Doug Finke, A PowerShell MVP tested it in .Net where it fails as well. He explained that The call is ambiguous between the following methods or properties: 'System.Math.Floor(decimal)' and 'System.Math.Floor(double)'

My understanding is that PowerShell convert variables as it "pleases". 1/5 will most likely convert to float.

There maybe another approach to doing it w/o the [Math]::Floor. It is the format it with "{0:N0}", then use the D2 format.

$i = 1
$j = "{0:N0}" -f $i/5
$k = "{0:D2}" -f $j

AND IT WORKS!! This is probably better than the [Math]::Floor

That’s All Folks

Enterprise Architecture – SOA with a Dash of PubSub

Dylan Smith — Sun, 19 May 2013 13:40:50 GMT

Originally posted on: http://geekswithblogs.net/Optikal/archive/2013/05/19/152956.aspx

The past few weeks I’ve been helping a client come up with an Enterprise Architecture and I realized that I seem to have zero’d in on an EA that I would probably use at most places.

First off what do I mean by Enterprise Architecture? I know lots of people use this to mean different things, for this post I’m using the term Enterprise Architecture to describe how the various applications and systems in an Enterprise will interconnect and integrate with each other (where necessary). Effective Enterprise Architecture should enable powerful integration scenarios and application re-use, while encouraging loose coupling to minimize the cost of change and impact of change on other systems.

The EA described below relies on Web Services and a SOA approach, while also leveraging the PubSub (Publish/Subscribe) pattern common in Message-Based Architecture.

While this Enterprise Architecture describes the external interfaces each system exposes, and how data flows between them, it does not describe the inner workings of each specific System (that’s the Application Architecture). Having a well-thought out Enterprise Architecture enables flexibility in choosing Application Architectures. Within each system you can choose to use a different Application Architecture, or even change a System’s Application Architecture in the future with minimal impact on other systems.

Integration at the Database

Most teams I encounter do integration exclusively by reading/writing directly from each Systems’ databases. Although the majority of software teams out there probably do integration by database, in my experience the majority of software teams also deeply regret this decision. Integrating at the DB level tightly couples Applications to the database schema design, making it risky to ever change that design. It also limits reuse of application logic limiting you to the reuse of data only.

Service Oriented Architecture

Enterprise Architecture consists of breaking down the software ecosystem into independent Systems, and defining a well-known way for those Systems to integrate and/or exchange data. A common approach to manage this integration is to take a SOA approach, and wrap each system in a (Web) Service with a well-defined Service Contract. This moves the inter-system dependencies to the Service Layer rather than the Database layer. At first glance this would seem to simply move the coupling from the DB to the Service Contract, making it risky to ever change the Service Contract. However, it does enable re-use of application logic in addition to data. But more importantly there are well-known techniques to evolve Service Contracts while maintaining compatibility.

The most common approach to Service evolution is to expose separate End-Points for each version of the Service Contract. This way if you wish to modify the Service Contract, you publish a new End-Point with the new Service Contract while leaving the End-Point with the previous Service Contract active. Then implement a compatibility layer that translates service calls from the old Service Contract to the new Service Contract. This way the core System logic needs only support the most recent version of the Service Contract. It also provides a convenient place to introduce logging to understand which Systems are still depending on the old Service Contracts and plan the upgrade work required to move them to the new Service Contract, enabling the eventual retirement of older Service Contracts/End-Points.

PubSub Pattern

The introduction of an SOA approach, would be a marked improvement over integration at the DB level, however there are still challenges with a Service only approach to integration:

Availability - Service-level integration introduces availability concerns. Imagine a scenario where System A depends on Systems B, C, and D via their Service Contract. System A either needs to retrieve data from B/C/D to perform some work, or some operation in System A needs to request B/C/D to perform an operation as part of the System A operation (or often both of the above). If any of the B/C/D systems become un-available it will also impact the availability of System A, as now any System A operations that interact with B/C/D will also fail. System A’s availability is now tied to B, C, and D’s availability.

Coupling - Let’s imagine that we’re System A developers, and when some important operation in System A occurs, Systems B, C and D need to be notified so they can perform some related action. There are really two options, either B, C and D can poll the System A’s Service constantly querying to see when the relevant data in A has changed. This will have significant performance impacts on System A. The alternative is for System A to explicitly call some Service method in B/C/D when the relevant operation in System A happens. This not only incurs the availability concerns noted above, but what happens when another team develops System E that also wishes to be notified? Does the System E development team now need to ask System A’s development team to make changes to System A in order for System E to work? This is not a good situation to be in.

My approach is that in addition to wrapping every System with a Web Service, we also borrow from Message-Based Architecture and use a PubSub (Publish/Subscribe) pattern. In this pattern each System would publish “Domain Events” when things of interest occur within the System (ideally a System would publish an event every time any data owned by that System changes). Using one of the readily available messaging frameworks, this makes it easy for any System to subscribe to Events from any other System. Whenever anything of note happens in System A it simply publishes an event with the related data, and any other interested systems can subscribe to that Event and react accordingly. This way System A (from the above example) has no knowledge or dependency on the other Systems that may subscribe to its events (System E developers can create their System without having to ask System A developers to make any changes). If System A goes down it will not affect Systems B/C/D, and if System B/C/D go down it will not affect System A.

The other scenario is if System A requires some data from Systems B/C/D to perform an operation in System A. Rather than calling Service methods on B/C/D when that data is required, instead System A can subscribe to the relevant events in System B/C/D when that data changes and System A can maintain its own data cache of data “owned” by B/C/D updating it when the relevant B/C/D events are received. This way the System A operation can complete, even if B/C/D are all unavailable at the time. The important principle to keep in mind with this approach is that a given piece of data can only be “owned” by a single system. System A is free to cache data from B/C/D, but if System A wishes to change any data owned by B/C/D it must “ask” those systems to change it via the B/C/D Web Service. We also need to ensure that the messaging infrastructure we put in place has guaranteed delivery; meaning if System A happens to be down, when it comes back online it will still receive any Events that occurred while it was offline (modern messaging frameworks mostly handle this for us).

Each System under this Enterprise Architecture should look like the following:

In this case the “Core Domain” is the actual implementation of that system (we’re assuming in the above diagram that there is some Domain DB contained within it, but that’s not necessary). The actual Application Architecture contained within the Core Domain is irrelevant to the Enterprise Architecture. The “Core Domain” in this case may even be a Commercial Software package such as AX or SAP.

In the case of a Commercial Software system, it often won’t support the Enterprise Architecture proposed here. In that case we need to wrap it with the appropriate integration layer to support the Enterprise Architecture. Consider the below example of a Dynamics AX System:

In the case of AX I believe it already exposes a Web Service, however, in the case that it didn’t and AX Integration was performed some other way (e.g. DB integration, copying files in a specific format to a specific directory, etc) we would create a custom Web Service that exposed those integration methods over a Service Contract (we don’t want any non-AX Systems talking directly to the AX Database except AX itself, and any Integration Layer we would write). Likewise, AX doesn’t publish Domain Events (and even if it did it wouldn’t do so using the Messaging framework we chose), again we can write some plumbing code to add support for this. In the above diagram we are writing a custom component “AX Event Generator” that would poll the AX Database looking for interesting changes in data and would raise the appropriate Domain Events that other Systems could subscribe to (some COTS Systems may have some notification system or way to “hook” system events eliminating the need to poll the DB). If we wanted AX to respond to Domain Events from other Systems, we would write a simple Event Consumer component that subscribed to Domain Events from other systems and executed the appropriate action in AX.

Using this approach, for other Systems to integrate with AX they no longer need to understand AX Database schema, they don’t need to understand any unusual integration mechanism that AX may use, they only need to understand the Web Service Contract and the Domain Events raised by the AX System (just like every other System).

Typically System-To-System Communication is done primarily via Domain Events. Clients (i.e. UI’s) primarily communicate via the Web Service(s).

SharePoint QuicLaunch Maker with PowerShell

PointsToShare — Sun, 19 May 2013 05:44:04 GMT

Originally posted on: http://geekswithblogs.net/PointsToShare/archive/2013/05/19/sharepoint-quiclaunch-maker-with-powershell.aspx

At times I create so many sites and sub-sites that the Top-Nav cannot handle it. It is better to add the new links to the Quick Launch.

The function below makes it a snap.

Here is how it is used:

The first line inserts a heading "OrgSites" under the "Lists" heading (already there) in the QuickLaunch.

New-SPNode -Web $siteurl -NodeText "OrgSites" -NodeLink "Head" -NodeParent "Lists"

TAnd this line inserts the URL of a site named $web1name and the URL $web1url unter the new "OrgSites" heading

New-SPNode -Web $siteurl -NodeText $web1name -NodeLink $web1url -NodeParent "OrgSites"

Here (FINALLY!!) is the function

# New-SPNode creates an entry in the QuickLaunch navigation
# $Web is the URL of the site
# A node is made of text - $NodeText and link - $NodeLink
# If the link says "Head", then the node is a heading, else it is assumed a URL
# If "Head" then the heading is added immediately under The parent heading ($NodeParent)
# No checking for a URL being a URL
# Nodes are always added last
# Nodes are added under $NodeParent

function New-SPNode {
    [CmdletBinding()]
    Param(
    [Parameter(Mandatory=$true,ValueFromPipeline=$true)]
    [string]$Web,
    [Parameter(Mandatory=$true)]
    [string]$NodeText, #"Head" if Heading
    [Parameter(Mandatory=$true)]
    [string]$NodeLink,
    [Parameter(Mandatory=$true)]
    [string]$NodeParent
    )
Start-SPAssignment -Global
$SPWeb = Get-SPWeb -Identity $Web
$QL = $SPWeb.Navigation.QuickLaunch # QuickLaunch
$PrevHead = $QL | where {$_.Title -eq $NodeParent}
# Check if heading
If ($NodeLink -eq "Head")
{
      $NewHead = New-Object Microsoft.SharePoint.Navigation.SPNavigationNode($NodeText, "")      $QL.Add($NewHead, $PrevHead) | Out-Null

}
else
{
$NewNode = New-Object Microsoft.SharePoint.Navigation.SPNavigationNode($NodeText, $NodeLink)

Write-Host "New-SPNode: " $Web " " $NodeText " " $NodeParent -ForegroundColor Blue -Backgroundcolor magenta
$PrevHead.Children.AddAsLast($NewNode) | Out-Null
}
$SPWeb.Dispose()
Stop-SPAssignment -Global

}

That's All Folks!!

ReadOnlyObservableCollection

Patrice Calvé — Sun, 19 May 2013 11:38:22 GMT

Originally posted on: http://geekswithblogs.net/Patware/archive/2013/05/19/152957.aspx

Use a ReadOnlyObservableCollection when you allow people to subscribe to changes to a collection, without allowing them to make changes to the collection.

ReadOnlyObservableCollection is a object from System.Collections.ObjectModel.

ReadOnly: Because there's no Add/Remove method
Observable: When an item is added or removed, it will fire an event (INotifyCollectionChanged).

But, if it's ReadOnly, how can it be Observable? Because the object is actually a wrapper to a "real" collection. When you create a new instance of this object, in the constructor, you need to specify a "real" collection.

So, you actually need two objects:

A private, modifyable, observable collection
A public, ReadOnlyObservableCollection

Here's a simple console app example to illustrate the use. Persons is public but ReadOnly, whereas _myPeople is private, unexposed, but modifiable.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
namespace ConsoleApplicationForTestingCollections
{
    class Program
    {
        static void Main(string[] args)
        {
            var ds = new DataService();
            ds.Init();
            // Note 1: here that we're using a "readonly" collection...
            Console.WriteLine(ds.Persons[0].FullName);
            Console.Read();
        }
    }
    public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string FullName
        {
            get { return string.Format("{0} {1}", FirstName, LastName); }
        }
    }
    public class DataService
    {
        public ReadOnlyObservableCollection<Person> Persons { get; private set; }
        private ObservableCollection<Person> _myPeople;
        public DataService()
        {
            _myPeople = new ObservableCollection<Person>();
            this.Persons = new ReadOnlyObservableCollection<Person>(_myPeople);
        }
        public void Init()
        {
            // Note 2: here, we're adding an item in a private, unexposed, collection
            _myPeople.Add(new Person() { FirstName = "Foo", LastName = "Bar" });

        }
    }
}

Windows 8 for Developers Online Camp

Joe Mayo — Mon, 20 May 2013 10:01:52 GMT

Originally posted on: http://geekswithblogs.net/WinAZ/archive/2013/05/20/windows-8-for-developers-online-camp.aspx

On May 21st, Ziff Davis is hosting an eSeminar, Windows 8 for Developers Online Camp. Speakers include Greg Levenhagen, @GregLevenhagen, and myself. Here’s the agenda:

- Building a Windows 8 App in 15 minutes or less.
- Where is Microsoft headed, how it differs from others (Apple/Google), and why it makes sense.
- Win8 Development versus Android, iOS, and Pre-Win8 Dev
- What’s Different in Building for Windows 8?
- Understanding the potential to Make Money With Windows 8
- What it takes to submit an app (It’s not that hard)
- What help is available? (There is some very good, free help and tools available)
- Next Steps / Getting Started

@JoeMayo

Another cause of Internal Error 2761 - BizTalk 2013

Michael Stephenson — Mon, 20 May 2013 15:45:49 GMT

Originally posted on: http://geekswithblogs.net/michaelstephenson/archive/2013/05/20/152964.aspx

I had another occasion where I was getting the internal error 2761 error when trying to install BizTalk 2013.

This time it was not related to the "Run as Administrator" trap I fell into a couple of weeks ago. This time the cause was that I had not activated MS Office 2013. So before installing BizTalk 2013 remember to open and activate your install of Office 2013

Capturing HTTP traffic on an iPhone with Fiddler

Scott Wojan — Mon, 20 May 2013 02:26:53 GMT

Originally posted on: http://geekswithblogs.net/wojan/archive/2013/05/20/152961.aspx

This is a simple update to the great entry at http://conceptdev.blogspot.com/2009/01/monitoring-iphone-web-traffic-with.html with the new Fiddler interface.

1. Get Fiddler
Download Fiddler

2. Set-up Fiddler
Start Fiddler then open the Tools > Fiddler Options... window

and in the Connections tab, ensure:

"Allow remote computers to connect" is checked.
"Act as system proxy on startup" is checked.
Note or change what port is set (eg. 8888).

Once you've saved those settings you need to stop and re-start Fiddler.

3. Ensure Fiddler is 'listening'
Once Fiddler has re-started, verify that the Capture Traffic menuitem is ticked.

4. Check the 'listening' IP
You need to know your computer's wireless-network IP address to configure the iPhone. This screenshots shows the Command Prompt > ipconfig output:

5. Set-up iPhone Settings
With the computer IP address and Fiddler port, go to your iPhone's Wifi Settings and scroll down to the HTTP Proxy, choose Manual and input the Fiddler proxy info:

(remember to switch back to Off when you're done)

6. 'sniff' away
If everything has been setup right, anything you do in Safari or other internet based applications will be logged in the Fiddler window.

It's extremely useful for testing/debugging - have fun!

Don't forget to UNDO the iPhone settings when you're finished!!

What is Application Domain (AppDomain)...?

Pavan Kumar Pabothu — Mon, 20 May 2013 08:10:22 GMT

Originally posted on: http://geekswithblogs.net/pabothu/archive/2013/05/20/what-is-application-domain-appdomain.aspx

When we launch the Notepad program in Windows, the program executes inside of a container known as a process. We can launch multiple instances of Notepad, and each instance will run in a dedicated process. Using the Task Manager application, we can see a list of all processes currently executing in the system.

A process contains the executable code and data of a program inside memory it has reserved from the operating system. There will be at least one thread executing instructions inside of the process, and in most cases there are multiple threads. If the program opens any files or other resources, those resources will belong to the process.

A process is also boundary. Erroneous code inside of a process cannot corrupt areas outside of the current process. It is easy to communicate inside of a process, but special techniques are required to communicate from one process to another. Each process also runs under a specific security context which can dictate what the process can do on the machine and network.

A process is the smallest unit of isolation available on the Windows operating system. This could pose a problem for an ISP who wants to host hundreds of ASP.NET applications on a single server. The ISP will want to isolate each ASP.NET application to prevent one application from interfering with another company’s application on the same server, but the relative cost of launching and executing a process for hundreds of applications may be prohibitive.

Introducing the Application Domain

.NET introduces the concept of an application domain, or AppDomain. Like a process, the AppDomain is both a container and a boundary. The .NET runtime uses an AppDomain as a container for code and data, just like the operating system uses a process as a container for code and data. As the operating system uses a process to isolate misbehaving code, the .NET runtime uses an AppDomain to isolate code inside of a secure boundary.

Note, however, that the application domain is not a secure boundary when the application runs with full trust. Applications running with full trust can execute native code and circumvent all security checks by the .NET runtime. ASP.NET applications run with full trust by default.

An AppDomain belongs to only a single process, but single process can hold multiple AppDomains. An AppDomain is relatively cheap to create (compared to a process), and has relatively less overhead to maintain than a process. For these reasons, an AppDomain is a great solution for the ISP who is hosting hundreds of applications. Each application can exist inside an isolated AppDomain, and many of these AppDomains can exist inside of a single process – a cost savings.

AppDomains And You

You’ve created two ASP.NET applications on the same server, and have not done any special configuration. What is happening?

A single ASP.NET worker process will host both of the ASP.NET applications. On Windows XP and Windows 2000 this process is named aspnet_wp.exe, and the process runs under the security context of the local ASPNET account. On Windows 2003 the worker process has the name w3wp.exe and runs under the NETWORK SERVICE account by default.

An object lives in one AppDomain. Each ASP.NET application will have it’s own set of global variables: Cache, Application, and Session objects are not shared. Even though the code for both of the applications resides inside the same process, the unit of isolation is the .NET AppDomain. If there are classes with shared or static members, and those classes exist in both applications, each AppDomain will have it’s own copy of the static fields – the data is not shared. The code and data for each application is safely isolated and inside of a boundary provided by the AppDomain

In order to communicate or pass objects between AppDomains, you’ll need to look at techniques in .NET for communication across boundaries, such as .NET remoting or web services.

Note again: the one caveat to the idea of an AppDomain as a boundary is that ASP.NET applications will run with full trust by default. Fully trusted code can execute native code, and native code can essentially have access to anything inside the process. You’ll need to run applications with partial trust to restrict access to unmanged code and verify all managed code to secure AppDomains.

Shadow Copies and Restarts

Once an assembly is loaded into an AppDomain, there is no way to remove the assembly from the AppDomain. It is possible, however, to remove an AppDomain from a process.

If you copy an updated dll into an application’s bin subdirectory, the ASP.NET runtime recognizes there is new code to execute. Since ASP.NET cannot swap the dll into the existing AppDomain , it starts a new AppDomain. The old application domain is “drain stopped”, that is, existing requests are allowed to finish executing, and once they are all finished the AppDomain can unload. The new AppDomain starts with the new code and begins taking all new requests.

Typically, when a dll loads into a process, the process locks the dll and you cannot overwrite the file on disk. However, AppDomains have a feature known as Shadow Copy that allows assemblies to remain unlocked and replaceable on disk.

The runtime initializes ASP.NET with Shadow Copy enabled for the bin directory. The AppDomain will copy any dll it needs from the bin directory to a temporary location before locking and loading the dll into memory. Shadow Copy allows us to overwrite any dll in the bin directory during an update without taking the web application offline.

Master Of Your Domain

Application domains replace the OS process as the unit of isolation for .NET code. An understanding of application domains will give you an idea of the work taking place behind the scenes of an ASP.NET application. Using the CurrentDomain property of the AppDomain class you can inspect properties about the AppDomain your code is executing in, including the Shadow Copy settings we discussed in this article.

Source: http://odetocode.com/articles/305.aspx

Uncaught SyntaxError: Unexpected token u. file JavaScript Error in MVC

Aligned — Mon, 20 May 2013 06:45:39 GMT

Originally posted on: http://geekswithblogs.net/Aligned/archive/2013/05/20/uncaught-syntaxerror-unexpected-token-u.-file-javascript-error-in-mvc.aspx

I was getting a JavaScript error that pointed to line number 1 of my MVC page. I have a form on the page and expected the Unobtrusive Validation to work with the Data Annotations. It took me a while to realize the validation messages weren't showing. After I while I found that I was missing the @Html.ValidationMessageFor(m => m.Name). Adding that for each field fixed it.

My password reset with token example. I was missing line 12 and 17.

   1:  @using (Html.BeginForm("PasswordReset", "Home"))

   2:  {

   3:      @Html.AntiForgeryToken()

   4:      @Html.ValidationSummary()

5:

   6:      <fieldset>

   7:          <legend>@HomeViewResource.ChangePasswordFormTitle</legend>

   8:          <ol>

   9:              <li>

  10:                  @Html.LabelFor(m => m.PasswordResetModel.NewPassword)

  11:                  @Html.PasswordFor(m => m.PasswordResetModel.NewPassword)

  12:                  @Html.ValidationMessageFor(m => m.PasswordResetModel.NewPassword)

  13:              </li>

  14:              <li>

  15:                  @Html.LabelFor(m => m.PasswordResetModel.ConfirmPassword)

  16:                  @Html.PasswordFor(m => m.PasswordResetModel.ConfirmPassword)

  17:                  @Html.ValidationMessageFor(m => m.PasswordResetModel.ConfirmPassword)

  18:              </li>

  19:          </ol>

  20:          <input type="submit" class="btn btn-primary" value="@HomeViewResource.ChangePasswordButtonText" />

  21:      </fieldset>

22:

  23:      @Html.HiddenFor(m => m.PasswordResetToken)

  24:      @Html.HiddenFor(m => m.UserId)

  25:  }

New Book: Pro Team Foundation Service

Jakob Ehn — Mon, 20 May 2013 16:27:33 GMT

Originally posted on: http://geekswithblogs.net/jakob/archive/2013/05/20/new-book-pro-team-foundation-service.aspx

The last couple of months I have been working together with Mathias Olausson, Mattias Sköld and Joachim Rossberg on a new book project for Apress that has just been published. The book is called Pro Team Foundation Service and covers all aspects of working with Team Foundation Service, Microsoft's hosted version of Team Foundation Server in the cloud. I have mainly worked on the chapter related to automated build and continuous deployment, but also with some of the other chapters.

It has been a quite hectic project due to a tight schedule, but at the same time it has been a lot of fun to work on this book together with late night meetings and weekends filled with book writing and chapter editing.

During the project we’ve had great help from several people at Microsoft, Jamie Cool, Will Smythe, Anutthara Bharadwaj, Ed Blankenship and Vijay Machiraju. Also a big thanks to Brian Harry for writing the foreword to the book. In addition I’d like to thank my colleague Terje Sandstrøm for helping out with Technical Review of large parts of the book.

Here is some information about the book, you can find it on Amazon here:
http://www.amazon.com/Team-Foundation-Service-Mathias-Olausson/dp/1430259957#_

Check it out and let us know what you think!

Pro Team Foundation Service gives you a jump-start into Microsoft’s cloud-based ALM platform, taking you through the different stages of software development. Every project needs to plan, develop, test and release software and with agile practices often at a higher pace than ever before.
Microsoft's Team Foundation Service is a cloud-based platform that gives you tools for agile planning and work tracking. It has a code repository that can be used not only from Visual Studio but from Java platforms and Mac OS X. The testing tools allow testers to start testing at the same time as developers start developing. The book also covers how to set up automated practices such as build, deploy and test workflows.

This book:

· Takes you through the major stages in a software development project.

· Gives practical development guidance for the whole team.

· Enables you to quickly get started with modern development practices.

With Microsoft Team Foundation Service comes a collaboration platform that gives you and your team the tools to better perform your tasks in a fully integrated way.

What you’ll learn

· What ALM is and what it can do for you.

· Leverage a cloud-based ALM platform for quick improvements in your development process.

· Improve your agile development process using integrated tools and practices.

· Develop automated build, deployment and testing processes.

· Integrate different development tools with one collaboration platform.

· Get started with ALM best-practices first time round.

Who this book is for

Pro Team Foundation Service is for any development team that wants to take their development practices to the next level. Microsoft Team Foundation Service is an excellent platform for managing the entire application development lifecycle and being a cloud-based offering it is very easy to get started. Pro Team Foundation Service is a great guide for anyone in a team who wants to get started with the service and wants to get expert guidance to do it right.

Table of Contents

1. Introduction to Application Lifecycle Management

2. Introduction to Agile Planning, Development, and Testing

3. Deciding on a Hosted Service

4. Getting Started

5. Working with the Initial Product Backlog

6. Managing Team and Alerts

7. Initial Sprint Planning

8. Running the Sprint

9. Kanban

10. Engaging the Customer

11. Choosing Source Control Options

12. Working with Team Foundation Version Control in Visual Studio

13. Working with Git in Visual Studio

14. Working in Heterogeneous Environments

15. Configuring Build Services

16. Working with Builds

17. Customizing Builds

18. Continuous Deployment

19. Agile Testing

20. Test Management

21. Lab Management

New version of Syncfusion Metro Studio V2

ihaynes — Tue, 21 May 2013 07:52:11 GMT

Originally posted on: http://geekswithblogs.net/ihaynes/archive/2013/05/21/new-version-of-syncfusion-metro-studio.aspx

Syncfusion have released an updated version of their free Metro Studio V2.

If you've not seen it before it's a collection of 2500 'Modern UI' style icons which you can edit/modify and use without restriction in apps, websites etc.

See http://www.syncfusion.com/downloads/metrostudio

ssis error deploying package

Alex Bransky — Mon, 20 May 2013 17:13:57 GMT

Originally posted on: http://geekswithblogs.net/influent1/archive/2013/05/20/152966.aspx

I was getting the error below when trying to deploy to my SQL 2008 R2 cluster, which was odd since I had never had any trouble before. The problem ended up being that when I double clicked on the SSISDeploymentManifest file my computer was using the SQL 2012 version of the deployment utility because I had recently installed it. Once I used the 2008 utility everything worked fine.

Exception details: Microsoft.SqlServer.Dts.Runtime.DtsRuntimeException: Storing or modifying packages in SQL Server requires the SSIS runtime and database to be the same version. Storing packages in earlier versions is not supported.

---> System.Runtime.InteropServices.COMException: Storing or modifying packages in SQL Server requires the SSIS runtime and database to be the same version. Storing packages in earlier versions is not supported.

Xat.com Image Optimiser - a little known tool for RWD

ihaynes — Tue, 21 May 2013 03:30:40 GMT

Originally posted on: http://geekswithblogs.net/ihaynes/archive/2013/05/20/152970.aspx

An article in the July 2013 issue of .Net Magazine, "Optimise your site for mobile", highlights the importance of image optimisation and has a link to a list of tools for the job.

This mentions several well known tools but misses one of the oldest and best, Xat's Image Optimiser. I've used this for many years and, despite having more modern tools, still come back to this when I want the tightest optimisation.

It handles jpegs, gifs and pngs with appropriate settings for each. For jpegs it has a 'MagiCompression' mode as well as the normal settings. This applies different levels of compression to areas of an image depending on the complexity of the content. It works very well and can make a big difference. The only thing you need to be aware of is that if you open such an image again in an ordinary editor, this variable compression will be lost.

There is a batch wizard and are also tools for image resizing, cropping, adding text to images, filling areas with colour etc.

The product costs $49 which seems expensive in todays market but I've definitely had my moneys worth over the years and with image optimisation being critical for responsive design, will do so again and again.

Download the trial and try it out. You'll be impressed with the results.

http://www.xat.com/io/

APress Deal of the Day 21/May/2013 - Pro Application Lifecycle Management with Visual Studio 2012

TATWORTH — Tue, 21 May 2013 12:03:49 GMT

Originally posted on: http://geekswithblogs.net/TATWORTH/archive/2013/05/21/apress-deal-of-the-day-21may2013---pro-application-lifecycle.aspx

Today's $10 Deal of the Day from APress at http://www.apress.com/9781430243441 is Pro Application Lifecycle Management with Visual Studio 2012

"Pro Application Lifecycle Management with Visual Studio 2012 focuses on the most powerful application lifecycle management tool available for the Microsoft .NET Framework: Visual Studio Team Foundation Server."

Tech Learning–Always Start with Hello World

D'Arcy Lussier — Wed, 15 May 2013 07:20:01 GMT

Originally posted on: http://geekswithblogs.net/dlussier/archive/2013/05/15/152931.aspx

I was talking with an attendee at Prairie Dev Con about this last week, and how we can easily get caught up in fulfilling the domain rather than understanding the underlying tech.

Consider these two scenarios, both related to learning ASP.NET MVC with EF code first.

Create a single view in an MVC project that uses EF to retrieve a simple value of “Hello World” from a database table and display it on the screen.

Unburden yourself from complex domain contexts when you’re starting out with something new. Start with Hello World and take it from there.

Tech Learning–Always Start with Hello World

D'Arcy Lussier — Wed, 15 May 2013 07:20:01 GMT

Originally posted on: http://geekswithblogs.net/dlussier/archive/2013/05/15/152931.aspx

I was talking with an attendee at Prairie Dev Con about this last week, and how we can easily get caught up in fulfilling the domain rather than understanding the underlying tech.

Consider these two scenarios, both related to learning ASP.NET MVC with EF code first.

Create a single view in an MVC project that uses EF to retrieve a simple value of “Hello World” from a database table and display it on the screen.

Unburden yourself from complex domain contexts when you’re starting out with something new. Start with Hello World and take it from there.

.NET Security Part 3

simonc — Thu, 16 May 2013 10:52:00 GMT

Originally posted on: http://geekswithblogs.net/simonc/archive/2013/05/16/.net-security-part-3.aspx

Defining assemblies as fully-trusted

In my last post, I mentioned that when you create a sandboxed appdomain, you can pass in a list of assembly strongnames that run as full-trust within the appdomain:

// get the Assembly object for the assembly
Assembly assemblyWithApi = ...    

// get the StrongName from the assembly's collection of evidence
StrongName apiStrongName = assemblyWithApi.Evidence.GetHostEvidence<StrongName>();

// create the sandbox
AppDomain sandbox = AppDomain.CreateDomain(
    "Sandbox", null, appDomainSetup, restrictedPerms, apiStrongName);

So now you have a class that you want the sandboxed code to call:

// within assemblyWithApi
public class MyApi
{
    public static void MethodToDoThings() { ... }
}

// within the sandboxed dll
public class UntrustedSandboxedClass
{
    public void DodgyMethod()
    {        
        ...
        MyApi.MethodToDoThings();
        ...
    }
}

However, if you try to do this, you get quite an ugly exception:

MethodAccessException: Attempt by security transparent method 'UntrustedSandboxedClass.DodgyMethod()' to access security critical method 'MyApi.MethodToDoThings()' failed.

Security transparency and AllowPartiallyTrustedCallersAttribute

So the solution is easy, right? Make MethodToDoThings SafeCritical, then the transparent code running in the sandbox can call the api:

[SecuritySafeCritical]
public static void MethodToDoThings() { ... }

However, this doesn't solve the problem. When you try again, exactly the same exception is thrown; MethodToDoThings is still running as Critical code. What's going on?

So, to allow the sandboxed assembly to call the full-trust API assembly, simply add APCTA to the API assembly:

[assembly: AllowPartiallyTrustedCallers]

and everything works as you expect. The sandboxed dll can call your API dll, and from there communicate with the rest of the application.

Conclusion

.NET Security Part 3

simonc — Thu, 16 May 2013 10:52:00 GMT

Originally posted on: http://geekswithblogs.net/simonc/archive/2013/05/16/.net-security-part-3.aspx

Defining assemblies as fully-trusted

In my last post, I mentioned that when you create a sandboxed appdomain, you can pass in a list of assembly strongnames that run as full-trust within the appdomain:

// get the Assembly object for the assembly
Assembly assemblyWithApi = ...    

// get the StrongName from the assembly's collection of evidence
StrongName apiStrongName = assemblyWithApi.Evidence.GetHostEvidence<StrongName>();

// create the sandbox
AppDomain sandbox = AppDomain.CreateDomain(
    "Sandbox", null, appDomainSetup, restrictedPerms, apiStrongName);

So now you have a class that you want the sandboxed code to call:

// within assemblyWithApi
public class MyApi
{
    public static void MethodToDoThings() { ... }
}

// within the sandboxed dll
public class UntrustedSandboxedClass
{
    public void DodgyMethod()
    {        
        ...
        MyApi.MethodToDoThings();
        ...
    }
}

However, if you try to do this, you get quite an ugly exception:

MethodAccessException: Attempt by security transparent method 'UntrustedSandboxedClass.DodgyMethod()' to access security critical method 'MyApi.MethodToDoThings()' failed.

Security transparency and AllowPartiallyTrustedCallersAttribute

So the solution is easy, right? Make MethodToDoThings SafeCritical, then the transparent code running in the sandbox can call the api:

[SecuritySafeCritical]
public static void MethodToDoThings() { ... }

However, this doesn't solve the problem. When you try again, exactly the same exception is thrown; MethodToDoThings is still running as Critical code. What's going on?

So, to allow the sandboxed assembly to call the full-trust API assembly, simply add APCTA to the API assembly:

[assembly: AllowPartiallyTrustedCallers]

and everything works as you expect. The sandboxed dll can call your API dll, and from there communicate with the rest of the application.

Conclusion

.NET Security Part 3

simonc — Thu, 16 May 2013 10:52:00 GMT

Originally posted on: http://geekswithblogs.net/simonc/archive/2013/05/16/.net-security-part-3.aspx

Defining assemblies as fully-trusted

In my last post, I mentioned that when you create a sandboxed appdomain, you can pass in a list of assembly strongnames that run as full-trust within the appdomain:

// get the Assembly object for the assembly
Assembly assemblyWithApi = ...    

// get the StrongName from the assembly's collection of evidence
StrongName apiStrongName = assemblyWithApi.Evidence.GetHostEvidence<StrongName>();

// create the sandbox
AppDomain sandbox = AppDomain.CreateDomain(
    "Sandbox", null, appDomainSetup, restrictedPerms, apiStrongName);

So now you have a class that you want the sandboxed code to call:

// within assemblyWithApi
public class MyApi
{
    public static void MethodToDoThings() { ... }
}

// within the sandboxed dll
public class UntrustedSandboxedClass
{
    public void DodgyMethod()
    {        
        ...
        MyApi.MethodToDoThings();
        ...
    }
}

However, if you try to do this, you get quite an ugly exception:

MethodAccessException: Attempt by security transparent method 'UntrustedSandboxedClass.DodgyMethod()' to access security critical method 'MyApi.MethodToDoThings()' failed.

Security transparency and AllowPartiallyTrustedCallersAttribute

So the solution is easy, right? Make MethodToDoThings SafeCritical, then the transparent code running in the sandbox can call the api:

[SecuritySafeCritical]
public static void MethodToDoThings() { ... }

However, this doesn't solve the problem. When you try again, exactly the same exception is thrown; MethodToDoThings is still running as Critical code. What's going on?

So, to allow the sandboxed assembly to call the full-trust API assembly, simply add APCTA to the API assembly:

[assembly: AllowPartiallyTrustedCallers]

and everything works as you expect. The sandboxed dll can call your API dll, and from there communicate with the rest of the application.

Conclusion

Nokia: Your vision is clouded

rodelljr — Tue, 14 May 2013 22:26:24 GMT

Originally posted on: http://geekswithblogs.net/rodelljr/archive/2013/05/15/nokia-your-vision-is-clouded.aspx

Nokia: Your vision is clouded

rodelljr — Tue, 14 May 2013 22:26:24 GMT

Originally posted on: http://geekswithblogs.net/rodelljr/archive/2013/05/15/nokia-your-vision-is-clouded.aspx

Extending Team Explorer 2012 – Associating Recent Work Items

Jakob Ehn — Thu, 16 May 2013 11:29:44 GMT

Originally posted on: http://geekswithblogs.net/jakob/archive/2013/05/16/extending-team-explorer-2012-ndash-associating-recent-work-items.aspx

Extension available at: http://visualstudiogallery.msdn.microsoft.com/9ed2d30c-a692-42b0-a21d-cdc8d2bf322c

So this seemed to be a good feature to implement and at the same time learn a little about how to extend Team Explorer in Visual Studio 2012.

Example of attributing a Team Explorer extension

We also need to implement the ITeamExplorerSection interface, that contains properties and methods that needs to be implemented for anything to show up.

ITeamExplorerSection interface

Recently Associated Work Item section

I encourage you to read the MSDN article for more information about the possibilities to extend Team Explorer 2012. Also, try out the extension and let me know it you find it useful!