{"id":9851,"date":"2006-08-02T05:08:00","date_gmt":"2006-08-02T05:08:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/powershell\/2006\/08\/02\/joel-on-software-on-the-power-of-a-good-language\/"},"modified":"2019-02-18T13:21:27","modified_gmt":"2019-02-18T20:21:27","slug":"joel-on-software-on-the-power-of-a-good-language","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/powershell\/joel-on-software-on-the-power-of-a-good-language\/","title":{"rendered":"Joel-On-Software on the power of a good language"},"content":{"rendered":"

Joel Spolsky of Joel-On-Software fame, just posted a blog, “Can Your Programming Language Do This?” http:\/\/www.joelonsoftware.com\/items\/2006\/08\/01.html<\/a><\/p>\n

In this article, he drives home the point that when it comes to code: Maintainability, Readability, Abstraction == Good!  He then points out how languages can help or hinder this and goes on to articulate the things a language should do to help.  We couldn’t agree more.  He could have renamed the article, “Why Windows PowerShell is a Great Language!”.  <\/p>\n

Open up Joel’s blog entry in a separate window and compare the code. You should notice 2 things immediately <\/p>\n

    \n
  1. Windows PowerShell code looks amazingly like the code Joel said he wanted.  There are a couple of syntactic <\/span>differences but not many.<\/li>\n
  2. Windows PowerShell is giving you answers!  In other words, I did everything using the interactive console.<\/li>\n<\/ol>\n

    Joel uses the function ALERT to display info so to make it easier to compare, I created an Alias:<\/p>\n

    PS> Set-Alias Alert Write-Host<\/font><\/strong><\/font><\/span><\/p>\n

    PS> Alert “I’d Lke some Spaghetti!”<\/font><\/strong><\/font><\/span><\/p>\n

    I’d Lke some Spaghetti!
    PS> Alert “I’d Lke some Chocolate Moose!”<\/strong><\/font><\/font><\/span><\/p>\n

    I’d Lke some Chocolate Moose!
    <\/font><\/span><\/p>\n

    <\/font> <\/p>\n

    Noone likes repeated code so he created a function:<\/p>\n

    PS> function SwedishChef ($food)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {   <\/span>Alert “I’d like some $food !”<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    >> <\/font><\/font><\/strong><\/span><\/p>\n

    PS> SwedishChef Spaghetti<\/font><\/strong><\/font><\/span><\/p>\n

    I’d like some Spaghetti !
    PS> SwedishChef “Chocolate Moose”<\/font><\/strong><\/font><\/span><\/p>\n

    I’d like some Chocolate Moose !
    <\/font><\/span><\/p>\n

     <\/p>\n

    Joel then makes the point that being able to pass functions as parameters increases the chances that you’ll be able to find common code:<\/p>\n

    PS> Function PutInPot($Ingredient) {Alert “POT: $Ingredient added”}<\/font><\/strong><\/font><\/span><\/p>\n

    PS> Function BoomBoom($Ingredient) {Alert “BOOM: $Ingredient”}<\/font><\/strong><\/font><\/span><\/p>\n

    PS> Function Cook ($i1, $i2, $f)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>Alert “Get the $i1”<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>&$f $i1<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>&$f $i2<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    >> <\/font><\/font><\/strong><\/span><\/p>\n

    PS> Cook Lobster Water PutInPot<\/font><\/strong><\/font><\/span><\/p>\n

    Get the Lobster
    POT: Lobster added
    POT: Water added
    PS> Cook Chicken Coconut BoomBoom<\/strong><\/font><\/font><\/span><\/p>\n

    Get the Chicken
    BOOM: Chicken
    BOOM: Coconut
    <\/font><\/span><\/p>\n

     <\/p>\n

    He then points out that the problem with this is that you have to have the functions defined a priori.  Wouldn’t it be more flexible\/powerful if you could write them inline instead of declaring them elsewhere (anonymous functions)?  If you could do that, then it reduces the cost\/burden to reuse code:<\/p>\n

    PS> Cook Lobster Water {Param($x) Alert “Pot $x”}<\/strong><\/font><\/font><\/span><\/p>\n

    Get the Lobster
    Pot Lobster
    Pot Water
    PS> Cook Chicken Coconut {Param($x) Alert “Boom $x”}<\/font><\/strong><\/font><\/span><\/p>\n

    Get the Chicken
    Boom Chicken
    Boom Coconut
    <\/font><\/span><\/p>\n

     <\/p>\n

    Once you have anonyous functions as arguments, you begin to see the world in a different way.  First Joel shows you a traditional approach to doubling all the elements of an array:<\/p>\n

    <\/p>\n

    PS> $a = 1,2,3<\/font><\/strong><\/font><\/span><\/p>\n

    PS> for ($i = 0; $i -lt $a.length; $i++) {Alert $a[$i]}<\/font><\/strong><\/font><\/span><\/p>\n

    2
    4
    6
    <\/font><\/span><\/p>\n

    But now let’s use write a generic function which takes a function and an array as parameter and then applies that function to each element in the array:<\/p>\n

    PS> function map ($fn, $a)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>for ($i = 0; $i -lt $a.length; $i++)<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>{  <\/span>$a[$i] = &$fn $a[$i]<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>}<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    That allows you to now do this:<\/p>\n

    PS> $a = 1,2,3<\/font><\/strong><\/font><\/span><\/p>\n

    PS> map {param($x) return $x*2} $a<\/font><\/strong><\/font><\/span><\/p>\n

    PS> map Alert $a<\/font><\/strong><\/font><\/span><\/p>\n

    2
    4
    6
    <\/font><\/span><\/p>\n

     <\/p>\n

    Another example of this is the following 2 functions.  Both of these add elements to an initial value.  In the first case (SUM), the elements are added as integers.  In the second case (JOIN), the elements are added as strings.<\/p>\n

    PS> function sum ($a)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>$s = 0<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>for ($i = 0; $i -lt $a.length; $i++) <\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>{   <\/span>$s += $a[$i]<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>}<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>return $s<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    <\/font><\/span><\/p>\n

    PS> function join ($a)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>$s = “”<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>for ($i = 0; $i -lt $a.length; $i++)<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>{  <\/span>$s += $a[$i]<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>}<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>return $s<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    >> <\/font><\/span><\/p>\n

    PS> alert (sum 1,2,3)<\/font><\/strong><\/font><\/span><\/p>\n

    6
    PS> alert (join “a”,”b”,”c”)<\/font><\/strong><\/font><\/span><\/p>\n

    abc
    <\/font><\/span><\/p>\n

     <\/p>\n

    Look at the details of these functions and you’ll see that they are almost identical except for the initial value (0 vs “”).  So now let’s refactor these functions to use a common function (REDUCE):<\/p>\n

    PS> function reduce ($fn, $a, $init)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>$s=$init<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>for ($i = 0; $i -lt $a.length; $i++)<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>{  <\/span>$s = &$fn $s $a[$i]<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>}<\/font><\/font><\/strong><\/span><\/p>\n

    >>    <\/span>return $s<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    <\/font><\/span><\/p>\n

    PS> function sum ($a)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>return reduce {param($a,$b) return $a + $b} $a 0<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    >> <\/font><\/font><\/strong><\/span><\/p>\n

    PS> function join ($a)<\/font><\/strong><\/font><\/span><\/p>\n

    >> {  <\/span>return reduce {param($a,$b) return $a + $b} $a “”<\/font><\/font><\/strong><\/span><\/p>\n

    >> }<\/font><\/font><\/strong><\/span><\/p>\n

    >> <\/font><\/font><\/strong><\/span><\/p>\n

    PS> alert (sum 1,2,3)<\/font><\/strong><\/font><\/span><\/p>\n

    6
    PS> alert (join “a”,”b”,”c”)<\/font><\/strong><\/font><\/span><\/p>\n

    abc
    <\/font><\/span><\/p>\n

    Joel – thanks for an the eloquent articulation <\/span>of the value of Windows PowerShell!  <\/p>\n

    Jeffrey Snover [MSFT]
    Windows PowerShell\/Aspen Architect
    Visit the Windows PowerShell Team blog at:        http:\/\/blogs.msdn.com\/PowerShell<\/a>
    Visit the Windows PowerShell ScriptCenter at:      http:\/\/www.microsoft.com\/technet\/scriptcenter\/hubs\/msh.mspx<\/a><\/p>\n

     <\/p>\n

    PSMDTAG:FAQ: Anonymous Functions – are they supported? ANSWER: YES<\/p>\n

    PSMDTAG:LANGUAGE: Anonymous Functions<\/p>\n","protected":false},"excerpt":{"rendered":"

    Joel Spolsky of Joel-On-Software fame, just posted a blog, “Can Your Programming Language Do This?” http:\/\/www.joelonsoftware.com\/items\/2006\/08\/01.html In this article, he drives home the point that when it comes to code: Maintainability, Readability, Abstraction == Good!  He then points out how languages can help or hinder this and goes on to articulate the things a language […]<\/p>\n","protected":false},"author":600,"featured_media":13641,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[10,33],"class_list":["post-9851","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-powershell","tag-faq","tag-language"],"acf":[],"blog_post_summary":"

    Joel Spolsky of Joel-On-Software fame, just posted a blog, “Can Your Programming Language Do This?” http:\/\/www.joelonsoftware.com\/items\/2006\/08\/01.html In this article, he drives home the point that when it comes to code: Maintainability, Readability, Abstraction == Good!  He then points out how languages can help or hinder this and goes on to articulate the things a language […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/9851","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/users\/600"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/comments?post=9851"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/9851\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media\/13641"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media?parent=9851"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/categories?post=9851"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/tags?post=9851"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}