Steve Lange @ Work

Steve Lange's thoughts on application lifecycle management, Visual Studio, and Team Foundation Server

  • Steve Lange @ Work

    Data-Driven Tests in Team System Using Excel as the Data Source

    • 3 Comments

    There is some documentation to explain this already, but below is a step-by-step that shows how to use an Excel spreadsheet as a Data Source for both unit and web tests.

    First, let’s set the stage.  I’m going to use a solution containing a class library and a web site. 

    imageSolution 

    The class library has a single class with a single method that simply returns a “hello”-type greeting. 

    namespace SimpleLibrary
    {
        public class Class1
        {
            public string GetGreeting(string name)
            {
                return "Hello, " + name;
            }
        }
    }
    For my VB friends out there:
    Namespace SimpleLibrary
        Public Class Class1
            Public Function GetGreeting(ByVal name As String) As String
                Return "Hello, " & name
            End Function
        End Class
    End Namespace

    Unit Testing

    So now I’m going to create a unit test to exercise the “GetGreeting” method.  (As always, tests go into a Test project.  I’m calling mine “TestStuff”.)

    image

    Here’s my straightforward unit test:

    [TestMethod()]
    public void GetGreetingTest()
    {
       Class1 target = new Class1();
       string name = "Steve";
       string expected = "Hello, " + name;
       string actual;
       actual = target.GetGreeting(name);
       Assert.AreEqual(expected, actual);
    }

    In VB:

    <TestMethod()> _
    Public Sub GetGreetingTest()
       Dim target As Class1 = New Class1
       Dim name As String = "Steve"
       Dim expected As String = "Hello, " & name
       Dim actual As String
       actual = target.GetGreeting(name)
       Assert.AreEqual(expected, actual)
    End Sub

    I’ll run it once to make sure it builds, runs, and passes:

    image

    I have an Excel file with the following content in Sheet1:

    image

    Nothing fancy, but I reserve the right to over-simplify for demo purposes.  :)

    To create a data-driven unit test that uses this Excel spreadsheet, I basically follow the steps you’d find on MSDN, with the main difference being in how I wire up my data source.

    I click on the ellipsis in the Data Connection String property for my unit test.

    image

    Follow these steps to set up the Excel spreadsheet as a test data source for a unit test.

    • In the New Test Data Source Wizard dialog, select “Database”. 
    • Click “New Connection”.
    • In the “Choose Data Source” dialog, slect “Microsoft ODBC Data Source” and click “Continue”.  (For additional details about connection strings & data sources, check this out.)
      image
    • In “Connection Properties”, select the “Use connection string” radio button, then click “Build”.
    • Choose if you want to use a File Data Source or a Machine Data Source.  For this post, I’m using a Machine Data Source
    • Select the “Machine Data Source” tab, select “Excel Files” and click Ok
    • Browse to and select your Excel file.
      image
    • Click “Test Connection” to make sure everything’s golden.
      image
    • Click Ok to close “Connection Properties”
    • Click Next
    • You should see the worksheets listed in the available tables for this data source.
      image
    • In my example, I’ll select “Sheet1$”
    • Click “Finish”
    • You should get a message asking if you want to copy your data file into the project and add as a deployment item.  Click Yes.
      image
    • You should now see the appropriate values in Data Connection String and Data Table Name properties, as well as your Excel file listed as a deployment item:
      image 
    • Now I return to my unit test, note that it’s properly decorated, and make a change to the “name” variable assignment to reference my data source (accessible via TestContext):
      [DataSource("System.Data.Odbc", "Dsn=Excel Files; 
      dbq=|DataDirectory|\\ExcelTestData.xlsx;defaultdir=C:\\TestData; 
      driverid=1046;maxbuffersize=2048;pagetimeout=5", "Sheet1$", 
      DataAccessMethod.Sequential), 
      DeploymentItem("TestStuff\\ExcelTestData.xlsx"), TestMethod()]
              public void GetGreetingTest()
              {
                  Class1 target = new Class1();
                  string name = TestContext.DataRow["FirstName"].ToString();
                  string expected = "Hello, " + name;
                  string actual;
                  actual = target.GetGreeting(name);
                  Assert.AreEqual(expected, actual);
              }
    Again, in VB:
    <DataSource("System.Data.Odbc", "Dsn=Excel Files;
    dbq=|DataDirectory|\ExcelTestData.xlsx;defaultdir=C:\TestData;
    driverid=1046;maxbuffersize=2048;pagetimeout=5", "Sheet1$", 
    DataAccessMethod.Sequential)> 
    <DeploymentItem("TestStuff\ExcelTestData.xlsx")> <TestMethod()> _
        Public Sub GetGreetingTest()
            Dim target As Class1 = New Class1
            Dim name As String = TestContext.DataRow("FirstName").ToString()
            Dim expected As String = "Hello, " + name
            Dim actual As String
            actual = target.GetGreeting(name)
            Assert.AreEqual(expected, actual)
        End Sub
    • Now, running the unit test shows me that it ran a pass for each row in my sheet
      image

    Yippee!

    Web Testing

    You can achieve the same thing with a web test.  So I’m going to first create a simple web test that records me navigating to the website (at Default.aspx), entering a name in the text box, clicking, submit, and seeing the results.  After recording, it looks like this.

    image

    See “TxtName=Steve”?  The value is what I want to wire up to my Excel spreadsheet.  To do that:

    • Click on the “Add Data Source” toolbar button.
    • Enter a data source name (I’m using “ExcelData”)
    • Select “Database” as the data source type, and click Next
    • Go through the same steps in the Unit Testing section to set up a data connection to the Excel file.  (Note:  If you’ve already done the above, and therefore the Excel file is already in your project and a deployment item, browse to and select the copy of the Excel file that’s in your testing project.  That will save you the hassle of re-copying the file, and overwriting.)
    • You’ll now see a Data Sources node in my web test:
      image
    • Select the parameter you want to wire to the data source (in my case, TxtName), and view its properties.
    • Click the drop-down arrow in the Value property, and select the data field you want to use.
      image
    • Now save and run your web test again.  If you haven’t used any other data-driven web tests in this project, you’ll notice that there was only one pass.  That’s because your web test run configuration is set to a fixed run count (1) by default.  To make changes for each run, click “Edit run settings” and select “One run per data source row”.  To make sure all rows in data sources are always leveraged, edit your .testrunconfig file to specify as such.
      image
    • Now run it again, and you should see several passes in your test results:
      image

    That’s it in a simple nutshell!  There are other considerations to keep in mind such as concurrent access, additional deployment items, and perhaps using system DSNs, but this should get you started.

  • Steve Lange @ Work

    Querying the TFS Database to Check TFS Usage

    • 3 Comments

    Why would you want to know how many users are actually using Team Foundation Server?  Well, for starters:

    • You want to make sure that each user in your environment using TFS is properly licensed with a TFS CAL (Client Access License). 
    • You want to show management just how popular TFS is in your environment.
    • You want to request additional hardware for TFS, and want to show current usage capacity.

    But, what if your users are spread out all over the world, so you can’t just send a simple email asking, “Hey, are you using TFS?”

    One relatively straightforward way is to ask your TFS server’s database.  TFS logs activity in a database ‘TfsActivityLogging’, specifically in a table ‘tbl_Command’.

    NOTE:  It’s not supported to go directly against the database, so take note of 2 things:

    1. Be very careful!
    2. Be clear that this isn’t supported.  This process works, but only in the absence of a supported way to query TFS usage.  Just because I work for Microsoft, doesn’t mean you can get official support from MS on this.

    All that out of the way, the simple way to do this is to use Excel:

    Open Excel.

    Go to the Data tab and select ‘From Other Sources’ in the ‘Get External Data’ group, and select ‘From SQL Server’.

    image

    The Data Connection Wizard will open.  Follow steps to connect to the SQL Server that’s used by TFS, selecting the ‘TfsActivityLogging’ database and the contained ‘tbl_Command’ table.

    image

    Enter the SQL Server name that TFS uses.  For the below, my SQL server is at ‘tfsrtm08’.

    image

    Select the ‘TfsActivityLogging’ database, then select the ‘tbl_Command’ table. Click Next.

    image

    Click Finish.

    Select how you’d like to import the table’s data.  For this example, I’m choosing ‘PivotTable Report’.

    image

    Now you’re ready to get the data you want:

    Listing All Users Who Have Touched TFS

    In the ‘PivotTable Field List’ panel on the right, select the ‘IdentityName’ field.  Your spreadsheet should look something like this:

    image

    If you just want a list of users that have touched TFS, then you’re done (in my example, I really only have 2 accounts, and one is the TFSSERVICE account that actually runs TFS).

    However, if you want a little extra information about your users’ activities, you can do a couple extra things.

    List Users and Their Relative Activity Levels

    Add the ‘ExecutionCount’ field to the ‘Values’ section of the PivotTable, and you’ll see the number of commands each user has run against TFS (some minor, like gets, and other major, like changing ACL’s):

    image

    List Users and Their Specific Activity Levels

    Add first the ‘ExecutionCount’ field to the ‘Values’ section of the PivotTable, then add the ‘Command’ field to the ‘Row Labels’ section:

    image

    (Again, remember that some of these commands are less significant than others, but still indicate user activity.)

    List Users and Their Clients

    Add the ‘UserAgent’ field to the ‘Row Labels’ section of the PivotTable:

    image

    List Users and Their Last Activity Time

    Add ‘IdentityName’ to the ‘Row Labels’ section of the PivotTable and ‘StartTime’ to the ‘Values’ section.  Then click ‘Count of StartTime’ (in the Values section) and select ‘Value Field Settings’.  Change the ‘Summarize the value field by’ value to ‘Max’.

    image

    Click ‘Number Format’ and set the format to ‘Date’.  Click OK.  You’ll now see the last activity date for each user.

    image 

    I hope this helps!

    Other Tip:

    • You’ll probably see (like in my example) the built-in accounts and their activities (i.e. TFSSERVICE, perhaps TFSBUILD as well).  You may want to filter those ones out from your report.
    • I’ve heard conflicting reports about how much data the ‘tbl_Commands’ table retains (some say just the preceding week).  In my example, I queried the ‘Min’ start times for logged activities and went back over 5 months.  Just something to think about:  Your mileage may vary greatly.  (Apparently a clean-up job is supposed to run periodically which trims this table.)
  • Steve Lange @ Work

    Thoughts on TFS Project Collections

    • 3 Comments

    New to TFS 2010, Team Project Collections (TPCs) provide an additional layer of project organization/abstraction above the Team Project level (see the MSDN article, “Organizing Your Server with Project Collections”)

    I’ve been asked numerous times over the past couple of months about the intention of project collections, their flexibility and limitations.  Below are simply my educated thoughts on the subject.  Please do your due diligence before deciding how you wish (or wish not) to implement project collections in your environment.

    You can use collections to more tightly couple related projects, break up the administrative process, or to dramatically increase scale.  But the primary design goal behind introducing project collections is around isolation (of code, projects, or groups within an organization) in a way that provides all the benefits of TFS, scoped to a defined level within a single instance of TFS.  You’re effectively partitioning TFS.

     Basic project collection structure

     

    If you have ever used TFS 2005 or 2008, think of it this way.  A project collection effectively compartmentalizes all the capabilities you’ve grown to love in a single TFS 2005/2008 instance:

    Project collection compartmentalization

    I won’t go into how you create/edit/delete project collections.  Just know that you can.  (BTW – for those of you upgrading from an earlier version of TFS, your existing projects will go into a single default project collection (by default, it’s named “Default Collection”.  Original, right?)

    Consider this (over-simplified) example.  I have 4 projects in my server, currently in a single (“default”) collection:

    Single collection view

    Say Project A and Project B are used by “Division A” in my company, and Agile1 and Sample Win App are used by “Division B”.  Project A and Project B share some code and leverage the same user base.  The assets in each division’s projects are in no way related to the other.  Consequently, I’d love to take advantage of project collections and separate our divisions’ stuff.  A more practical implementation of project collections might look like this:

    I build out my collections using the TFS Administration Console to look like this:

    Viewing my project collections in the admin console

    Once that’s done, I can ultimately end up with such a structure that my desired projects are contained in their respective organization’s collection:

    Division A’s stuff:

    Division A's collection

    Division B’s stuff:

    Division B's collection

    Now each division’s stuff is effectively compartmentalized.  No shared process templates, no shared user base, and no shared database (which means one division’s screw-up won’t affect another division’s work).

    Okay, so I lied a little – I earlier said I wouldn’t go into detail about how to CRUD collections.  But I will mention one thing here, which will add context to the above scenario.  In the above, I had a single collection that I effectively wanted to split into two collections (i.e. go from “Default Collection” to “Division A” and “Division B”).  This is surprisingly easy to do (more complicated than drag & drop, but not ridiculous either).  The documentation for splitting a collection lists 15 main steps to accomplish this, but basically what you’re doing is cloning a collection and then deleting what you don’t want.

    See?  I told you it would be a simple example.  But if you expand this to think of a TFS environment with 100 projects (instead of my puny four), you get the point.

    This all sounds pretty cool, right?  It. Is. Very. Cool.  Project collections can be used for various purposes in your TFS deployment (consolidating related development efforts, scaling the SQL backend, mapping TFS hierarchy to organization hierarchy, etc.).  However, with flexibility comes complexity.  If you had fun sitting around a conference table debating how to structure your TFS 2005/2008 project hierarchy (perhaps consulting our branching guidance document or patterns & practices?), project collections add a new element to consider for 2010.  Below I’ve outlined some of the main considerations for you and your team to think about before taking advantage of project collections in TFS 2010.

    For Systems Administrators:  Pros & Cons

    Pros

    • Flexibility to to backup/restore collections individually.  This can reduce downtime as restoring one collection will not impact users of other collections.
    • Since each collection is contained in its own database, these databases can be moved around a SQL infrastructure to increase scale and load balancing.
    • Could help consolidate IT resources.  If your organization currently leverages several TFS instances simply to isolate environments between departments, collections can allow the same TFS instance to be used while still providing this isolation.

    Cons

    • Again, with flexibility comes complexity.  Since project collections use their own databases, each one must be backed up (and restored) individually.  Also, other admin tasks such as permissions and build controller configuration grow proportionately as additional collections are created.
    • Users and permissions need to be administered separately for each project collection (this may also be a project admin consideration).
    • There are more databases to restore in the event a full disaster recovery is needed.

    For Project Administrators:  Pros & Cons

    Pros

    • Organizational hierarchy.  If your organization has multiple divisions/departments, you can break up your TFS project structure to reflect that organizational view.  This makes it much easier for users to identify (or constrain via permissions) which projects belong to their department.
    • Projects grouped in the same project collection can leverage similar reports (“dashboards”) work item types, etc.  They can can also inherit source code from other grouped projects.

    Cons

    • In Visual Studio, you can only connect to one collection at a time.  While it’s relatively trivial to simply connect to a different collection, you can’t view team projects in Team Explorer that reside in different project collections.
    • Relationship-specific operations you enjoy across team projects cannot span project collections.  This means that there are several things you cannot do across collection boundaries, such as:
    • Branch/merge source code (you can do this cross-project, but not cross-collection)
    • Query work items (i.e. you can’t build a query that will show you all bugs across multiple collections)
    • Link items (i.e. you can’t link a changeset in one collection to a task in another collection)
    • Process templates are customized and applied at the project collection level, not the TFS server level

    What does it boil down to?

    It’s really about your need for isolation.  Do you ideally want to isolate by application/system, organization, or something else?  Do you foresee a need to share code, work items, or other assets across projects?  It’s a fun little decision tree:

     Basic, over-simplified decision tree

    So that’s it!  The devil is always hiding in the details, so do your own research and use your own discretion when deciding how to adopt project collections into your TFS deployment.  I anticipate more guidance on this topic to come out as TFS 2010 installations propagate throughout the world.

    For more resources and practical guidance on using Team Foundation Server, see the TFS team’s blog on MSDN.

    I hope this helps you somewhat!  And thanks for reading!

  • Steve Lange @ Work

    August 2010 - Steve’s Monthly Developer Tools Newsletter (First Installment!)

    • 3 Comments

    [UPDATE – To allow comments and better tracking, I’m going to be publishing my newsletter as a regular blog post instead of a static page.]

    imageIt happens often:  I meet with a customer who asks a terrific question which makes me think, “Man, I have a lot of other customers who’d love to know about that as well!”

    So I’ve decided to (try and) put together a monthly newsletter which provides announcements, tips, event notices, and other information that I think will interest you.  (And yes, I’m open to ideas/topics as well!)

    Earlier today, I posted my first installment for August 2010.  As I post more, I’ll maintain an archive as well, I’ll be tagging my newsletter posts as well so you can see an archive.  While I will be posting these newsletters online, I will (and already have!) sent notifications to some of you.  If you’d like to be notified of new newsletters, send me an email or fill out the contact form and let me know.  (Yep, opt in.  I don’t want to just spam.)

    I hope to publish at the beginning of each month, detailing news from the past month and covering upcoming items for the next month.

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: TFS Feedback Management Behind the Scenes

    • 3 Comments

    In this post, I’m going to take a closer look at how the new Feedback capabilities in TFS 2012 works under the covers.

    In general, TFS users can request “feedback” from stakeholders about particular elements/areas of an application.  This can be either specific or general scenarios.  TFS manages the feedback process using work items and email notifications.  But how does this work, really?  Let’s find out!

    You initiate a feedback request from your project (or team) dashboard by clicking on “Request Feedback”

    image

    In this example, I’m soliciting feedback for Bing searches.  And I’ve asked for two items of feedback (called “feedback items”, see Step 3 in the screenshot).

    So what happens when I actually click send?

    Well, as far as the stakeholder is concerned, they just get an email with some simple instructions to get started:

    image

    But on the TFS side, TFS creates two work items (of type Feedback Request), one for each feedback item specified in the previous request (see #142 and #143):

    image

    Let’s look at #142 (Search for ‘Steve Lange’) and see what’s stored.

    The Title field obviously houses the name of the feedback item.  On the Details tab, the Description field holds the specific instructions that correspond with the feedback item.

    image

     

    On the Application tab you’ll find the details from step 2 on the request form (“Tell the Stakeholders How to Access the Application”).

    image

    And lastly, you’ll notice that the feedback items (Feedback Request work items) are linked together to form the more composite request.

    image

    So how can we see to whom this request was sent?  Look in the comments of the history for the work item (at the bottom of the screenshot):

    image

    The benefit of this approach is that it allows feedback items to be tracked individually.  If you submit a feedback request, but ask stakeholders to check out features that align with different backlog items/requirements/whatever, this method provides more specific tracking.

    Reuse or Making Corrections

    Another less obvious, but equally nice benefit to managing feedback requests this way is that you can make changes to the request without creating an entire new one.  This is possible because the link that’s inserted in the email sent to the stakeholders references the work item ID’s of the feedback request items, rather than embedding all the instructions in the URL (or statically somewhere else).

    So if I make a mistake I don’t have to create a brand new request, but instead the Title, Description, and other applicable fields on the Application tab and have the stakeholder simply reuse the previously-sent link.

    In this example, the URL provided in the email looks like this (see bolded area):

    mfbclients://<my_subdomain>.tfspreview.com/DefaultCollection/p:Sandbox?rid=142%2C143

    By updating either of the work items specified in the URL, the feedback session will subsequently be updated.

    More on the feedback URL

    You can modify the URL and send it directly to someone without filling out the feedback request form.  For instance, if I requested feedback of work items 142 and 143 from certain people but also wanted feedback on work item 143 from an additional person I can augment the URL and send it to that one-off person.  In this example it would look like:

    mfbclients://<my_subdomain>.tfspreview.com/DefaultCollection/p:Sandbox?rid=143

    Here’s the basic breakdown of the URL:

    mfbclients://<TFS_URL>/CollectionName/p<Project_Name>?rid=<work_item_ids>

    <TFS_URL> The URL of your TFS instance
    <Project_Name> The name of your Team Project
    work_item_ids Comma-separated list (or use %2C) of work item ID’s.  These work item ID’s need to correspond to Feedback Request work items or the Feedback Client will throw an error.

    Moving On

    So let’s say I walk through the process of providing feedback using the Microsoft Feedback Client.  For summary, here’s the feedback I provide:

    image

     

    Once I submit my feedback through the Feedback Client, a work item (of type Feedback Response) is created for each individual reply.  (See #144 and #145 below)

    image

    Again, this allows teams to track individual responses to discrete items.  So if a stakeholder skips feedback for a particular item, it doesn’t interfere with feedback on other items.

    Revisiting and Providing More Feedback

    Here’s one last great feature.  As the stakeholder, let’s say I want to either review or amend feedback I’ve already provided, or submit additional feedback.  I’m covered!  If I simply click on the link provided in the original feedback request email, upon entering the “Provide” step of my feedback session TFS is smart enough to see that I’ve already provided feedback.  In doing so, it inserts the feedback details I provided earlier into the Feedback Client.  So now I can make changes to existing feedback, or enter more information. 

    For example, here’s the Feedback Response work item created from my first submitted feedback:

    image

    If I click on the URL in the original email sent to the stakeholder, the Feedback Client runs again, and I can instantly see the feedback I’d previously supplied:

    image

    (Look familiar?)

    Really all it’s doing is looking at the Feedback Request work item, checking to see if there is a Feedback Response item submitted by me already.  If there is, it pulls the content of the Stakeholder Comments field and sends it over to the Feedback Client for the stakeholder to make further edits.  Sweet!

    Basically..

    The basic thing to remember here is that the Feedback Management process in TFS uses TFS work items to manage the storage and workflow of providing feedback.  Think of the Feedback Client as a very lightweight TFS client.  Changes you make in the Feedback Client either create or update Feedback Response work items in TFS.  Direct changes made in TFS to the work items are reflected in the Feedback Client when those work items are accessed.

    I hope this helps better explain how feedback actually works in TFS 2012.  It’s terrific and easy way to engage stakeholders to get feedback at various points in the development lifecycle.  But it’s a flexible implementation as well, providing mechanisms for reuse and more granular tracking.

    Enjoy!

  • Steve Lange @ Work

    Microsoft’s Visual Studio ALM is a leader in the the Gartner Magic Quadrant

    • 3 Comments

    The brilliant minds at Gartner have positioned Microsoft in the “leader” quadrant for Application Lifecycle Management, in their June 5th, 2012 publication, “Magic Quadrant for Application Life Cycle Management” (available for 12 months following publication).

    Their evaluation was based on Visual Studio 2010 and Team Foundation Server 2010. I can’t wait to see what they think of the 2012 version once it releases!

    Magic Quadrant for Application Life Cycle Management (Gartner June 2012) 

    I’ll let you read the report (Microsoft section) for full details, but notable quotes include:

    “By virtue of its position in the market as a provider of key platforms and development tools, Microsoft acts as an overall thought leader in the ALM market”

    “Unlike all of the other tools in this Magic Quadrant, Microsoft's is the only one that tightly binds its versioning system to the rest of the ALM planning tool.”

    “..the company has made good strides with support for Eclipse and the ability to extend TFS with Java code.”

    This is truly a great accomplishment for our teams at Microsoft.  Congratulations to all!

  • Steve Lange @ Work

    Ordering Method Execution of a Coded UI Test

    • 2 Comments

    There’s often no discernable, consistent pattern that dictates the execution order of automated tests (Coded UI in this example, but the same applies to Unit Tests).  Some argue that it may be a good thing that there isn’t an inherent pattern for the execution of CodedUI tests (and unit tests, for that matter), as a seemingly more random pattern can uncover test dependencies which reduce the overall effective coverage of tests.  And I agree with that to an extent, but there are always cases in which control over execution order is needed.

    An easy way to accomplish test order is to use an Ordered Test. This will provide you explicit control over the execution order of your tests.

    For this example, I have a Coded UI Test class called CodedUITest1 (for more on Coded UI Tests, see the Anatomy of a Coded UI Test).  In it, I have two CodedUI Test methods:

    • CodedUITestRunFirst()
    • CodedUITestRunSecond()

    I want to order them such that they execute like:

    • CodedUITestRunSecond()
    • CodedUITestRunFirst()

    1. Add a new Ordered Test. Go to Test->New Test, and select Ordered Test.

     New test window

    2. The ordered test will open. I can move the available tests from the left list into my ordered test list on the right. I can then move the tests up/down to create the desired order.

     Ordered Test dialog

    It’s not shown in this screenshot, but there is a checkbox to allow the ordered test to continue upon a failure.

    3. Save the ordered test. I can now see the ordered test in my Test View window.

    Test View window showing new ordered test

    4. When ready, I select to run my ordered test. It will appear in the Test Results window as a single test.

    Test Results window showing ordered test

    When finished, I can double-click on the test result to see that both tests did actually run, their individual results, and their order.

    Detailed results of ordered test

    It’s a surprisingly easy yet elegant solution.  I can put pretty much any automated test into an ordered test (except for load tests).  If you have a lot of tests, coupling the use of ordered tests with other test lists can really help visually organize your test project.

  • Steve Lange @ Work

    Announcing My New Virtual Office Hours!

    • 2 Comments

    In an effort to continually help you get the most out of your investment in Microsoft development tools, I am happy to announce that I have set up regularly-scheduled virtual office hours!

    Please join me at any of his scheduled hours to ask questions, view quick demos, or learn more about upcoming products, technologies, and events.  You can also use this time to collaborate with other customers who may have stories or advice to share.

    I've created a page on this blog that lists my office hours dates/times, as well as information on how to join.  I've scheduled them roughly every two weeks or so for one hour.

    My current office hours schedule runs through the end of January 2012.  If enough people participate each week, I would love to extend them another six months!

    I hope to "see" you in my "office"!

  • Steve Lange @ Work

    No PDC Tickets? Watch it with us at PDC Live!

    • 2 Comments

    image

    Live Broadcast & In-Person Session

    UPDATE (10/26) – The Denver PDC viewing venue is moving to the local Microsoft office in the Tech Center: 7595 Technology Way, Denver, 80237 (map HERE)

    PDC10 is now sold out, but you can still join in on the excitement via the live stream and in-person delivered sessions. Attend this event on October 28, 2010; this year’s content will focus on the next generation of Cloud Services, client & devices, and framework & tools. You can get the highlights of PDC without heading to Redmond.

    This year’s groundbreaking event will include live streaming of the keynotes, as well as concurrent live streaming of sessions. All content will be available on demand within 24 hours of recording. Be a part of it by attending a local area event or by watching online.

    So since it’s online, why come to a PDC Live event?  Watch it with others to create better interaction and an improved learning experience; plus see key sessions demonstrated live!

    Join the PDC mailing list for the latest news on upcoming PDC events and special discount offers: https://www.ustechsregister.com/pdcmailinglist/main.aspx.

    Space is limited, register soon! For agenda & session detail, please visit the local event registration page.

    PDC Viewing Venues & Registration Info

    Mountain View, CA

    Microsoft Corporation

    Event ID: 1032464622

    Denver, CO

    The Cable Center

    Microsoft Office

    Event ID: 1032464623

    Phoenix, AZ

    Gangplank

    Event ID: 1032464624

    Seating is limited. Register online or call 1-877-MSEVENT

  • Steve Lange @ Work

    Holy Accelerated Training, Batman!

    • 2 Comments

    Hey Denver!  Our friends at IT Boot Camps have two sets of accelerated trainings coming up that you will want to check out.  This is just a subset of courses offered, ones that focus on developers. 

    imageTeam Foundation Server 2010 Administration

    This 2-day accelerated program covers all the material that targets achieving the MCTS: Visual Studio Team Foundation Server 2010, Administration certification (Exam 70-512).

    This program is designed for knowledge and skills on installing, configuring and maintaining Visual Studio 2010 Team Foundation Server.  It is intended for candidates who install, configure, and manage a Microsoft Visual Studio Team Foundation Server (TFS) 2010 implementation. Candidates typically work in an enterprise development organization that provides process automation services by using TFS.

    This $950 course (even cheaper if you belong to one of the local user groups!) includes:

    The currently-scheduled dates for this training are: February 17 – 18 and March 17 - 18

    For more information, visit the course’s home page on IT Boot Camp’s site, or email info@itbootcamps.com.

    imageVisual Studio Boot Camps

    Visual Studio, and .NET development in general is a broad and deep topic.  IT Boot Camps is providing four separate curriculums in this area:

    Visual Studio Windows Applications 2010
    Date(s):

    March 7 - 9
    May 2 - 5

    Price: $1,495*

    Exam Targeted:  70-511: TS: Windows Applications Development with Microsoft .NET Framework 4

    Course Material:  10262A: Developing Windows Applications with Microsoft Visual Studio 2010

    Curriculum:

    1. Windows Client Application Design
    2. Introduction to Visual Studio 2010 and WPF
    3. Designing and Developing a User Interface
    4. Taking Control of the User Interface
    5. Testing, Unit Testing and Debugging
    6. Sample Data Binding and Validation
    7. Data Binding to Collections
    8. Enhancing UI Responsiveness
    9. Integrating Localization and User Assistance Features
    10. WPF 2D Graphics, Multimedia and Printing
    11. Control Customization
    12. Attached Properties and Behaviors in WPF
    13. Animations in WPF
    14. Application State, Settings and Lifecycle
    15. Configure and Deploy Windows Client Applications
    Visual Studio Web Applications 2010
    Date(s):

    March 10 - 12
    May 5 - 7

    Price: $1,495*

    Exam Targeted:  70-511: TS: Windows Applications Development with Microsoft .NET Framework 4

    Course Material:  10264A: Developing Web Applications with Microsoft Visual Studio 2010

    Curriculum:

    1. Designing a Web Application
    2. Developing MVC Models
    3. Developing MVC Controllers
    4. Developing MVC Views
    5. Designing for Discoverability
    6. Writing Server-Side Code for Web  Forms
    7. Optimizing Data Management for Web Forms
    8. Ensuring Quality by Debugging, Unit Testing, and Refactoring
    9. Securing a Web Application
    10. Applying Master Pages and CSSs
    11. Developing Client-Side Scripts and Services
    12. Advanced AJAX in a Web Application
    13. Deploying a Web Application
    Visual Studio Service Communications 2010
    Date(s):

    March 14 - 15
    May 9 - 10

    Price: $950*

    Exam Targeted:  70-513: TS: Windows Communication Foundation Development with Microsoft .NET Framework 4

    Course Material:  10263A: Developing Windows Communication Foundation Solutions with Microsoft Visual Studio 2010

    Curriculum:

    1. Service Oriented Architecture
    2. Getting Started with WCF Development
    3. Hosting WCF Services
    4. Defining and Implementing WCF Contracts
    5. Endpoints and Behaviors
    6. Testing and Troubleshooting
    7. Security
    8. Advanced Topics
    Visual Studio Data Access 2010
    Date(s):

    March 16 - 18
    May 11 - 13

    Price: $1,195*

    Exam Targeted:  70-516: TS: Accessing Data with Microsoft .NET Framework 4

    Course Material:  10265A: Developing Data Access Solutions with Microsoft Visual Studio 2010

    Curriculum:

    1. Designing a Web Application
    2. Developing MVC Models
    3. Developing MVC Controllers
    4. Developing MVC Views
    5. Designing for Discoverability
    6. Writing Server-Side Code for Web  Forms
    7. Optimizing Data Management for Web Forms
    8. Ensuring Quality by Debugging, Unit Testing, and Refactoring
    9. Securing a Web Application
    10. Applying Master Pages and CSSs
    11. Developing Client-Side Scripts and Services
    12. Advanced AJAX in a Web Application
    13. Deploying a Web Application

     

    Additional Great Opportunities

    IT Boot Camps has courses covering a wide range of topics, but here are a couple more developer-focused ones you may want to look at:

    Silverlight 4: Application Development
    Date(s):

    March 28 -31

    Price: $1,895*

    Exam Targeted:  70-506: TS: Silverlight 4, Development

    Course Material: 

    • 10553A: Fundamentals of XAML and Expression Blend
    • 10554A: Developing Rich Internet Applications using Microsoft Silverlight 4

    This accelerated program will take 8 days of information and offer it in a 4 day format.  Candidates for this program are developers who create and maintain rich interactive applications (RIA) using Silverlight 4.  Candidates may have additional experience with previous Silverlight versions.

    Windows Azure Professional Developer
    Date(s):

    June 13 - 14

    Price: $950*

    This class is designed for .NET developers with Web application experience that are exploring developing new applications or porting existing applications to Windows Azure.

    After completing this course, students will be able to:

    • Understand cloud computing in its various forms and how Windows Azure fits in the cloud computing space.
    • Learn why organizations want to run applications in the Azure cloud.
    • Understand the architecture of Azure.
    • Explore the Azure SDK and DevFabric development environment.
    • See how to develop applications for Azure and how that varies from "normal" .NET application development.
    • Write and deploy a ASP.NET Web application (Web Role) to Azure.
    • Explore Azure storage capability.
    • Learn how to create and deploy background computational applications (Worker Role) in Azure.
    • Explore SQL Azure capability.

    * Remember that there are discounts for user group members!

    WHEW!  Don’t know where to start?  Contact IT Boot Camps for more information.

  • Steve Lange @ Work

    Content from My DevExpress Webinars this Week

    • 2 Comments

    Thanks to those of you who attended the DevExpress webinars I delivered this week.  I hope it was worth your 60 minutes!

    As promised, below is the content from each webinar.  I’ve posted the slide decks on SlideShare.net, and the sample code from my second webinar on SkyDrive.

    Feb 22nd - Team Foundation Server 2010 for Developers

    (view the replay here at DevExpress)

     

    Feb 24th – Visual Studio 2010 Testing for Developers

    (view the replay here at DevExpress)

    The sample project from this webinar can be found here on SkyDrive (click on DevTesting-Samples.zip).

    Again, thanks for attending!  I had a lot of fun!

  • Steve Lange @ Work

    Upcoming ALM Webcasts from Neudesic

    • 2 Comments

    The events just keep comin’ from our awesome partners!  See below for the latest schedule of ALM webcasts from Neudesic.

    October 30th Scrum and Agile Management with Visual Studio 2012, Presented by Clementino de Mendonca

    Find out how Visual Studio has become the tool of choice to manage your Scrum projects, and how it stands out of the way allowing you to do Agile in your own terms instead of forcing you to adapt your development process to a tool. We will take a tour on how you can enact Scrum best practices and cycles, allowing the team to always have a clear picture of Done should look like at the end of a sprint through using Team Foundation Server as a team communication hub.

    November 1st Requirements and Stortyboarding in the Visual Studio 2012, Presented by William Salazar

    Many teams use mockups or storyboards to describe general application appearance and flow.  This session will demonstrate new features in Visual Studio 2012 that support creating, presenting and maturing storyboards using tools you already know. And then we’ll show how this process fits into the rest of your application’s lifecycle.

    November 6th – Creating a Branch Strategy, what it is, why you need one, and how you get started, Presented by Clementino de Mendonca

    Do you know for sure which code base snapshot in your source control system matches what is in production? What is the best strategy to manage source code for team members working in parallel in different features? In this talk we will take a look at creating branching strategies that answer these and other questions, and allow you to balance simplicity, isolation, and speed in your software development efforts.

    November 8th – DevOps: Integrating Operations for Continuous Delivery, Presented by William Salazar

    Integrating Development and Operations teams deeply using new practices and tools is critical to delivering on the promise of shorter cycle times, improved mean time to repair, and increased business value that all companies that build software want to fulfill. Organizations that use practices and tools to integrate development and operations can significantly speed up their Application Lifecycle Management (ALM) process and enable continuous delivery of software to their customers, whether internal or external. Developers and Operations engineers are increasingly working closer together to maintain always on services. Visual Studio 2012 with System Center 2012 give developers and operations the tools to work seamlessly together to reduce the mean time to repair for defects in production applications.

    Learn about some of the newest features in Microsoft Visual Studio 2012 and System Center 2012, including:

    • Features to help improve the interactions between development and operations, creating better, integrated workflows
    • New lab management tools that allow teams to quickly spin up an advanced Build-Deploy-Test infrastructure
    • Deployment management features such as support for multiple package types, virtual machine management, automated deployment to private and public clouds
    • Integrated production monitoring and diagnostics tools

    Register:

    November 14th – Collecting Actionable Feedback with Visual Studio, Presented by Clementino de Mendonca

    Most teams collect feedback from customers in one way or another but it fails to trickle down as something that developers can use to improve the product. See how Visual Studio can help you capture, structure and tie feedback into your existing development efforts with Microsoft Feedback Client, allowing you to provide actionable starting points for your development and testing efforts. REGISTER TODAY!

    November 15th – Developer Testing with Visual Studios, Presented by William Salazar

    From the ground up, the developer testing experience in Visual Studio 2012 was designed to allow developers to focus on their code and avoid unnecessary distractions. Test Explorer is now easily extended, allowing you to add third-party testing frameworks in addition to those shipped with Visual Studio. Visual Studio also includes the new Fakes framework to let developers create fast running and isolated unit tests. In this session, we will review the new developer testing experience in the context of a typical day-to-day workflow, showing how these features will help you quickly write better quality code.

    November 27th – Improving Small Team Productivity with Team Foundation Server, Presented by Clementino de Mendonca

    Team members in smaller teams have always had to wear multiple hats: talk to customer, develop, test, talk to customer, fix bugs, retest, talk to customer, deploy… did I forget to mention you also have to plan your releases?  No way you can do this without some automation. Visual Studio 2012 is the suite that will boost your productivity to the max by augmenting your skills with powerful tools that will help you trace your way out of a development cycle labyrinth.

    November 29th – Making Developers More Productive with Visual Studio Team Foundation Server, Presented by William Salazar

    In this session, we will talk about those “fit-and-finish” scenarios in Visual Studio Team Foundation Server 2012 which will make developers more productive as they write code and collaborate with other team members. You’ll find out about the new integrated code reviews; the new “My Work” experience for managing your active tasks; and once you’re “in the zone” Visual Studio will now help you stay focused on the task at hand, no matter how much you’re randomized, with a new suspend/resume experience. You’ll also find out how to work offline seamlessly, how the new merging experience works, and how you can more easily find work items.

  • Steve Lange @ Work

    Denver Study Group, by the Denver Visual Studio User Group

    • 2 Comments

    2/13: Update – New meeting location!

    The local user group here in town has set up a new study group, kicking off tomorrow (Feb 7th).  For full details, go here, but below are the core details.

    The Denver Study Group is a sub group of Denver Visual Studio User Group.

    When

    Thursdays, beginning February 7, 2013 (first course for 6 weeks, then repeat for next course)
    5:30 p.m. - 7:30 p.m. Limited to First 20 Attendees!  

    Where

    Microsoft Store, 303-824-6772
    Park Meadows Mall, 8505 Park Meadows Center Dr., Lone Tree, CO 80124,
    Store is near the center of the mall, Zone B, Upper Level, between Macy's and Forever 21
    Meeting space is near the middle back portion inside the Microsoft store

    UPDATED LOCATION (see below)   

    Innovation Pavilion, 9200 East Mineral Ave., Centennial, CO 80112

    North of Park Meadows Mall, between E. Dry Creek Rd. & E. County Line Rd., W of I-25)
    - Plenty of free parking, Enter the front lobby (doors locked after 7:00 p.m.)
    - Check the white board for room number (probably, 3rd floor, Suite 310 or 385)

    Using Pluralsight videos: one month free pass for first time attendees
    First Course: Building Applications with ASP.NET MVC 4 by Scott Allen
    Watch Videos, Code, Discuss (no purchase necessary)
    Optional: bring your own pc (free Wi-Fi available)
    Join us for our first Denver Study Group --
    FMI: read the details below

    What

    The Study Group meets for the express purpose of gathering developers together on a series basis to watch, code, discuss, and learn from high quality video training along with others of a like mind.
    During the Study Group meetings, the training videos are shown in a web browser via a streaming service and displayed on a large screen audio/visual presentation system for all participants to watch and hear together.

    Why

    Video training helps us in our group bring experienced and highly rated training professionals directly into our group at a time and place of our choice -- and for free! More than that, it provides us with opportunities to select the specific training we need to be delivered via video and supplement it with coding in a group setting and interactive discussions learning together with our own peers locally. This gives us the best of both worlds - expert training and group interaction - delivered to fit our needs.
    Video training provides an excellent, cost-efficient alternative to live training programs by using a vast training library which has helped thousands of developers worldwide. When we add our group members to code and discuss together, you get even more than you could by watching the videos solo.

    When

    Thursdays, 5:30 pm – 7:30 pm MST, approximately 2 hour meetings once each week
    Watch 45-60 minutes of course video at each meeting
    Work 20-30 minutes on ad-hoc exercises and code together as a group related to the video just watched
    Discuss 20-30 minutes in a round table format related to the video just watched
    Approximately 5-6 consecutive weekly meetings will be completed to go through a course
    Break between courses 1-4 weeks and then repeat for next course
    Depending on the course and the needs of the participants, the watching/coding/discussion times  will vary, sometimes considerably
    Depending on each course, length of each weekly meeting and consecutive meetings for a course may vary
    Holidays, other special days, weather, and venue use, may cause changes to the planned schedule
    We will plan for each course from one to six months ahead of scheduled venue space needs and  communicate those dates and times to ensure our space reservations and placement on the venue  events calendar

  • Steve Lange @ Work

    Woot! Expression Studio 4 is Here

    • 2 Comments

    Expression Studio 4Expression Studio 4 was announced this week!  There are some incredible new capabilities in this release, and I’ve bulleted the big ones below.  There are other places that will talk more about each in detail, but this should give you a start.  (One of my favorite features – native TFS support!)

    There are three (3) different product sets for Expression Studio:

    • Expression Studio 4 Ultimate
      • Expression Web + SuperPreview
      • Expression Blend
      • SketchFlow
      • Expression Design
      • Expression Encoder Pro
    • Expression Studio 4 Web Professional
      • Expression Web + SuperPreview
      • Expression Design
      • Expression Encoder
    • Expression Encoder 4 Pro

    (Technically, there is a fourth edition, Expression Studio 4 Premium, but that is not available via retail)

    Here’s the experience you get with xStudio 4 as told in an elevator:

    Expression Blend, Visual Studio, Silverlight and .NET provide the most compelling design and development workflow on the market today. Seamlessly working on user experience and core architecture enables you to deliver visual and interaction design and underlying code that is both unique and innovative. The speed and flexibility with which ideas are taken from concept to completion gives you and your team the ability to push the envelope of your skills throughout the project, challenging you to deliver sophisticated and compelling applications for your customers, while still enabling you to deliver the final project on time and within budget.

    Here’s what I say:

    Expression Studio 4 allows you to conceptualize, design, and create compelling user experiences while easily collaborating with development and test teams.  Map your thoughts, communicate ideas, design the next “wow” experience.

    Think about it in a few major focus areas, and their supporting capabilities:

    Compelling Experiences

    • SketchFlow
    • Adobe Photoshop Import
    • Adobe Illustrator Import
    • Behaviors
    • Control Styling
    • Visual State Manager
    • Custom controls
    • Easing Animation
    • Path Layout
    • Pixel Effects

    Powerful Technology

    • Silverlight 4, Silverlight 3, .NET 4, .NET 3.5
    • Code Editor
    • XAML IntelliSense
    • C#/VB IntelliSense
    • Sample Data
    • TFS support (yeah, baby!)
    • Behaviors
    • Extensibility (UI adorners on custom controls)
    • Expression Blend and Visual Studio integration
    • Eco-system – utilizing and leveraging skills that are in place today

     Accelerated Results

    • Behaviors
    • SketchFlow / Microsoft Word export
    • Adobe Photoshop Import
    • Adobe Illustrator Import
    • Sample Data
    • Code Editor
    • XAML IntelliSense
    • C#/VB IntelliSense
    • Control Skinning
    • Visual State Manager – State animation / Effects
    • Custom controls / Convert Graphics to control parts
    • Superior workflow design/development workflow

    Take it for a test drive today!

  • Steve Lange @ Work

    Hey Slange, where have you been?

    • 2 Comments

    I received a few emails and tweets asking why my blog has been so quiet lately.  Well, I promise there’s a good reason.

    My newest little guy, Caden Jax

    My wife and I welcomed our second child into the world in March.  As a result, I was able to take advantage of a Microsoft benefit giving me 4 weeks of paid leave.  So, I went dark for all of April to adjust to life as a new dad (again).

    So what about this leave?, some of you have asked me.  Well, let me explain further:

    I know there are a few other companies out there that offer this, but I’ve never worked for any of them before.

    When my wife and I had our first child, I worked for a different company.  I had done well to save up my vacation time so that I could take three weeks of to adjust to our new family lifestyle.  While it was vacation time well-spent, doing so drained my allotted vacation hours.  It was months before I could afford to take any more time off for family excursions, personal activities, or just plain R&R.

    Enter my career at Microsoft.  Microsoft provides what’s called ICL, or Infant Care Leave, for both new mothers (as you’d expect) AND new fathers (very, very cool!).  I was provided four weeks of leave, paid, and the option to take an additional eight weeks (unpaid) if I so chose (I didn’t, as three months from work would probably give me the shakes).

    However, I did work one day in April – the VS 2010 Launch event in Denver on April 22nd.  I delivered the Application Lifecycle Management session in the Developer track.  (Thanks to all of you who offered kind words after!).  My task list includes getting the content posted online soon, for those of you asking for it.

    So, as of today (5/3), I’m back and digging out of my pile of email.  If you’ve sent me email, I promise I’ll find it and get back to you ASAP.  I also have some pending blog entries which I’ll get posted in the next couple weeks.

  • Steve Lange @ Work

    Free Webcast: The Full Testing Experience – Professional Quality Assurance with Visual Studio 2010

    • 2 Comments

    vs2010logo I hope you can make this Webinar on June 15 - we’ll review all of the great new TESTING functionality of Visual Studio 2010.

    If you are using other Testing solutions from HP, IBM or providers (including open source solutions), you will want to learn more about what comes “in the box” with Visual Studio 2010.  Many of you already own the licenses to our new Testing solutions – learn how you can start to leverage them today!

    The Full Testing Experience – Professional Quality Assurance with Visual Studio 2010

    • Imagine knowing exactly what manual regression tests you had to run, given the code changes in the recent build…
    • Imagine being able to quickly and completely capture bugs in such a way that developers can always reproduce them…
    • Imagine being able to record your exploratory testing and turn that exploration into detailed test steps – with just a few commands…
    • Imagine taking a manual test run and, in seconds, turning it into an automated test…
    • Imagine seeing your testing progress on one simply dashboard, and drilling into critical details…

    Registration Link:

    https://www.clicktoattend.com/invitation.aspx?code=143871

  • Steve Lange @ Work

    Thanks, RM Tech Trifecta!

    • 2 Comments

    I had a great time on Saturday hanging out with 400-ish of my closest friends at the Rocky Mountain Tech Trifecta!  Many of you braved iffy road conditions to make it downtown for this incredible event.

    Big hats of to the Yacks for putting this together!

     

    View Rocky Mountain Tech Trifecta (Feb 2009)
  • Steve Lange @ Work

    Take TFS for a Test Drive with a Hosted Trial

    • 2 Comments

    There is a new option for taking TFS for a test drive:

     

    Free 6-week hosted trials of TFS are being offered by TeamDevCentral.  It includes:

    ·         Accounts allowing customers to experience different team roles and to collaborate within a project

    ·         Up to 4 hours of guidance and/or support for the trial can be used for any type of advice related to TFS or Visual Studio Team System

     

    You can sign up for the trial at their website, or read the press release:  Press Release: TeamDevCentral Offers Free Trials of Hosted Microsoft Team Foundation Server

     

  • Steve Lange @ Work

    Sssshh!!! The Team System Big Event is Coming..

    • 2 Comments

    We’ve got a cool event in the works.  Covering all aspects of Team System.  Presented by Microsoft, partners, and community influentials.

    Where?  Denver, Phoenix, Irvine, Mountain View, Portland.

    Don’t tell anyone! (Okay, do tell people – bring them along, but don’t give up your seat!)

  • Steve Lange @ Work

    First Take: Microsoft Surface at the Rio's iBar

    • 2 Comments

    Surface at the iBarDuring a recent trip to Las Vegas (yes, for business), I was able to visit the iBar at the Rio.  It recently installed six Microsoft Surface machines to add to the social experience at the bar (press release).  This was the first time I'd seen a Surface up close.

    For a Monday night, there were quite a few people hovering around the area waiting for one of the Surface machines to become available.  We found one, sat down, and started experimenting.  Here are the games/apps that we played with.

    Mixologist

    This app allows you to scroll through various adult beverages and select one to be ordered directly from the bar.  You can also experiment mixing your own.  Overall, it worked pretty well, although we had to get used to the navigation.  It was the first application we played with, so I think we were also still figuring out the touch sensitivity and the allowance for multi-touch (the two of us were touching the screen at the same time, and I think that messed up some of our menu choices).

    PIC-0062 - Copy Hip-notic

    This application is basically a YouTube viewer.  You can search for videos by keyword, browse by rating, or browse by most recent.  Your search results appear as postcard-looking thumbnails that can be rotated, resized, and played.  We found it pretty easy to lose track of time with this application (isn't that the point?), and spent most of our time watching videos.

    Head Games

    This app provides a series of games, most notably "High Roller" bowling, pinball, and Last Call (a memory game).  We bowled a few frames and moved on.  BTW, here's a hint for the bowling game if you want to run up your score.  As you're getting ready to bowl, you can run your fingers on the standing pins, you can knock a lot of them over before you even bowl.  (You can also use the same technique against your opponent, moving his pins away from the ball.)

    Flirt

    This app allows patrons at one Surface machine to interact with patrons at other machines.  There are video cameras pointed at each Surface table, so you can look at other Surface users in the bar.  The interactions available include chat, zooming the video camera, taking and sending pictures, or send predefined phrases (read: pick-up lines) or words (remember the magnetic words you can put on your fridge?  This is the virtual version of that).

    There are a couple other applications that were available, but we didn't really check them out.  They looked to be a "virtual vegas" tour, showing attractions, shows, and other sights.

    My overall impression is that this has some great social potential.  Since there were only six tables at the iBar, there weren't a lot of choices for interaction.  A much more compelling social experience:  Someday when Surface machines are installed at other Harrah's properties around the country (or world), network them together and allow the Flirt app to work across those properties.  The fun and interactivity dynamic will be dramatically different when someone in Las Vegas "flirts" with someone in Atlantic City.

     PIC-0064Oh, and one last thing - it's with a heavy heart that I must confess that we crashed a couple of the apps - each several times.

    On the bright side, there were no GPF's or Blue Screens of Deaths.  Rather Surface just mentioned that there was a problem, killed the failed app and restarted.  Not a huge distraction for a social user who would probably have a decent count of adult beverages coursing through their system to begin with.

    The flirt app has the most promise, integrating with webcams and other Surface machines.  If it can scale without crashing, Flirt will be a great draw for many Harrah's properties.  We didn't "flirt" too much - not just because we're married, but because most of the tables were occupied by other guys...

  • Steve Lange @ Work

    Phoenix: Awesome Upcoming SDLC/VSTS Event

    • 2 Comments

    VS-header

    ADOPTING VISUAL STUDIO TEAM SYSTEM 2008

    June 12, 2008 | Phoenix, AZ |Event ID: 1032374283

    ABSTRACT/SUMMARY

    Microsoft Visual Studio Team System 2008 (VSTS) is an integrated Application Life-cycle Management (ALM) solution comprising tools, processes, and guidance to help everyone on the team improve their skills and work more effectively together. VSTS 2008 provides multi-disciplined team members with an integrated set of tools for architecture, design, development, database development, and testing of applications. Team members can continuously collaborate and utilize a complete set of tools and guidance at every step of the application lifecycle.

    This one-day seminar will walk through VSTS 2008, highlighting new features that are available in the most recent release. Presentations will include demonstrations, best practices, and discussions on all four role-specific editions. We will also cover project management with Team Foundation Server (TFS), leveraging TFS source control, and new features such as integration with MOSS, and managing the build process with continuous integration. .  During lunch, we will also have a discussion around the adoption of methodology within the enterprise including lessons and experience from customers that have been through that process.

    Please join Microsoft and Neudesic, a Microsoft Gold Certified Partner for this one-day seminar. Thank you, we look forward to seeing you there!

    COURSE OUTLINE

    Interactive seminar and demonstrations

    • VSTS Role-based Editions
      • Architect
      • Developer
      • Test
      • Database Professional
    • Team Foundation Server
    • Adopting a Methodology (lessons from other customers)
    • Best Practices
      • Version Control
      • Project Management using VSTS
      • Working with Continuous Integration

    REGISTER

    To register, please visit http://msevents.microsoft.com/ and search on the event code listed below, or call 1.877.MSEVENT (1.877.673.8366).

    Date: June 12, 2008
    Time: 9:00 AM-5:00 PM
    Location:
    Microsoft Corporation
    2929 N. Central Ave., Ste. 1400
    Phoenix, AZ 85012
    Phone: 602.280.8600
    See map and/or driving directions

    Registration Link: http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032374283&Culture=en-US

    Event ID: 1032374283

  • Steve Lange @ Work

    Where's my old Borland blog?

    • 2 Comments

    I think the folks at Borland have finally removed my StarTeam blog.  With the inception of CodeGear, CG seemed to take over the blog server, and removed me. 

    I honestly haven't touched it since leaving Borland, but several former colleagues and customers have emailed me wondering if the content is still available somewhere (I had a lot of how-to's and SDK samples posted).  I honestly don't think it's archived anywhere, but I've asked the CodeGear folks via email, and will post the URL if it's still posted somewhere.

  • Steve Lange @ Work

    Team Foundation Server: Beta 3 Refresh vs. CTP

    • 2 Comments
    Which to use for evaluation?  Well it depends on you ultimately might use the evaluated TFS install as your production server.  Keep this important note in mind.  The Beta 3 Refresh version carries a go-live license, which means that Microsoft will provide a supported migration path to the RTM version of TFS.  The CTP version does NOT carry the same promise.
  • Steve Lange @ Work

    Visual Studio Online (VSO): Owning Multiple VSO Accounts

    • 2 Comments

    NOTE: This is not official guidance, nor may it be even officially a supported “feature” in the near future (my guess is that it’s not a directly intended capability.  It’s simply a short-term workaround that assisted a few of my customers that I thought I’d share.

    Visual Studio Online by default only allows a Microsoft account to create a single VSO account.  When you create a VSO account, the system records who the owner (creator) is, and the next time that user comes back, they cannot create additional VSO accounts.

    I have customers who currently maintain several VSO accounts (for various reasons), and have done so by creating multiple Microsoft accounts, one for each VSO account.

    With the May 7th date of ending the “Early Adopter” program for VSO, I have customers in this situation asking what to do about this moving forward.

    There’s a slightly indirect, but perfectly doable way around this: a way to let a single Microsoft account “own” multiple VSO accounts.  You need two (2) Microsoft accounts (but only for VSO account creation purposes), but only two.

    For this example, I’m going to create 2 sample Microsoft accounts, one primary and one secondary (both which I’ll delete after this post – I hate stale/dummy accounts!) and show you how to create three (3) VSO accounts owned by the primary Microsoft account.

    First, I create the primary Microsoft account: SteveLangePrimary@hotmail.com

    Here’s this account’s profile page:

    image

    Note that this account neither owns any VSO accounts nor is a member of any VSO accounts.

    Using this Microsoft account, I create a new VSO account: https://stevelangeprimary.visualstudio.com/.

    Next, I sign out of Microsoft and create my secondary Microsoft account: SteveLangeSecondary@hotmail.com.

    And the resulting profile page:

    image

    Like the first account, this account neither owns any VSO accounts nor is a member of any VSO accounts.

    Using this secondary account, I create a second VSO account: https://stevelangesecondary.visualstudio.com

    Next, while still logged in as the secondary account, I go to the Users page.

    image

    Once there, I click “Add” and add the primary account (the first account I created) to this VSO account as a user, assigning a “Basic” license.

    image

    Now that the primary account is recognized as a user, I set that account to be the owner of this VSO account.  (The same below steps are described here.)

    I click on the "gear” icon at the top-right, which takes me to the Admin area.

    image

    Next, I click on the Settings tab, and for Account Owner, select my primary account from the drop-down list, and click the Save button.

    image

    NOTEWARNING: If you follow my steps to the letter, you may have the unintended consequence of removing the secondary Microsoft account’s access from all the VSO accounts.  If this is truly a “dummy” account, then it’s probably no big deal.  But if you’re using a Microsoft account you with to keep using in VSO, you’ll want to make sure you add that account as a valid member of a group in the VSO account. In this walkthrough, I added the secondary account back into the VSO as an administrator.

    So let’s see what’s happened.  Sign out, and then sign in as the primary Microsoft account.  Here’s the updated profile page for the primary account:

    image

    Notice that now this account “owns” both VSO accounts (primary and secondary).  Cool?

    Now let’s own a third VSO account.  Sign out, then back in as the secondary Microsoft account.  Here’s the secondary account’s profile page:

    image

    This should be expected now, because this account no longer owns the secondary VSO account.

    I click the link to “Create a free account now”, and create a third VSO account: https://stevelangetertiary.visualstudio.com/

    Like before, I go to the Users page, add the primary Microsoft account as a valid (Basic) user, then specify in the Administrators area that I want my primary Microsoft account to be the owner (and per the above note/warning, I add the secondary account back in). Be sure to click the “Save” button throughout!

    image

    image

    Once that’s all set, I sign out, then back in as the primary Microsoft account:

    image

    Now my primary Microsoft account owns three (3) VSO account. Sweet!

    See the pattern?

    • As a Microsoft account that doesn’t own a VSO account, create a VSO account.
    • Transfer ownership of that account to the Microsoft account you actually want to own the VSO account.
    • Sign back in as the “dummy” Microsoft account, rinse and repeat as needed.

    As an added FYI, if you have an Azure Subscription (not the same thing as Azure MSDN Benefits, by the way), you can link you Azure account to each of the VSO accounts you own, and distribute your Azure resources (users, build minutes, load testing, etc.) across each of them.

    Here’s a big disclaimer: I’m still not clear if this is intended behavior, mainly because there’s no obvious link to create additional VSO accounts while logged in as a Microsoft account that already owns one.

    Hey, but for now, this works!

  • Steve Lange @ Work

    VSO is Happy to See You! Project Welcome Pages

    • 2 Comments

    The August 18th news article on the Visual Studio site announced a fun new addition to VSO: Project Welcome pages.

    Think of Welcome pages as documentation, a greeting, or basic contextual information for the Team Project.  You can use a Welcome pages for things like:

    • Describing the purpose/business value of the project.
    • Basic tips and tricks for navigating the VSO project.
    • Project-specific nomenclature or acronyms
    • Project sponsors or contacts
    • You get the idea.. whatever!

    The implementation of these pages is surprisingly simple.  Pages are really just Markdown files (.md) which are checked in/committed to the root of your project.  The default page is named “readme.md”.  For example, in my “Awesome Calculator” project, I checked in a “readme.md”:

    image

    Now if I got to my project’s homepage, I see a “Welcome” tab.  If I click on that, I get to any/all of my Welcome pages:

    image

    Adding additional Welcome pages is simple as well.  Just check in/commit more markdown files! 

    image

    My new markdown file, “The Truth.md”, then renders like this:

    image

    If you’re not familiar with markdown, don’t fear.  It’s a simple and fast markup.  VSO utilizes of GitHub Flavored Markdown, a common convention already used in some open source version control systems, based on then “marked” open source library. You can use virtually any editor (they are just text files) to work on your markdown files, including VIsual Studio, MarkdownPad, and others.

    For additional details, please read Martin Woodward’s post on the Visual Studio ALM blog.

    Enjoy!

Page 2 of 15 (352 items) 12345»