{"id":3413,"date":"2013-06-12T00:01:00","date_gmt":"2013-06-12T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2013\/06\/12\/translate-vbscript-into-powershellnot\/"},"modified":"2013-06-12T00:01:00","modified_gmt":"2013-06-12T00:01:00","slug":"translate-vbscript-into-powershellnot","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/translate-vbscript-into-powershellnot\/","title":{"rendered":"Translate VBScript into PowerShell—Not!"},"content":{"rendered":"

Summary<\/strong>: Microsoft Scripting Guy, Ed Wilson, talks about translating VBScript script into Windows PowerShell, and he says it is not a very good idea.<\/span><\/p>\n

\"Hey, Hey, Scripting Guy! I love VBScript. I know, I know. It is not fashionable these days to say that, but it is a fact. I love using VBScript. It is powerful, and over the last ten years or so, I have written literally hundreds of scripts that we use at my company on a daily basis. I simply do not have time to translate these scripts in Windows PowerShell. I am sorry, but that is all there is to it…just sayin’.<\/span><\/p>\n

—ML<\/p>\n

\"Hey, Hello ML,<\/p>\n

Microsoft Scripting Guy, Ed Wilson, is here. The Scripting Wife and I are going through what could be called TechEd withdrawl. After nearly a week of non-stop activity, literally from 6:00 AM to midnight each day, we find ourselves missing the fun, engagement, and excitement—like a rabbit locked out of a vegetable garden. It was too much, and now it is too little. Luckily, in a few weeks there is the TechStravaganza 2013 in Atlanta<\/a>, and then there is TechEd 2013 Europe in Madrid<\/a>. So we get a chance to do it all over again.<\/p>\n

Anyway, ML, I thought I would take some time to review some of my email sent to scripter@microsoft.com<\/a>, and I came across your letter. Here are some thoughts…<\/p>\n

Do not translate VBScript into Windows PowerShell…<\/h2>\n

Never. Never. Never. Never. Never!<\/p>\n

Of the more than 3,000 VBScript scripts I wrote years ago, I have translated fewer than two dozen into Windows PowerShell. Each of those was for academic purposes, not for real-life purposes. The reason is that Windows PowerShell and VBScript are completely different. You may as well try to turn applesauce into mashed potatoes. It might seem like a good idea at the time—but dude! (or dudette!), I am not certain of a really acceptable outcome.<\/p>\n

Need some proof? OK, how about this one:<\/p>\n

This script is a basic WMI script from the Scripting Guys Script Center Repository. It is called Retrieving BIOS Information<\/a>, and it does a great job. In fact, I have used this particular script on more than one occasion over the last decade and a half—in production and in teaching situations. Here is the script:<\/p>\n

strComputer = “.”<\/p>\n

Set objWMIService = GetObject(“winmgmts:” _<\/p>\n

    & “{impersonationLevel=impersonate}!\\\\” & strComputer & “\\root\\cimv2”)<\/p>\n

 <\/p>\n

Set colBIOS = objWMIService.ExecQuery _<\/p>\n

    (“Select * from Win32_BIOS”)<\/p>\n

 <\/p>\n

For each objBIOS in colBIOS<\/p>\n

    Wscript.Echo “Build Number: ” & objBIOS.BuildNumber<\/p>\n

    Wscript.Echo “Current Language: ” & objBIOS.CurrentLanguage<\/p>\n

    Wscript.Echo “Installable Languages: ” & objBIOS.InstallableLanguages<\/p>\n

    Wscript.Echo “Manufacturer: ” & objBIOS.Manufacturer<\/p>\n

    Wscript.Echo “Name: ” & objBIOS.Name<\/p>\n

    Wscript.Echo “Primary BIOS: ” & objBIOS.PrimaryBIOS<\/p>\n

    Wscript.Echo “Release Date: ” & objBIOS.ReleaseDate<\/p>\n

    Wscript.Echo “Serial Number: ” & objBIOS.SerialNumber<\/p>\n

    Wscript.Echo “SMBIOS Version: ” & objBIOS.SMBIOSBIOSVersion<\/p>\n

    Wscript.Echo “SMBIOS Major Version: ” & objBIOS.SMBIOSMajorVersion<\/p>\n

    Wscript.Echo “SMBIOS Minor Version: ” & objBIOS.SMBIOSMinorVersion<\/p>\n

    Wscript.Echo “SMBIOS Present: ” & objBIOS.SMBIOSPresent<\/p>\n

    Wscript.Echo “Status: ” & objBIOS.Status<\/p>\n

    Wscript.Echo “Version: ” & objBIOS.Version<\/p>\n

    For i = 0 to Ubound(objBIOS.BiosCharacteristics)<\/p>\n

        Wscript.Echo “BIOS Characteristics: ” & _<\/p>\n

            objBIOS.BiosCharacteristics(i)<\/p>\n

    Next<\/p>\n

Next<\/p>\n

Translating to Windows PowerShell…<\/h2>\n

So we have a great VBScript script that retrieves bios information from local and remote computers, and it is something we use all the time. So we decide to translate it to Windows PowerShell. Here is the result:<\/p>\n

$strComputer = “.”<\/p>\n

 <\/p>\n

$colItems = get-wmiobject -class “Win32_BIOS” -namespace “root\\CIMV2” `<\/p>\n

-computername $strComputer<\/p>\n

 <\/p>\n

foreach ($objItem in $colItems) {<\/p>\n

      write-host “BIOS Characteristics: ” $objItem.BiosCharacteristics<\/p>\n

      write-host “BIOS Version: ” $objItem.BIOSVersion<\/p>\n

      write-host “Build Number: ” $objItem.BuildNumber<\/p>\n

      write-host “Caption: ” $objItem.Caption<\/p>\n

      write-host “Code Set: ” $objItem.CodeSet<\/p>\n

      write-host “Current Language: ” $objItem.CurrentLanguage<\/p>\n

      write-host “Description: ” $objItem.Description<\/p>\n

      write-host “Identification Code: ” $objItem.IdentificationCode<\/p>\n

      write-host “Installable Languages: ” $objItem.InstallableLanguages<\/p>\n

      write-host “Installation Date: ” $objItem.InstallDate<\/p>\n

      write-host “Language Edition: ” $objItem.LanguageEdition<\/p>\n

      write-host “List Of Languages: ” $objItem.ListOfLanguages<\/p>\n

      write-host “Manufacturer: ” $objItem.Manufacturer<\/p>\n

      write-host “Name: ” $objItem.Name<\/p>\n

      write-host “Other Target Operating System: ” $objItem.OtherTargetOS<\/p>\n

      write-host “Primary BIOS: ” $objItem.PrimaryBIOS<\/p>\n

      write-host “Release Date: ” $objItem.ReleaseDate<\/p>\n

      write-host “Serial Number: ” $objItem.SerialNumber<\/p>\n

      write-host “SMBIOS BIOS Version: ” $objItem.SMBIOSBIOSVersion<\/p>\n

      write-host “SMBIOS Major Version: ” $objItem.SMBIOSMajorVersion<\/p>\n

      write-host “SMBIOS Minor Version: ” $objItem.SMBIOSMinorVersion<\/p>\n

      write-host “SMBIOS Present: ” $objItem.SMBIOSPresent<\/p>\n

      write-host “Software Element ID: ” $objItem.SoftwareElementID<\/p>\n

      write-host “Software Element State: ” $objItem.SoftwareElementState<\/p>\n

      write-host “Status: ” $objItem.Status<\/p>\n

      write-host “Target Operating System: ” $objItem.TargetOperatingSystem<\/p>\n

      write-host “Version: ” $objItem.Version<\/p>\n

      write-host<\/p>\n

}<\/p>\n

This is an actual script that comes from the Script Center Repository: List BIOS Information<\/a>. I am including the link because it is a perfect example of a horrible Windows PowerShell script, and anyone teaching a Windows PowerShell class should have access to a script such as this. (And no, I did not write this script—it was bulk uploaded four years ago using the Scripting Guys Live ID…Oh well.)<\/p>\n

Comparing the two scripts, I see very little difference. Here are the two scripts (somewhat truncated) side-by-side:<\/p>\n

\"Image<\/a><\/p>\n

Writing the script in Windows PowerShell…<\/h2>\n

Instead of translating VBScript into Windows PowerShell, take advantage of the inherent capabilities of Windows PowerShell instead of forcing Windows PowerShell to do VBScript. Indeed, it is not my intention to make fun of VBScript, because I have also seen Windows PowerShell code that was written in C#, or C++, or Perl.<\/p>\n

The cool thing is that Windows PowerShell is very flexible, and it is possible to get things up and running easily. Here is the previous BIOS script, written so that it takes advantage of Windows PowerShell:<\/p>\n

Get-WmiObject Win32_Bios<\/p>\n

That is it.<\/p>\n

This connects to WMI and retrieves BIOS information. It can also be written by using the CIM cmdlets from Windows PowerShell 3.0 as shown here:<\/p>\n

Get-CimInstance Win32_Bios<\/p>\n

The thing that is incredible in both examples is that there are fewer LETTERS in the command than there are LINES in the previous script.<\/p>\n

So, ML, please, please, please, please do not translate your old VBScript scripts into Windows PowerShell. If you do, you will do the following:<\/p>\n

    \n
  1. Waste your time redoing something that already works.<\/li>\n
  2. Waste your time by writing very bad Windows PowerShell code.<\/li>\n
  3. Come away confused as to what “all the fuss” surrounding Windows PowerShell is about.<\/li>\n
  4. Contribute to the already too large pool of bad Windows PowerShell code.<\/li>\n<\/ol>\n

    ML, your job as an IT pro is to get stuff done, not to write code (Windows PowerShell, VBScript, or otherwise). Therefore, if you have something that works, stay with it.<\/p>\n

    If or when you need NEW code, I would advise you to write it in Windows PowerShell. To get started, see the Scripting with Windows PowerShell<\/a> in the Script Center. You might also want to pick up a copy of my book, Windows PowerShell 3.0 Step by Step<\/a>, and follow along there.<\/p>\n

    ML, there are my thoughts about translating VBScript to Windows PowerShell. Join me tomorrow when I will talk about more cool Windows PowerShell stuff.<\/p>\n

    I invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

    Ed Wilson, Microsoft Scripting Guy<\/strong> <\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

    Summary: Microsoft Scripting Guy, Ed Wilson, talks about translating VBScript script into Windows PowerShell, and he says it is not a very good idea.  Hey, Scripting Guy! I love VBScript. I know, I know. It is not fashionable these days to say that, but it is a fact. I love using VBScript. It is powerful, […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[51,3,4,45],"class_list":["post-3413","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

    Summary: Microsoft Scripting Guy, Ed Wilson, talks about translating VBScript script into Windows PowerShell, and he says it is not a very good idea.  Hey, Scripting Guy! I love VBScript. I know, I know. It is not fashionable these days to say that, but it is a fact. I love using VBScript. It is powerful, […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/3413","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=3413"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/3413\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=3413"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=3413"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=3413"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}