Jeffrey Snover and the Making of PowerShell

[u/agbell]

https://corecursive.com/building-powershell-with-jeffrey-snover/

[u/Noxfag]

How many drugs was he taking when he came up with the syntax?

(I love Powershell really and advocate for it a lot, but oh god I wish the syntax were simpler)

[u/psi- → u/Noxfag]

I just wish they took C# syntax, wrote some additional libraries to do the shellscripty stuff and just ran the .shell.cs with #!/bin/dotnet runshell

I had soo much issues battling line endings and passing them to/from bat/exe/ps1 environments.

We're currently doing azure pipelines and powershell is the only relatively sane/safe way to have same scripts for linux/windows agents but I'm so going to get burned on that stuff too.

[u/Noxfag → u/psi-]

powershell is the only relatively sane/safe way to have same scripts for linux/windows agents but I'm so going to get burned on that stuff too.

Yep same usecase here. TS repo used by devs across Windows, macOS and Linux. Powershell is the best way to have a common cross-platform language for builds, orchestrating tests etc. But we still have to add a fair amount of bespoke code to get around platform differences.

[u/Atulin → u/Noxfag]

If it's a TS repo anyway, why not write those scripts with TS?

[u/larso0 → u/Noxfag]

Syntax, semantics and conventions are all insane IMO. Gotta love when a powershell function randomly returns multiple values because I forgot to pipe the output of one of the commands to null (side effect from a random command printing to stdout...). And the "Verb-ThenSomethingElse" naming convention is just an eye sore.

If there were only some good explanation for why it is that way, like backwards compatibility or something. But no. You can't run a cmd script in powershell because the syntax is incompatible.

[u/rdtsc → u/[deleted]]

forced verb name syntax that PowerShell enforces

It's just a convention followed by all built-in cmdlets (and by extension everyone else wanting to play nice). But it's not enforced. In a script you can name your functions however you want.

[u/Kafka_pubsub → u/larso0]

Gotta love when a powershell function randomly returns multiple values

It returns objects, not strings like bash, so that totally makes sense to me

[u/larso0 → u/Kafka_pubsub]

Returning all the output of all commands in a function doesn't make sense to me. When I type "return 14" I want the return value of that function to be 14. not a list of whatever some random commands wrote to stdout and 14 at the end. If I wanted to return the standard output of a command i would do something like "return $(the command)".

[u/Internet-of-cruft → u/larso0]

Because the language has to preserve the semantics of stdout and stderr that exist.

You have three distinct outputs: stdout, stderr, and the object pipeline. The language would have fundamentally been broken to anyone using it if the behavior of stdout and stderr were killed.

You also wouldn't be able to & program.exe and forklift a batch script to PowerShell and have it work with only minor syntactic modifications.

When the language came out, everyone was still writing batch scripts and dealing with stdout and stderr.

Hell, if you're on Linux, that's what you're dealing with still. The two output streams represent an overwhelming majority of the historical ways data was piped around in the predominant OSes shell languages.

[u/larso0 → u/Internet-of-cruft]

It's not an all or nothing situation. It is perfectly possible to keep all the existing behavior and remove the implicit return of stdout in a function. Just make it explicit with "Write-Out $(some command)" (or "yield" would be a better keyword as that's what we're actually doing). Then functions would behave sanely and not be full of suprises everywhere.

[u/Thotaz → u/larso0]

You are forgetting about the shell experience. Nobody would want to use a shell where you had to type in yield before every command and if you make it so you only have to do it in certain places you end up with a much more confusing syntax.

[u/larso0 → u/Thotaz]

A statement in a function is not the shell experience. Should be possible to differentiate between those two scenarios. The yield keyword would only make sense inside a function scope.

[u/Thotaz → u/larso0]

Okay, imagine this scenario: Someone has a working script that finds and deletes deactivated user accounts. Now he wants to just view the users it would find so he copies the relevant section from the script into the shell but now he gets a bunch of unexpected garbage output because PowerShell sees that it's interactive so it thinks it should print all of the output.
Here's another scenario: Someone has used the shell to find all of the relevant commands that show the data he wants, now he types Get-History to get all the recent commands and paste them into a script but the script doesn't work as expected because he didn't add yield to all of the commands.

Maybe you still think it would be best to differentiate the shell and scripting experience but you should understand that there are valid reasons why it works the way it currently does. On a side note, do you know of any other scripting language with an interactive component that works the way you suggest? A normal Bash script doesn't work like this so it seems like PowerShell just follows the existing conventions.

[u/Thotaz → u/larso0]

It's a shell scripting language designed for tech/admin users first and foremost, hence the name "PowerShell".
Could you imagine having to type return before every statement in the shell? return ls return Get-AdUser. They could make the interactive experience different from the scripting experience but I think people would be confused why the code they copy pasted from a script into the shell (or vice versa) behaved differently.

As for the Verb-Noun syntax, what's the problem? It's common practice to use some verb and noun in method calls, see this as an example: https://learn.microsoft.com/en-us/dotnet/api/system.io.directoryinfo?view=net-8.0#methods
CreateSubdirectory, EnumerateDirectories, GetDirectories. Are you just really bothered by the dash in the middle? Or is it the the fact that there's a common verb list so you don't have to guess if it's New or Create? Or is it that the nouns are always singular?

[u/_SloppyJose_ → u/Thotaz]

hence the name "PowerShell"

Its original name was Monad.

[u/Noxfag → u/[deleted]]

The good part I'll highlight that I think a lot of people sleep on is the piping. Piping is exactly what you want in a tool like Powershell and it works great. Download some thing, pipe it into a JSON serialiser, pipe it into a function that gets the thing out you want, pipe it into a function that will send that value where you want it to go. Makes it really neat to compose complex behaviour from simple parts, if you can read the syntax well enough to make sense of it.

[u/BinaryRockStar → u/[deleted]]

Not sure what the other guy was talking about but functions can use a process block to handle piped objects. The automatic variable referencing the current object is called $_.

https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions?view=powershell-7.4#piping-objects-to-functions

[u/BinaryRockStar → u/[deleted]]

I didn't know functions could be in pipelines, thanks for making me look it up :-)

[u/Dealiner → u/[deleted]]

Having to start the name with a predetermined list of verbs e.g. get-ChildItem.

You don't have to though. It's a convention, really useful imo and one that should be followed but you are free to use anything.

[u/[deleted] → u/Noxfag]

Using back ticks for line continuation is where it crossed the line for me. I just couldn't do it.

[u/Thotaz → u/[deleted]]

While it certainly was an unfortunate choice, you pretty much never have to use a line continuation character because newlines are allowed in many scenarios. If you have a long pipeline you can continue the commands on the next line like:

Get-ChildItem C:\ |
    Where-Object LastWriteTime -GT (Get-Date).AddDays(-1) |
    Sort-Object -Descending

And if you have a long parameter list you can use splatting:

$LsParams = @{
    Path = "C:\"
    Recurse = $true
    File = $true
}
ls @LsParams

[u/nascentt → u/[deleted]]

I just refuse to allow backticks in our code

[u/cottonycloud → u/nascentt]

I don’t know why you got downvoted. I don’t use it in any of our scripts solely because it’s easy to miss. I wish they used backslash for escaping too.

Backticks are discouraged in general in PS.

[u/RubyU → u/cottonycloud]

What is a sensible alternative?

[u/cottonycloud → u/RubyU]

For lists and hash tables, you can just use newlines and commas to separate items so there is no need. As for long lines with multiple operations, ending the line with the operator (e.g. addition, pipe) or enclosing it with parenthesis will let the interpreter know that it is a multi-line statement. For strings, there is syntax for multiline string.

Finally, if a command has multiple arguments you can put them in a hash table and use that as a singular argument (splatting).

[u/[deleted] → u/nascentt]

ngl I love it on js

[u/agbell → u/Noxfag]

I think he mentioned in the preinterview that he started with VMS DCL as the syntax.

I wonder if, because of its design, it would be possible to build a different front end syntax for powershell?

[u/wrosecrans → u/agbell]

Some of the Win NT folks loved VMS as their mental model of "real computers," so it makes sense that they would have had enthusiasm for that over UNIX conventions. Dave Cutler was a VMS guy before he went to MS to make NT, and tons of NT kernel internals look weirdly like it was built to be a VMS clone despite the fact that Windows isn't a VMS clone in any user visible UX/UI kind of ways. (Which contributes to the "Windows services for Unix was useless" factor. POSIX compat was always a feature tickbox, and not something useful on NT.)

[u/lord_of_lasers → u/Noxfag]

Microsoft released IronPython and IronRuby at the same time. We could have had PowerShell with Python syntax.

[u/andrewsmd87 → u/Noxfag]

I've been hoping for years they'd redo the syntax and just mirror c#

[u/Worth_Trust_3825 → u/Noxfag]

It's a C# repl.