Andrew Coates ::: MSFT

It's all about community!

  • Andrew Coates ::: MSFT

    What version of TFS am I Running?

    • 5 Comments

    Chris Birmele, our (ostensibly neutral) VSTS Technical Specialist was complaining about not being able to work out what version (Beta, RC, RTM, SP1) and which Edition (Standard, Trial, Workgroup) of TFS was running on a machine. After consulting with VSTS MVP and all-round TFS guru, Anthony Borton, I was able to point Chris to Rob Caron's article on this very topic.

    Chris was less than impressed with having to spelunk through folders and the registry so I whipped him up a command line utility to do his dirty work.

    image

    Here's the source:

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.IO;
    using System.Diagnostics;
    using Microsoft.Win32;
    
    namespace TFSVer
    {
        class Program
        {
    
    
            static void Main(string[] args)
            {
                if (args.Length > 0)
                {
                Console.WriteLine("TFSVer - Version Information for Team Foundation Server");
                Console.WriteLine();
                Console.WriteLine("Usage: TFSVer");
                    return;
    
                }
    
                StringBuilder VersionInfo = new StringBuilder("Team Foundation Server Version Information\n==========================================\n");
                                                               
                // go and get the version info
                // based on Rob Caron's Blog Post http://blogs.msdn.com/robcaron/archive/2006/08/15/701843.aspx
    
                /*
                 1. On the application-tier computer, check the file version of Microsoft.TeamFoundation.Server.dll. 
                 
                 You'll find this file here:
    
                    %PROGRAMFILES%
                      \Microsoft Visual Studio 2005 Team Foundation Server
                        \Web Services
                          \Services
                            \Bin
    
                    Here's the key to determine which release of Team Foundation Server you have:
    
                    8.0.50727.43 = Beta 3 Refresh 
                    8.0.50727.127 = Release Candidate 
                    8.0.50727.147 = RTM (final shipping release of the product)
                    Update: The version number for Visual Studio 2005 SP1 is 8.0.50727.762.
                 */
    
                string DllVersion = "";
                string tfsVersion = "Unrecognised";
                bool RTMorLater = false;
                try 
                {    
                    FileVersionInfo TheFile = FileVersionInfo.GetVersionInfo(Environment.GetEnvironmentVariable("PROGRAMFILES") + "\\Microsoft Visual Studio 2005 Team Foundation Server\\Web Services\\Services\\Bin\\Microsoft.TeamFoundation.Server.dll");
                    DllVersion = TheFile.FileVersion;
                    switch (DllVersion)
                    {
                        case "8.0.50727.43":
                        {
                            tfsVersion = "Beta 3 Refresh";
                            break;
                        }
    
                        case "8.0.50727.127":
                        {
                            tfsVersion = "Release Candidate";
                            break;
                        }
    
                        case "8.0.50727.147":
                        {
                            tfsVersion = "RTM";
                            RTMorLater = true;
                            break;
                        }
    
                        case "8.0.50727.762":
                        {
                            tfsVersion = "SP1";
                            RTMorLater = true;
                            break;
                        }
    
                        default:
                        {
                            break;
                        }
    
                    }
                    
                    VersionInfo.AppendLine(string.Format("TFS Version: {0}", tfsVersion));
    
                    // now go and find the Edition (If we're in RTM or later)
                    if (RTMorLater)
                    {
                        /*
                            If you have the RTM release, the next check is to see which edition of Team Foundation Server you have. To do this, open Registry Editor (regedt32.exe) and navigate down to this key:
    
                            HKEY_LOCAL_MACHINE
                              \SOFTWARE
                                \Microsoft
                                  \VisualStudio
                                    \8.0
                                      \TeamFoundation
                                        \Registration
    
                            In this key, you'll find a value named, Edition_CT, which is the clear text equivalent of the encrypted data in Edition. Here's the key to determine which edition you have:
    
                            "Full" = Team Foundation Server ("Standard Edition") 
                            "Trial" = Team Foundation Server 180-day Trial Edition 
                            "Workgroup" = Team Foundation Server Workgroup Edition 
                         */
    
                        string Edition = "unknown";
                        string rk = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\VisualStudio\\8.0\\TeamFoundation\\Registration").GetValue("Edition_CT").ToString();
    
                        switch (rk)
                        {
                            case "Full":
                                {
                                    Edition = "Team Foundation Server (\"Standard Edition\")";
                                    break;
                                }
                            case "Trial":
                                {
                                    Edition = "Team Foundation Server 180-day Trial Edition";
                                    break;
                                }
                            case "Workgroup":
                                {
                                    Edition = "Team Foundation Server Workgroup Edition";
                                    break;
                                }
                            default:
                                break;
                        }
    
                        VersionInfo.AppendLine(string.Format("Edition: {0}", Edition));
    
                    }
               
                }
                catch (FileNotFoundException fnfEx)
                {
                    VersionInfo.AppendLine("TFS Not Installed on this machine");
                }
    
                Console.WriteLine(VersionInfo.ToString());
                Console.WriteLine("Press any key to continue ...");
                Console.ReadKey();
    
            }
    
         }
    }
    

    And I've attached the binary project with the binaries in the Release and Debug folders.

    As usual, this is a hack without production-level quality control or any exception handling. You'll need to give it sufficient caspol permissions to read the registry and environment variables (I generally copy it to somewhere on the local machine). Use at your own risk.

  • Andrew Coates ::: MSFT

    Microsoft Speak

    • 11 Comments

    I've been at Microsoft for just on 6 months now and I guess that's a reasonable amount of time to have settled in and got an impression of the place from the inside. One thing that's struck me (especially having been an independent contractor for the 7 years prior to starting here) is the localised version of the language spoken here. It's not just the TLAs and the code names that I'm talking about (although there are enough of those), it's mannerisms as well. The one that I notice most often (and that I've discovered that I've subconsciously adopted) is prefixing the answer to any question with the word "So". Here's an example:

     

    Q: What's Microsoft's roadmap for the release of Visual Studio 2005?

     

    A: So, what we've announce publicly is … < answer continues here >

     

    This seems to just happen, regardless of the context of the conversation or audience, but especially when resuming an inturrupted conversation.

     

    The next idiosyncrasy we adopt is the use of the word "right" to confirm that our interlocutor agrees with the position we've put forward. This might sound like fairly standard practice, but it seems we've made it into an art form. It generally gets used either when we're not sure of the position even though we're putting it forward as gospel (as in "I know it doesn't work that way yet, but that's going to be included in beta 2, right?") or when we're so sure of the position that the conversation probably shouldn't even be happening. It seems not to be used in the middle ground situation (where the speaker knows the answer, but doesn't expect the audience to know it as well).

     

    We speak a lot about things happening in the <insert product codeword here> timeframe. I guess this one makes some sense. It's much more accurate to say that "Object Spaces will be released in the Longhorn timeframe" than to try to give a month and year. It just strikes me as interesting every time this happens (and trust me, it happens a lot).

     

    I'm not from a very corporate background (I worked at a university for 3 years before my 7 years as an independent), so I'm not sure how widespread the phrase "going forward" is (as in, "that's our plan going forward). I would guess that it's generally not uncommon, but it's endemic where I work. It seems a little more "jargony" than something like "from now on" or "in the future". It's another phrase that I notice every time it's used, and one that makes me cringe whenever I catch myself using it.

     

    Finally the phrase that I hear most often is

     

    dramatically provide access to mission-critical leadership skills and assertively coordinate world-class paradigms for 100% customer satisfaction

     

    Only kidding -- I got that one from the Dilbert Mission Statement Generator. http://www.dilbert.com/comics/dilbert/games/career/bin/ms.cgi

  • Andrew Coates ::: MSFT

    Sydney VFP User Group WebCast

    • 4 Comments

    UPDATE

    REQUIREMENTS FOR ATTENDING THIS WEB CONFERENCE:
    • A computer with access to the Internet to view the visual portion of the webcast.
    • A functioning sound card and speakers or headphones for your PC.
    • Test your computer:
    1. To test your computer for the proper configuration click on the following link: http://esd.placeware.com/wintest
    2. Please install and run Live Meeting Software if prompted to do so.
    3. You should see a Live Meeting Console with 3 revolving slides.  If you are able to see all three slides, your test was successful. 
    4. If you are not able to see the slides, or if your system is stalled, please contact Event Support (see below).

    ON THE WEBCAST DAY, FOLLOW STEPS A & B 15 minutes before the webcast begins:
    A. To view the Internet portion:

    1. Click the Meeting URL:
    http://www.placeware.com/cc/lmevents/join?id=msft092904ac&role=attend&pw=KJS89Q
     
    OR, if you can’t click the above Meeting URL, click on this link: http://www.placeware.com/cc/lmevents/join
    Clicking on either URL, you will arrive at the Join Meeting page and in the following fields, check or enter this information:
    a. Your Name: (enter your First and Last name)
    b. Meeting ID: msft092904ac
    c. Password: KJS89Q
    Click Submit
    2. On the next page, please enter your Email and Company Name (if required) and click Submit.
    3. You must install and run Live Meeting Software if prompted to do so.
    4. Please allow a few moments for your Console to launch.

    B. Listen to the audio portion of the webcast:
    Once you have logged into the Internet portion, click the “Click Here for Audio” link on the left of the Audience window. The VoiceNow! player will take a moment to load.  You should hear hold music prior to the webcast start time. If you do not hear the audio, please confirm that your PC speakers are on and that the volume is turned up.


    This wednesday night (29 Sep 2004, 18:30 Sydney time -- GMT + 10), we will be webcasting the Sydney VFP User Group Meeting. The video of the presenters' screen will be streamed, as will the audio of their presentation.

    The Melbourne VFP User Group will be gathering at the MS theatre at the Como Centre to view the webcast en masse, while I expect other VFP developers from around Australia will log in from their desks.

    This is a test run for the more general case of webcasting User groups of many different flavours over the next few months. We're hoping to lean a lot from this first pass, and will keep striving to make this the best experience possible.

    Details of the content of the meeting are (from the User Group's web site):

    Next meeting (29 September 2004)

      This month we will have 4 mini-talks of 20 minutes each covering the following topics
    I want to know how to...
    The format for this month will be a little different to usual, in that the aim is to cover 4 topics briefly by way of an eye-opener for people who haven't used them before.

    All attendees are encouraged to come with their own ideas to contribute, as there is no one 'right' way to do things.

    We will also have our regular Q+A session at the end.

    This meeting will be combined online with the Melbourne VFP User Group!

    Where
    The Sydney Visual FoxPro User Group meets at Microsoft headquarters:

    6:30pm - 8:30pm
    Microsoft Sydney Office
    Theatre 2
    1 Epping Road
    North Ryde NSW 2113

    Pizza and drinks are provided

    Note - if you come after 6:30pm you will need to call security to let you in - the number to call will be on a notice at the door

    Contact
    For details of upcoming meetings or general questions please email Craig Bailey (UG President)

  • Andrew Coates ::: MSFT

    .NET Framework 3.5 Namespaces Poster Available

    • 1 Comments

    clip_image002This just in from Paul Andrew.

    We just completed the .NET Framework 3.5 update to the Commonly Used Types and Namespaces poster.

    Here's a link to the file (PDF, XPS and 16-page XPS) if you want to grab it now and be the first on your block to get it on your wall. We'll be using it at a variety of places, if you think it would be a cool thing to have at a Microsoft event then please go suggest it to some Microsoft employee that you know.

    Let me point out the little additive circles diagram at the bottom right. We've found that this is a great way to explain the additive version releases of the .NET Framework 2.0 – 3.0 – 3.5. The primary reason for updating the .NET Framework this additive way instead of the side-by-side nature of .NET Framework 1.1 – 2.0 is to make it easier for customers to upgrade their apps. Here's that diagram again.

  • Andrew Coates ::: MSFT

    Standing on the Shoulders of Giants

    • 14 Comments

    26-Sep Updated table formatting

    image

    "If I have seen a little further it is by standing on the shoulders of Giants"

    Isaac Newton 1676*

    As a Developer Evangelist, I'm often talking about the value of "the Platform" and sometimes it takes a little while for people to see that value. I like to tell a story about the evolution of a platform

    image image Imagine it's 10,000 years ago and you live in a cave up the hill to the left. Getting water is a matter of walking the 500m down to the stream, using the water and then walking home. That’s fine if it’s a beautiful day like in this picture. The next day, however, there’s a severe storm so going outside is already unpleasant. To make matters worse, a large carnivore chases you when you do venture out into the elements go to get water. Once you get there, you find that one of your neighbours has slaughtered a woolly mammoth just upstream and the water is polluted and unusable. You have to go over the next hill (5 km) just to get water.
    image image Fast forward to 4,000 years ago and you’re living in a village in the African desert. Your village has constructed a well and you maintain it collectively. You still have to go outside for water, but not nearly as far, and all of the people in the village contribute to the maintenance.  Your water supply occasionally dries up, but is much more reliable than having to go down to a stream. 
    image imageFast-forward to 150 years ago** in the city of London. You now live in a lovely house in Broad Street. Just outside your front door, the City of London has installed a pump (or, more accurately, has contracted a private company to install a pump) connected to the new-fangled plumbing. You still need to go outside for your water, but you don’t have to worry about maintaining the pump, and there are public health professionals ready to remove the handle of the pump if too many of your neighbours catch cholera.
    image imageimageFast forward to today. Now you get water plumbed into every part of your house. The question now is not "how do I get water?", rather it’s "what do I want to do with water?"  Delivery of water is now a platform on which you can build, rather than being a task on its own.
    image We've seen this platform evolution (albeit on a much shorter time scale) in pretty much everything that happens with computers. From having to write your own code to read and write bytes from a disk (or punch card, or circuit board) to letting the operating system handle it for you. From having to write your own code to paint a window on the screen to letting the framework handle it for you. From sourcing drivers for every piece of hardware to having it just work when you plug it in and so on.

    One of the questions I often get asked is whether abstracting away the details of the working of the platform makes us less connected from the source and therefore somehow less capable. There's no requirement to not understand how the platform works (just like, as a Civil Engineer, I understand water supply systems pretty well), but equally, there's no requirement to rebuild the platform every time you want to build something on top of it. Whether I'm installing an espresso machine or a hydroponics farm, I can use the water supply platform without having to drill a well, install a reverse-osmosis plant, install solar panels for power and so on.

    MPj04008460000[1]This also makes a distinction between platform and services. Pat Helland pioneered the concept of a metropolis where he described the various utilities (water supply, sewerage, electricity, roads, railway lines, ports, telecommunications infrastructure etc) as services (I haven't done Pat's work any justice at all here - go and read his paper). I'd argue that these are actually the platform on which services (schools, high-speed internet access, parcel delivery, banking, petrol stations etc) can be built. In a similar way, in the Software plus Services story both the software and the services are built on a platform (or platforms). The more common functionality the platform provides, the more time service providers can spend on the provision of the actual service. For example, pretty much every provider of any significant services in the cloud needs to have a way to authenticate and bill (or otherwise gain benefit from) users of the service. There aren't that many schemes for doing either of these things and so it makes sense to have the platform (on which the service is built) provide this functionality. By factoring out commodity platform capabilities (i.e. billing, provisioning, SLA monitoring and management, auth[n|r], messaging, CRM, monetization services etc.), the service provider is free to invest fully in an offering in their domain of expertise, without being encumbered by having to build out these concerns.  Customers are also free to pick and choose those services that make the most sense, again without having to build out (and care and feed for) commodity capability. 

    This has the related effect that the costs of these cross-cutting platform capabilities – which cost a lot to develop and maintain – can be amortised against a much larger population of users. In turn, this tends to bring the cost of the services down, which makes them more accessible to smaller organisations (i.e. further along the tail).  This is a democratising effect  - i.e. now a small software firm can afford an enterprise-grade provisioning, billing and SLA management engine, and can scale this according to their needs, and therefore potentially compete with larger players, or offer lower-cost services to customers who are also further along the tail.

    Time to value is shorter.  If a service provider can focus on their offering sans the surrounding infrastructure, they can deliver services much more quickly, and can respond to opportunities in the market more rapidly.   Related to this is the expectation that markets and offerings will evolve much more quickly than ever before.  If you aren’t tied down by infrastructural drag, you can innovate much more quickly.

    Acknowledgements

    Many thanks to Nigel Watson for his insight and additional thoughts.

    * Yes, I'm aware that Isaac probably wasn't the first person to use this phrase, but he's probably the most famous
    ** OK, OK, the picture's obviously not from 150 years ago (of course, the first one is from 10,000 years ago), but I really wanted a picture of this pump - it's because of my background in GIS

  • Andrew Coates ::: MSFT

    Wow, Now I'm MCPD!

    • 10 Comments

    Call me unusual, but I like doing the MS Certification exams. First, some history.

    MCP LogoMy first exam was way back in 1999, when I participated in the beta program for the (then) new Visual FoxPro exams, 70-155 (Designing and Implementing Distributed Applications with Microsoft® Visual FoxPro® 6.0) and 70-156 (Designing and Implementing Desktop Applications with Microsoft® Visual FoxPro® 6.0). These were awarded when the beta program for those exams finished on 09 Feb 2000. All of a sudden I was an MCP.

    MCSD LogoI was hooked. Soon afterwards I followed up with the compulsory 70-100 (Analyzing Requirements and Defining Solution Architectures) and the optional 70-029 (Designing and Implementing Databases with Microsoft® SQL Server 7.0) exams and by April 12 that year I was an MCSD (although not MCSD.NET - this was in the Win32 timeframe).

    I haven't hyperlinked any of the exams above, because they've since been retired and are no longer listed on the MCP exam site. Some time passed after this as I hadn't moved to .NET (I was still working a lot with VFP), and there were no new exams that seemed relevant.

    That changed in 2004 when I accepted this role at MS, and in August 2005 I passed my first .NET exam: 70-305 (Developing and Implementing Web Applications with Microsoft® Visual Basic® .NET and Microsoft® Visual Studio® .NET). I sat the exam at our internal technical conference, TechReady and I found that sitting exams at a conference made a lot of sense. It was time that was already out of band for me, I was half-way across the world, immersed in the technology and I wasn't likely to get distracted by the day-to-day events that seem to sap your time for doing "optional" things.

    The next year (2006) at TechReady, I really went for it. I sat and passed 4 exams in a week (in chronological order) - 70-431 (TS: Microsoft® SQL Server™ 2005 - Implementation and Maintenance), the foundation 70-536 (TS: Microsoft® .NET Framework 2.0 - Application Development Foundation), 70-528 (TS: Microsoft® .NET Framework 2.0 - Web-based Client Development) and 70-526 (TS: Microsoft® .NET Framework 2.0 - Windows®-based Client Development). This gave me a new certification in the new generation of certifications. I was now a MCTS three times over (2 in .NET and one in SQL 2005).

    This year I took the same approach. I sat and passed another 4 exams in a week: one TS; 70-529 (TS: Microsoft® .NET Framework 2.0 - Distributed Application Development) and three PRO; 70-547 (PRO: Designing and Developing Web-based Applications by Using the Microsoft® .NET Framework), 70-548 (PRO: Designing and Developing Windows®-based Applications by Using the Microsoft® .NET Framework) and 70-549 (PRO: Designing and Developing Enterprise Applications by Using the Microsoft® .NET Framework). This gave me an additional MCTS (.Net Framework 2.0: Distributed Applications) and also certified me as a MCPD three times over (Web Developer, Windows Developer and Enterprise Application Developer)

    My impression of the certification program and the exams is very positive. Each time I study for and sit an exam I feel that I learn more and more about the breadth and capability of the product or technology I'm studying. Being forced to explore all of the parts means that I discover areas I may never have come across day-to-day, but that prove useful as I go about my job. It also helps me build an overall picture of (in this case) the framework and how its parts fit together. Finally, it gives me a tangible set of achievements to which I can point my manager (or a potential employer). Having passed these exams demonstrates a base level of knowledge and at least some interest in furthering my understanding of the tools I'm using. Note that I'm not saying that this is the only way to further one's understanding, indeed it's not the only way I use, but it is something that is easily demonstrated. I only need to point interested parties at the Transcript Sharing Page and tell them to use TranscriptID 735419 and Access Code AndrewCoates.

    If you've got to the end of this rather long post and you want more information about Microsoft Certifications, there's the official site, but you can do a lot worse than to subscribe to Trika Harms zum Spreckel's entertaining blog (although, if you get a chance to meet Trika in person as I just have at TechEd, you won't be at all surprised that her blog is so entertaining). Local MVP and certification junkie Rob Farley also often posts great information.

  • Page 3 of 47 (470 items) 12345»