Free eBook: Introducing Microsoft SQL Server 2012

By DimitriC at March 16, 2012 09:16
Filed Under: Books, Documentation, Microsoft, SQL, Technet, Training

SOURCE 

 

665156.indd

From the source:

 

Friends, the final and complete version of Introducing Microsoft SQL Server 2012, by Ross Mistry (@RossMistry) and Stacia Misner (@StaciaMisner), is now ready as a free download! You can download the PDF version of this title here (288 pages; 10.8 MB).

 

We will update this post soon with links to EPUB and MOBI files. We expect these files to be available by March 23. If you prefer a hard copy of the book, you can order it here for $14.99.

 

 

Introducing Microsoft SQL Server 2012 includes 10 chapters:

 

PART I   DATABASE ADMINISTRATION (by Ross Mistry)

1.   SQL Server 2012 Editions and Engine Enhancements

2.   High-Availability and Disaster-Recovery Enhancements

3.   Performance and Scalability

4.   Security Enhancements

5.   Programmability and Beyond-Relational Enhancements

 

PART II   BUSINESS INTELLIGENCE DEVELOPMENT (by Stacia Misner)

6.   Integration Services

7.   Data Quality Services

8.   Master Data Services

9.   Analysis Services and PowerPivot

10.   Reporting Services

TechDays 2012: session recordings, slides and content online - Katrien's MSDN Blog - Site Home - MSDN Blogs

By DimitriC at March 15, 2012 14:32
Filed Under: Community, Microsoft, Training

What is "binding" and what makes it late?

By DimitriC at February 14, 2012 08:39
Filed Under: Programming, Training

Another interesting post on Eric Lipper’s blog. In this post, he explains his understanding of the concept of “late binding” (with a couple of small samples).

 

Read the full article here.

BOOK: Putt's Law and the Successful Technocrat: How to Win in the Information Age

By DimitriC at January 10, 2012 09:13
Filed Under: Books, General, Training

Putt's Law and the Successful Technocrat: How to Win in the Information Age

 

As many of you, I too have this huge pile of books somewhere in the house correctly named by Homer J. Simpson as “the to-read-pile”. One of the books that’s been on there quite a while is “Putt's Law and the Successful Technocrat: How to Win in the Information Age” by Archibald Putt (a pseudonym).

 

The books handles the topic on how to be successful in a hierarchy of companies (or departments) whose core business is technology. Sometimes, you read a Dilbert-cartoon and laugh going “it’s funny cause it’s true”. I’ve had that with this book all the time. I’ve read its 170 pages in two days and had to agree for many times with the author’s description of the reality we live in. When it seems that management takes weird decisions, absurd conclusions,… this books explains why they have. I absolutely recommend this book for everyone who is in the technology-business.

 

Interested in the book?

 

United States (in $) / United Kingdom & Europe (in £)

Visual Studio 11 Developer Preview

Found the MSDN newsletter in my mailbox this morning. First topic that caught my eye: Visual Studio 11 Dev Preview! Another one? Indeed!!! So here is some more information on the new kid on the block.

 

What's New in Visual Studio 11 Developer Preview

Visual Studio 11 Developer Preview Training Kit

 

.NET Framework 4.5 Developer Preview

Security Development Lifecycle resources

There are a bunch of new SDL resources available on the Microsoft Security Development Lifecycle page. For every step in the software development process (Requirements, Design, Implementation, Verification, Release) there are tools and/or training videos available. For a video giving an overview of the SDL tools, click here.

 

Source

 

Requirements

Templates:

- SDL Process Template for Visual Studio Team System 2008

- MSF-Agile + SDL Process Template for Visual Studio Team System 2010

- MSF-Agile + SDL Process Template for Visual Studio Team System 2008

 

Videos:

 

 

Design

 

SDL Threat Modeling Tool

 

For more information on the treat modeling tool, click here.

 

Implementation

 

FxCop 

 

FxCop analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements. For more information, click here. Watch the video here.

 

Anti-Cross Site Scripting Library

 

This is specifically designed to help mitigate the potential of Cross-Site Scripting (XSS) attacks in web-based applications. Watch the video here.

 

Microsoft Code Analysis Tool .NET

 

CAT.NET is a binary code analysis tool that helps identify common variants of certain prevailing vulnerabilities that can give rise to common attack vectors such as Cross-Site Scripting (XSS), SQL Injection, and XPath Injection. Watch the video here.

 

 

Verification

BinScope Binary Analyzer

 

BinScope Binary Analyzer is a verification tool that analyzes binaries to ensure that they have been built in compliance with the SDL requirements and recommendations. Watch the video here.

 

SDL MiniFuzz File Fuzzer

 

MiniFuzz is a basic testing tool designed to help detect code flaws that may expose security vulnerabilities in file-handling code. Watch the video here.

 

AppVerifier

 

Application Verifier is a runtime verification tool for native code that assists in finding subtle programming errors that can be difficult to identify with normal application testing. For more information, click here.

 

SDL Regex Fuzzer

 

SDL Regex Fuzzer is a verification tool to help test regular expressions for potential denial of service vulnerabilities. Watch the video here.

 

Attack Surface Analyzer Beta

 

Attack Surface Analyzer is a tool that highlights the changes in system state, runtime parameters and securable objects on the Windows operating system.

 

 

Release

The release resources are the same templates and videos as the ones in the Requirements section.

Visual Studio LightSwitch

By DimitriC at August 31, 2011 17:07
Filed Under: Documentation, Microsoft, Programming, Visual Studio, Training, tools & Utilities

The first post I did about this was the announcement of it's beta release. The final version has been available for a while now, so here we go :)

 

What is Visual Studio LightSwitch?

Microsoft Visual Studio LightSwitch is a simplified self-service development tool that enables you to build business applications quickly and easily for the desktop and cloud. What can your business do with LightSwitch? Watch this brief introduction to find out.

 

Links & resources:

Visual Studio LightSwitch page
MSDN LightSwitch Development Center
Visual Studio LightSwitch Technical White Paper Series

 

LightSwitch videos:

 

Overview with Jason Zander
Build Custom Business Apps. Coding Optional.

Introductory videos

Creating Your First Business Application
Data, Queries and Code in LightSwitch 2011
Controlling Access to Your Business Application
Publishing Your LightSwitch Application

Advanced videos

Understanding the LightSwitch Architecture
Deploying Your Application to the Cloud
Advanced LightSwitch Customization
Advanced LightSwitch Extensions

Extension videos

DevExpress LightSwitch Extensions
Infragistics LightSwitch Extensions
RSSBus LightSwitch Extensions

Microsoft All-in-one code framework

Something I found that might come in handy:

 

The Microsoft All-In-One Code Framework is a free, centralized code sample library driven by developers' needs. Our goal is to provide typical code samples for all Microsoft development technologies, and reduce developers' efforts in solving typical programming tasks.

 

Codeplex page

Download (from Codeplex)

Request a code sample

 

For a full list of downloads (sorted by technology), please check the Codeplex download page. There are samples available for C++, ASP.NET, Silverlight, Azure, Office, Windows, WPF, Windows Security, and many more…

Book: Algorithms of the intelligent web

By DimitriC at March 31, 2011 18:40
Filed Under: Books, Architecture, Programming, Training

clip_image001

 

A very interesting read, written by Haralambos Marmanis, Dmitry Babenko, on how the web provides us with a rich user experience with the help of algorithms. Topics such as ranking and recommendation systems are explained very well and are illustrated with examples. Also, API's from well known sites such as Google, eBay and Facebook are discussed.

 

The book on amazon.

The Job Interview: Technical questions (Pt. V)

By DimitriC at March 28, 2011 19:16
Filed Under: General, Training, tips & tricks

Here’s one that you might run into when being screened for a technical position: the brain teaser. The point here, usually, is not to see if you can solve a riddle. But more to see how your mind works when an unusual problem arises (see it as creative problem solving). I’ll go over some of the types of questions you may encounter and I’ll also give some references for who like this kind of stuff Smile.

 

The Fermi-question

The answers to these kind of questions are based on estimates and a logical thought-process that accompanies these estimates to derive a valid answer. Often you won’t find the correct answer, but the idea is to get very close. Some of the popular Fermi-questions are: “How many piano tuners are there in the world?” or “How many gas stations are there in the United States of America?”. A bad way to answer these questions is to just give a number and be done with it.

 

On wikipedia you can find a good example of this: “How many piano tuners are there in Chicago?

Next to wikipedia, here is another great resource on the subject: Science Olympics. Here you will also find many examples of Fermi-problems. Some neat ones:

 

- How many golf balls will fit in a suitcase?
- How many hairs are there on a human head?
- If your life earnings were doled out to you by the hour, how much is your time worth per hour?
- People crowd into London until all available open space within the city limits is covered with standing people. How many people would there be?

 

More information about Fermi problems in general can be found on Wikipedia.

 

Creative-thinking question

These are actually just weird questions. Again, keep in mind that the purpose of these questions is to see how you approach a problem that is new to you. For instance: “How are m&m’s made?”, “Without looking at specifications, what is the weight of a Boing 747?” “Why are soda cans produced in that shape?” “Why are manhole covers round?”

 

Some of these questions can be about things that you know. If you know how m&m’s are made, just answer. If you just now looked at you soda can and asked yourself “Why is it made like that?”, you might want to do some thinking. The answer can be simple: They are made like that cause that way they stack easy. The answer can also be scientific: The curves in the can make sure that the build up pressure inside the can doesn’t make the can go boom. If it would be a metal cylinder with the same thickness of steel everywhere, the can probably can’t stand the build up of pressure inside the can.

 

Mathematical questions

 

These questions often have a certain way of looking at a problem to find the solution. Typically, with these questions, when someone gives you the answer you go “aaaahhhhh…of course”. A very famous one here is the riddle that John McClane (played by Bruce Willis) and Zeus Carver (Samuel L Jackson) had to solve in Die Hard: With a Vengeance: You have a jug that can contain 5 liters (let’s call it J5) and a jug that can contain 3 liters (J3). Now, you need to get exactly 4 liters  in the 5-liter-jug. Solution (let’s use water, just like in the movie Smile ):

 

- fill J3 with water

- poor J3 into J5

- fill J3 again with water

- fill J5 to the top (now you added 2 liters, so you have 1 liter in J3)

- empty J5

- fill J5 with the 1 liter from J3

- fill J3

- poor J3 into J5

 

And now J5 contains 4 liters of water.

 

Another one: You have 8 billiard balls. They all have exactly the same weight, except for one. You have a weighing scale like this:

 

 

You need to find the billiard ball that has a different weight with the least amount of weighings.

 

Answer: You can find the billiard ball in two weighings.

 

Put three billiard balls on each side of the scale. If the scale balances to a side, you know in which batch of three the crooked ball is. Now you put one ball of this batch on each side of the scale. If it balances to a side you know which ball is crooked, if it doesn’t, the crooked ball is the remaining one. If in the measurement of 3 versus 3 the scale stays in balance, you just need to measure the remaining two.

 

This can also be done with 9 billiard balls, here when the scale balances to one side in the first weighing, the crooked ball is in the last batch of three. And you still have to just weigh two of them to find the crooked billiard ball.

 

 

 

As you can see, there are many examples of these kinds of questions. You can spend a lot of time surfing the web searching for these questions.

 

There are also several books that cover this subject. Often these books also cover other subjects I talked about in these series (algorithms, programming questions,…)

 

- How would you move Mount Fuji?(William Poundstone)

- Programming Interviews Exposed (John Mongan, Noah Suojanen, Eric Giguère)

- Puzzles for programmers and pros (Dennis Shasha)

- Cracking the coding interview (Gayle Laakmann)

 

…and probably many more Smile

The Job Interview: Technical questions (Pt. IV)

By DimitriC at March 21, 2011 19:56
Filed Under: Programming, Training

An often requested piece of code is a sort algorithm. Of course, there are many sorting algorithms as you can see with our good friend wikipedia. A popularly one is the Bubble sort. In it’s essence it’s not a difficult algorithm once you know how it works. But in interviews it’s usually the case that you haven’t had to implement it for a long time or maybe you’ve just graduated and have never heard of it (but then you shouldn’t have graduated or the people responsible for your curriculum need a good talking to!) A good alternative for the bubble sort is the Insertion sort.

 

A short description:

 

“…a simple sorting algorithm that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. “ – Source: Wikipedia

The algorithm:

   1: void BubbleSort(int[] intArray)
   2: {
   3:     int tmp;
   4:     for (int i = intArray.Length - 1; i >= 0; i--)
   5:     {
   6:         for (int j = 1; j <= i; j++)
   7:         {
   8:             if (intArray[j - 1] > intArray[j])
   9:             {
  10:                 tmp = intArray[j - 1];
  11:                 intArray[j - 1] = intArray[j];
  12:                 intArray[j] = tmp;
  13:             }
  14:         }
  15:     }
  16: }

 

 

An example of using the method above:

 

   1: void Main(string[] args)
   2: {
   3:     int[] intArray = new int[] { 2, 8, 4, 9, 5, 1 };
   4:     PrintArray(intArray);
   5:     BubbleSort(intArray);
   6:     Console.WriteLine();
   7:     PrintArray(intArray);
   8:  
   9:     Console.ReadKey();
  10: }
  11:  
  12: public static void PrintArray(int[] intarray)
  13: {
  14:     foreach (int number in intarray)
  15:     {
  16:         Console.WriteLine(number);
  17:     }
  18: }

 

…gives the following output:

 

image

Free Microsoft e-books

A new list of free e-books on Microsoft technologies has been released on the Microsoft Press blog. Below is the list of available books (including sample code if available).

Programming Windows Phone 7 (Charles Petzold) PDF - Sample Code C# - Sample Code VB.NET
Introducing Microsoft SQL Server 2008 R2 (Ross Mistry and Stacia Misner) XPS - PDF
Understanding Microsoft Virtualization Solutions, From the Desktop to the Datacenter (Mitch Tulloch) XPS - PDF
Introducing Windows Server 2008 R2 (Charlie Russel and Craig Zacker with the Windows Server Team at Microsoft) XPS - PDF
First Look Microsoft Office 2010 (Katherine Murray) XPS - PDF
Deploying Windows 7, Essential Guidance (Mitch Tulloch, Tony Northrup, Jerry Honeycutt, Ed Wilson,...)  PDF
Moving to Microsoft Visual Studio 2010 (Patrice Pelland, Pascal Paré, and Ken Haines) XPS - PDF - Sample Code

 

(original post)

The Job Interview: Technical questions (Pt. II)

By DimitriC at March 09, 2011 19:10
Filed Under: Programming, Training, tips & tricks

Let’s have a look at a binary tree. In my implementation of the binary tree, I use a property to keep track of the fact that the node in question is the root node (= the node where the tree begins), the Parent-property. This refers to the node that has the current node as one of it’s children (or leafs). You can of course browse through your entire tree to find the node that’s not referenced by any other node, but that will probably take a lot of checks, especially if you have a big binary tree. Even when it’s a small binary tree I would use this property. It makes it easier to navigate through the tree.

 

   1: public class BTNode
   2: {
   3:     public BTNode LeftNode { get; set; }
   4:     public BTNode RightNode { get; set; }
   5:     public BTNode Parent { get; set; }
   6:  
   7:     public int value;    
   8:  
   9:     public BTNode(int val)
  10:     {
  11:         this.value = val;
  12:     }
  13:  
  14:     public void AddNode(BTNode newNode)
  15:     {
  16:         newNode.Parent = this;
  17:  
  18:         if (newNode.value >= this.value)
  19:         {
  20:             if (RightNode == null)
  21:             {
  22:                 RightNode = newNode;
  23:             }
  24:             else
  25:             {
  26:                 RightNode.AddNode(newNode);
  27:             }
  28:         }
  29:         else
  30:         {
  31:             if (LeftNode == null)
  32:             {
  33:                 LeftNode = newNode;
  34:             }
  35:             else
  36:             {
  37:                 LeftNode.AddNode(newNode);
  38:             }
  39:         }
  40:     }
  41:  
  42:     public BTNode Search(int srchValue)
  43:     {
  44:         if (srchValue == this.value)
  45:         {
  46:             return this;
  47:         }
  48:  
  49:         if (srchValue >= this.value)
  50:         {
  51:             if (this.RightNode == null)
  52:             {
  53:                 return null;
  54:             }
  55:             else
  56:             {
  57:                 return this.RightNode.Search(srchValue);
  58:             }
  59:         }
  60:         else
  61:         {
  62:             if (this.LeftNode == null)
  63:             {
  64:                 return null;
  65:             }
  66:             else
  67:             {
  68:                 return this.LeftNode.Search(srchValue);
  69:             }
  70:         }
  71:     }
  72:  
  73:     public void Delete()
  74:     {
  75:         //bottom of tree
  76:         if (this.LeftNode == null && this.RightNode == null)
  77:         {
  78:             if (this.Parent.LeftNode.value == this.value)
  79:             {
  80:                 this.Parent.LeftNode = null;
  81:             }
  82:             else
  83:             {
  84:                 this.Parent.RightNode = null;
  85:             }
  86:         }
  87:  
  88:         //Middle of tree - RightNode
  89:         if (this.LeftNode == null && this.RightNode != null)
  90:         {
  91:             if (this.Parent.LeftNode.value == this.value)
  92:             {
  93:                 this.Parent.LeftNode = this.RightNode;
  94:             }
  95:             else
  96:             {
  97:                 this.Parent.RightNode = this.RightNode;
  98:             }
  99:         }
 100:  
 101:         //Middle of tree - LeftNode
 102:         if (this.LeftNode != null && this.RightNode == null)
 103:         {
 104:             if (this.Parent.LeftNode.value == this.value)
 105:             {
 106:                 this.Parent.LeftNode = this.LeftNode;
 107:             }
 108:             else
 109:             {
 110:                 this.Parent.RightNode = this.LeftNode;
 111:             }
 112:         }
 113:  
 114:         if (this.LeftNode != null && this.RightNode != null)
 115:         {
 116:             if (this.Parent == null)
 117:             {
 118:                 throw new ApplicationException("You can not delete the root node!");
 119:             }
 120:  
 121:             if (this.Parent.LeftNode.value == this.value)
 122:             {
 123:                 this.Parent.LeftNode = this.LeftNode;
 124:                 this.LeftNode.RightNode = this.RightNode;
 125:             }
 126:             else
 127:             {
 128:                 this.Parent.RightNode = this.RightNode;
 129:                 this.RightNode.LeftNode = this.LeftNode;
 130:             }
 131:         }
 132:     }

 

To use it, you instantiate a node and assign new BTNodes to the leaves. Wherever you are in the tree-structure, you’ll find it easy to search for nodes. Keep in mind that the AddNode and Delete only reflect on the current node.

The Job Interview: Technical questions (Pt. I)

By DimitriC at March 01, 2011 08:56
Filed Under: Programming, Training

Ever since I graduated I’ve been employed as a .NET consultant. When applying for jobs (whether it’s at a consultancy firm or as a representative of your firm getting interviewed by a client) there is often a technical interview. Next to the fun object-orientation questions we all love so much (explain polymorphism, data abstraction, inheritance, Liskov’s substitution principle,…), there were sometimes these little exercises they used to test your approach to problem solving or to see how you react to a very unfamiliar problem. These questions can take different forms. You’ve got you’re here-is-a-piece-of-code-and-tell-me-what-the-output-is-questions, mathematical problems, writing code,…Even brain-teasers can be a part of the interview. 

 

In the “writing code” department you can be asked to write well known data structures yourself (e.g.: write your own linked list/binary tree), write an algorithm (sorting algorithm,search algorithm, reversing collections,…). The meaning of this series is to discuss some of these questions, find out where the pitfalls are and see what side-questions might be added to the exercise.

 

So let’s get to it! As a first exercise, let’s look at an implementation of a linked list.  In the .NET Framework, you can find a linked list in the System.Collections.Generic library.

 

For our basic implementation we need a Node-class where we can hold the references for the previous and the next item in the list. We’ll immediately keep references to both the next and the previous node as we’ll notice that it might be handy to navigate through the list. This is already a more complex version of a linked list (since the most simplistic version only holds the reference to the next node).

 

   1: public class Node
   2: {
   3:     private Node prevNode;
   4:     private Node nxtNode;
   5:     private string strValue;
   6:  
   7:     public Node(Node prevNode, Node nxtNode, string stringValue)
   8:     {
   9:         this.prevNode = prevNode;
  10:         this.nxtNode = nxtNode;
  11:         this.strValue = stringValue;
  12:     }
  13:  
  14:     public Node PrevNode
  15:     {
  16:         get { return this.prevNode; }
  17:         set { this.prevNode = value; }
  18:     }
  19:  
  20:     public Node NxtNode
  21:     {
  22:         get { return this.nxtNode; }
  23:         set { this.nxtNode = value; }
  24:     }
  25:  
  26:     public string StringValue
  27:     {
  28:         get { return this.strValue; }
  29:         set { this.strValue = value; }
  30:     }
  31:  
  32:     public void Delete()
  33:     {
  34:         this.prevNode.nxtNode = this.nxtNode;
  35:         this.nxtNode.prevNode = this.prevNode;
  36:     }
  37: }

 

This is a basic node-class. As a value I chose a string, but of course, that can be anything you want. This node is what we’ll use to create our list. We’ll have a list-object that contains the first node, and of course, since each node points to the next one in the list, the list-object will contain all the methods to navigate through the list.

 

   1: public class LinkedList
   2: {
   3:     public LinkedList(string stringValue)
   4:     {
   5:         nCurrent = new Node(null, null, stringValue);
   6:         nCurrent.NxtNode = null;
   7:         nCurrent.PrevNode = null;
   8:     }
   9:  
  10:     int iCount = 1;
  11:     int iCurrent = 0;
  12:     Node nCurrent;
  13:  
  14:     public int Count 
  15:     { 
  16:         get{return this.iCount; }
  17:     }
  18:  
  19:     public Node CurrentNode 
  20:     { 
  21:         get{return this.nCurrent;}
  22:     }
  23:  
  24:     public Node CurrentNodeIndex 
  25:     { 
  26:         get{return this.nCurrent;}  
  27:     }
  28:  
  29:     public void AddNode(string strValue)
  30:     {
  31:         if (nCurrent.NxtNode == null)
  32:         {
  33:             nCurrent.NxtNode = nCurrent;
  34:             nCurrent = new Node(nCurrent, null, strValue);
  35:         }
  36:         else
  37:         {
  38:             nCurrent.NxtNode = nCurrent;
  39:             nCurrent = new Node(nCurrent, nCurrent.NxtNode, strValue);
  40:         }
  41:         iCount++;
  42:         iCurrent++;
  43:     }
  44:  
  45:     public void ToNext()
  46:     {
  47:         Node tmpNode = null;
  48:  
  49:         if (nCurrent.NxtNode == null)
  50:         {
  51:             throw new Exception("there is no next node!");
  52:         }
  53:         else
  54:         {
  55:             tmpNode = nCurrent;
  56:             nCurrent = nCurrent.NxtNode;
  57:             nCurrent.PrevNode = tmpNode;
  58:             iCurrent++;
  59:         }
  60:     }
  61:  
  62:     public void ToPrevious()
  63:     {
  64:         Node tmpNode = null;
  65:  
  66:         if (nCurrent.PrevNode == null)
  67:         {
  68:             throw new Exception("there is no previous node!");
  69:         }
  70:         else
  71:         {
  72:             tmpNode = nCurrent;
  73:             nCurrent = nCurrent.PrevNode;
  74:             nCurrent.NxtNode = tmpNode;
  75:             iCurrent--;
  76:         }
  77:     }
  78:  
  79:     public void GoTo(int index)
  80:     {
  81:         while (iCurrent != index)
  82:         {
  83:             if (iCurrent < index)
  84:             {
  85:                 ToNext();
  86:             }
  87:             else if (iCurrent > index)
  88:             {
  89:                 ToPrevious();
  90:             }
  91:         }
  92:     }
  93:  
  94:     public void First()
  95:     {
  96:         while (nCurrent.PrevNode != null)
  97:         {
  98:             ToPrevious();
  99:         }
 100:     }
 101: }

Now you can instantiate the list. The constructor also requires a string value to define your first element in the list. Then you’ll find the methods to navigate through the list. And the nCurrent-property of the Linked List will contain the node where you navigated to.

 

A possible variation you might get asked is a circular linked list. This means that the last element you add (which points to null) actually should point to the first element in the list. For a full theoretical explanation I refer to wikipedia.

Moving to Microsoft Visual Studio 2010 (free e-book)

By DimitriC at October 26, 2010 10:49
Filed Under: Books, Microsoft, Training, Visual Studio

Another MSDN-flash newsletter was send out covering various topics such as Windows Phone 7, PDC10, MVVM Light Toolkit for Silverlight and WPF and much more. If you want to subscribe to the MSDN-Flash newsletter (and all other available Microsoft newsletters), you can do so at the Profile Center.

 

 

Now, about the e-book:

 

The book is called “Moving to Microsoft Visual Studio 2010”, written by Ken Haines, Pascal Paré and Patrice Pelland. For more information about the authors, please check the original post on the Microsoft Press Blog. The book is divided in three parts: part I for developers moving from VS2003, Part II is for developers moving from VS2005 and part III is for developers moving from VS2008. You can provide feedback by filling out the survey on the Microsoft Learning site.

 

 

 

Download the book: PDF (18.2MB) / XPS (30.5MB)
Download the sample code

Free e-books on .NET and architecture

By DimitriC at October 12, 2010 08:07
Filed Under: Architecture, Books, Microsoft, Programming, tools & Utilities, Training

The new MSDN Flash arrived this morning, and it offered 7 free e-books (actually 6 e-books and some reference cards) on .NET and architecture. For the original article that was posted in the newsletter, click here.

 

The books:

 

- Foundations of programming (Karl Seguin)
- Microsoft Application Architecture Guide, 2nd Edition (Microsoft)

- Rob Miles C# Yellow Book 2010 (Rob Miles)

- Threading in C# (Joe Albahari)

- Improving .NET Application Performance and scalability (Microsoft)

- Applying Design Patterns (Anoop Madhusudanan)

 

And some References Cards (RefCardz) from DZone:

 

- Getting Started with WCF 4.0 (Scott Seely)

- Getting Started with Silverlight + Expression Blend (Victor Gaudioso)

- Essential F# (Chance Coble, Ted Neward)

Developing Applications for the Cloud on the Microsoft Windows Azure™ Platform

By DimitriC at September 23, 2010 10:27
Filed Under: Architecture, Programming, Training, Cloud

Microsoft patterns & practices is excited to announce the release of a new guide: Developing Applications for the Cloud on the Microsoft Windows Azure™ Platform

 

The cloud platform provides you with access to capacity on demand, fault tolerance, distributed computing, data centers located around the globe, and the capability to integrate with other platforms. Someone else is responsible for managing and maintaining the entire infrastructure, and you only pay for the resources that you use in each billing period. You can focus on using your core domain expertise to build and then deploy your application to the data center or data centers closest to the people who use it. You can then monitor your applications, and scale up or scale back as and when the capacity is required. - Source MSDN

Links:

- Code Samples
- Community

Introducing Windows Server 2008 R2 - free e-book

By DimitriC at September 14, 2010 07:17
Filed Under: Books, Documentation, Microsoft, Technet, Training, Windows Server 2008

When cruising the MSDN-forums I found the following free e-book:

 

Introducing Windows Server 2008 R2, by Charlie Russel and Craig Zacker with the Windows Server Team at Microsoft.

 

Chapter 1    What’s New in Windows Server R2    1
Chapter 2    Installation and Configuration: Adding R2 to Your World    9
Chapter 3    Hyper-V: Scaling and Migrating Virtual Machines    25
Chapter 4    Remote Desktop Services and VDI: Centralizing Desktop and Application Management    47
Chapter 5    Active Directory: Improving and Automating Identity and Access    65
Chapter 6    The File Services Role    91
Chapter 7    IIS 7.5: Improving the Web Application Platform    109
Chapter 8    DirectAccess and Network Policy Server    129
Chapter 9    Other Features and Enhancements    147
Index    163

 

source (original MSDN post)

 

Download the e-book in XPS (28 MB) or PDF (11 MB).

 

 

Microsoft Learning Product Releases for September 2010

By DimitriC at September 09, 2010 09:35
Filed Under: certification, Microsoft, Training

Erwin Chan has posted the product releases (exams, courses,...) for this month on the born to learn web site.

The products concerned are:

- Microsoft BizTalk Server 2009
- Microsoft Dynamics C5
- Microsoft Dynamics NAV 2009
- Microsoft Dynamics Sure Step
- Microsoft Office 2007 & 2010
- Microsoft Exchange Server 2010
- Microsoft Expression Blend
- Microsoft Online Services
- Microsoft SharePoint Server 2010
- Microsoft SQL Server 2008
- Microsoft Visual Studio 2008 & 2010
- Windows Server 2003 & 2008
- Windows 7

Security Development Lifecycle Developer Starter Kit

By DimitriC at September 07, 2010 09:34
Filed Under: Microsoft, Programming, Security, SQL, Training

The SDL Developer Starter Kit offers training content and labs to help you establish a standardized approach to rolling out the SDL in your organization—or enrich your existing development practices.

It consists of 14 content modules (with speaker notes, presenter guides, and sample comprehension questions) plus eight MSDN virtual labs with lab manuals—all created to help you build a customized SDL training program for your development teams. – source

Topics covered:

- Banned APIs
- Buffer Overflows
- Code Analysis
- Compiler Defenses
- Cross-Site Scripting
- Fuzz Testing
- Secure Design Principles
- Secure Implementation Principles
- Secure Verification Principles
- Security Code Review
- Source Code Annotation Language
- SQL Injection
- Threat Modeling Principles
- Threat Modeling Tool Principles

You can download the individual videos or a package containing all videos here. The size of the individual videos varies between 14,8 MB and 38,8 MB. The complete package is 324,9 MB.

SQL Server 2008 R2 Digital Tour

By DimitriC at May 17, 2010 16:08
Filed Under: SQL, Training

TechNet Flash Feed reports:

 

The SQL Server 2008 R2 Digital Tour has started. Find a host of resources on SQL Server 2008 R2, including videos, whitepapers, e-books, events, test drives and downloads . Also check out these related resources:

 

· SQL Server 2008 R2 Books Online

· SQL server 2008 R2 Lessons on Channel 9

· Tuning the Performance of Change Data Capture in SQL Server 2008

 

To go hands-on with the product, Download the Microsoft SQL Server 2008 R2 Trial.

 

 

Full Article

Architecture Journal – Issue 23 – March 2010

By DimitriC at March 26, 2010 11:41
Filed Under: Microsoft, Programming, Training, Architecture

Microsoft Visual Studio Express Editions

By DimitriC at February 19, 2010 14:24
Filed Under: Microsoft, Programming, SQL, Training, Visual Studio, tools & Utilities

iDesign Masterclass: Architecting WPF Applications

By DimitriC at February 10, 2010 09:47
Filed Under: Training, WPF

In the beginning of March (1 – 5 March), Sparkles is organizing a 5-day training on WPF Applications in Antwerp, Belgium. The course will be given by Brian Noyes, Chief Architect at iDesign.  


The target audience is any .NET developer or architect responsible for building smart client applications with WPF. Some exposure to the basics of WPF concepts is helpful. WCF familiarity is a plus.

The class uses a combination of frontal presentations, code demonstrations, and hands-on lab exercises to reinforce all of the concepts presented. The demos provide a code library to refer back to when building your own applications, and the labs help cement the key learning elements of the class using step-by-step procedures to accomplish the tasks covered 

 

For more information on the Sparkles web site, click here.
For a PDF (0,5 MB) with the full course details, click here.
Or if you directly want to register, click here.