powershell.one

Setting Registry Values (Smart)

2020-06-02T00:00:00+00:00

While preparing for our second day of our virtual psconf.eu mini conference, my computer suddenly started to respond sluggishly, and when I investigated, I found that my Chrome browser was causing excessive CPU loads. Specifically, a softwarereporter tool caused the issue.

Join us for more PowerShell deep dive in todays free virtual panel: see powershell.love for the details. If you missed it, go to powershell.video for the recordings.

Turned out that’s a tool Google uses to regularly scan the computer for unwanted software that may negatively affect Chromes performance. Only that this tool degraded the performance of my entire machine.

This post is not about shutting down softwarereporter which was trivial by setting a bunch of registry values. It is about setting a bunch of registry values itself.

Setting Many Registry Values At Once

You can use Set-ItemProperty to set individual registry keys:

# setting a dummy registry value (key must exist)
Set-ItemProperty -Path 'HKCU:\Software' -Name Hello -Value 'I was here!' -Type String

The parameter -Type is not undocumented as is often claimed. It is a dynamic parameter that shows only when the value you submitted to -Path makes it necessary. That’s why -Type often is missing from IntelliSense: if you are submitting a variable to -Path, then the parser can’t figure out whether -Type should be added.

Yet when you need to set more than one, your script code starts to look ugly. So why not set them all with just one call to Set-ItemProperty?

Pipeline To The Rescue

Unfortunately, the cmdlet does not accept arrays so you can’t submit more than one registry value name.

But all three parameters accept pipeline data by property name, so when you pipe objects into Set-ItemProperty that have the properties Name, Value, and Type, you can create as many registry values as you like with just one call.

Creating these input objects is simple. Here are the three values I need to turn off Chromes software reporting tool:

'Name,Value,Type
ChromeCleanupEnabled,0,DWORD
ChromeCleanupReportingEnabled,0,DWORD
MetricsReportingEnabled,0,DWORD' | ConvertFrom-Csv

The result are three objects with the required properties:

Name                          Value Type 
----                          ----- ---- 
ChromeCleanupEnabled          0     DWORD
ChromeCleanupReportingEnabled 0     DWORD
MetricsReportingEnabled       0     DWORD

Pipeline Binding Conflict

Unfortunately, you can’t pipe these objects to Set-ItemProperty even though the parameters accept binding by property name: here is my first attempt, and it emits tons of exceptions and creates weird values:

#requires -RunAsAdmin
# make sure you run this with ADMIN privileges because it writes to HKLM

# CODE BELOW FAILS! READ ON FOR THE SOLUTION...
# https://powershell.one/code/13.html

# this is where the Chrome policies are located:
$key = 'HKLM:\SOFTWARE\Policies\Google\Chrome'

# make sure the key exists:
$exists = Test-Path -Path $key
if (!$exists) { $null = New-Item -Path $key -Force }

# write the registry values:
'Name,Value,Type
ChromeCleanupEnabled,0,DWORD
ChromeCleanupReportingEnabled,0,DWORD
MetricsReportingEnabled,0,DWORD' | 
  ConvertFrom-Csv | 
  Set-ItemProperty -Path $key

The key was created, but inside I found a value called “Value”, and PowerShell complained that Set-ItemProperty was unable to convert the piped input data into the proper data types.

The reason for this was a pipeline binding conflict:

Set-ItemProperty has a parameter -InputObject that accepts any object by value.
So my own custom objects were not bound to the parameters -Name, -Value, and -Type, and instead PowerShell assigned them as object to -InputObject.

Which left me confused: why would a cmdlet have parameters that accept pipeline data by property name when at the same time another parameter would always grab all pipeline input and bind it to itself?

Do it right: Setting Multiple Registry Values

In conflicts like the one above, there is a simple trick how you can force PowerShell to bind to a parameter by property name, so this is the working example that sets the Chrome policy keys, prevents the software reporter tool and high CPU loads, and is an excellent template for whenever you need to set multiple registry values:

#requires -RunAsAdmin
# make sure you run this with ADMIN privileges because it writes to HKLM

# this is where the Chrome policies are located:
$key = 'HKLM:\SOFTWARE\Policies\Google\Chrome'

# make sure the key exists:
$exists = Test-Path -Path $key
if (!$exists) { $null = New-Item -Path $key -Force }

# write the registry values:
'Name,Value,Type
ChromeCleanupEnabled,0,DWORD
ChromeCleanupReportingEnabled,0,DWORD
MetricsReportingEnabled,0,DWORD' | 
  ConvertFrom-Csv | 
  Set-ItemProperty -Path $key -Name { $_.Name } 

Note how I just added this: -Name { $_.Name }.

Whenever a parameter accepts pipeline data by property name, it also automatically accepts a scriptblock, and $_ inside of this scriptblock represents the incoming pipeline object.

This technique was originally designed to let you quickly do adjustments to piped data. For example, if you pipe an excel sheet into a cmdlet that requires a securestring password, you could do something like this:

# illustrates how a parameter can receive a plain text pipeline input
# via binding by property name, and YOU get still a chance to convert it
# to something else i.e. a secure string before the actual binding
# takes place:
-Password { $_.Password | ConvertTo-SecureString -AsPlainText -Force }

In my case, by explicitly using the parameter -Name, I made sure PowerShell knew which parameterset I wanted to use, and happily bound the input object to the remaining parameters -Value and -Type. Amazing stuff.

Auto-Learning Auto-Completion

2020-06-02T00:00:00+00:00

Autocompletion is awesome and makes using PowerShell so much easier. Typically, though, the autocompletion data is provided by the engine or your function. That’s why autocompletion is available predominantly for technical things such as paths, types, or prefixed lists and enumerations.

They are typically not able to adapt to the needs of users, i.e. suggest computer names in use in your infrastructure. And you as a PowerShell author can’t help this because you don’t know the suggestions that would be useful for a user of your function.

Let’s change that.

Add Auto-Learning Auto-Completion

With the magic of transformation attributes, you can effortlessly add auto-learning auto-completion to the parameters of your functions that a user trains.

Run this to see for yourself:

For the most part, this script is defining the new attributes that you can later reuse throughout your functions. So when you collapse the region at the beginning, you’ll see that there is just very little code to digest.

#region adding the new attributes
class AutoLearnAttribute : System.Management.Automation.ArgumentTransformationAttribute
{
    # define path to store hint lists
    [string]$Path = "$env:temp\hints"

    # define id to manage multiple hint lists:
    [string]$Id = 'default'

    # define prefix character used to delete the hint list
    [char]$ClearKey = '!'

    # define parameterless constructor:
    AutoLearnAttribute() : base()
    {}

    # define constructor with parameter for id:
    AutoLearnAttribute([string]$Id) : base()
    {
        $this.Id = $Id
    }
    
    # Transform() is called whenever there is a variable or parameter assignment, and returns the value
    # that is actually assigned:
    [object] Transform([System.Management.Automation.EngineIntrinsics]$engineIntrinsics, [object] $inputData)
    {
        # make sure the folder with hints exists
        $exists = Test-Path -Path $this.Path
        if (!$exists) { $null = New-Item -Path $this.Path -ItemType Directory }

        # create filename for hint list
        $filename = '{0}.hint' -f $this.Id
        $hintPath = Join-Path -Path $this.Path -ChildPath $filename
        
        # use a hashtable to keep hint list
        $hints = @{}

        # read hint list if it exists
        $exists = Test-Path -Path $hintPath
        if ($exists) 
        {
            Get-Content -Path $hintPath -Encoding Default |
              # remove leading and trailing blanks
              ForEach-Object { $_.Trim() } |
              # remove empty lines
              Where-Object { ![string]::IsNullOrEmpty($_) } |
              # add to hashtable
              ForEach-Object {
                # value is not used, set it to $true:
                $hints[$_] = $true
              }
        }

        # does the user input start with the clearing key?
        if ($inputData.StartsWith($this.ClearKey))
        {
            # remove the prefix:
            $inputData = $inputData.SubString(1)

            # clear the hint list:
            $hints.Clear()
        }

        # add new value to hint list
        if(![string]::IsNullOrWhiteSpace($inputData))
        {
            $hints[$inputData] = $true
        }
        # save hints list
        $hints.Keys | Sort-Object | Set-Content -Path $hintPath -Encoding Default 
        
        # return the user input (if there was a clearing key at its start,
        # it is now stripped):
        return $inputData
    }
}

class AutoCompleteAttribute : System.Management.Automation.ArgumentCompleterAttribute
{
    # define path to store hint lists
    [string]$Path = "$env:temp\hints"

    # define id to manage multiple hint lists:
    [string]$Id = 'default'
  
    # define parameterless constructor:
    AutoCompleteAttribute() : base([AutoCompleteAttribute]::_createScriptBlock($this)) 
    {}

    # define constructor with parameter for id:
    AutoCompleteAttribute([string]$Id) : base([AutoCompleteAttribute]::_createScriptBlock($this))
    {
        $this.Id = $Id
    }

    # create a static helper method that creates the scriptblock that the base constructor needs
    # this is necessary to be able to access the argument(s) submitted to the constructor
    # the method needs a reference to the object instance to (later) access its optional parameters:
    hidden static [ScriptBlock] _createScriptBlock([AutoCompleteAttribute] $instance)
    {
    $scriptblock = {
        # receive information about current state:
        param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
   
        # create filename for hint list
        $filename = '{0}.hint' -f $instance.Id
        $hintPath = Join-Path -Path $instance.Path -ChildPath $filename
        
        # use a hashtable to keep hint list
        $hints = @{}

        # read hint list if it exists
        $exists = Test-Path -Path $hintPath
        if ($exists) 
        {
            Get-Content -Path $hintPath -Encoding Default |
              # remove leading and trailing blanks
              ForEach-Object { $_.Trim() } |
              # remove empty lines
              Where-Object { ![string]::IsNullOrEmpty($_) } |
              # filter completion items based on existing text:
              Where-Object { $_.LogName -like "$wordToComplete*" } | 
              # create argument completion results
              Foreach-Object { 
                  [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
              }
        }
    }.GetNewClosure()
    return $scriptblock
    }
}
#endregion

#region CacheCredential
# attribute [CacheCredential()] transforms strings to creds and caches values:
class CacheCredentialAttribute : System.Management.Automation.ArgumentTransformationAttribute
{
    [string]$Path = "$env:temp\hints"
    [string]$Id = 'default'
    [char]$ClearKey = '!'

    CacheCredentialAttribute() : base()
    {}

    CacheCredentialAttribute([string]$Id) : base()
    {
        $this.Id = $Id
    }
    
    [object] Transform([System.Management.Automation.EngineIntrinsics]$engineIntrinsics, [object] $inputData)
    {
        # make sure the folder with hints exists
        $exists = Test-Path -Path $this.Path
        if (!$exists) { $null = New-Item -Path $this.Path -ItemType Directory }

        # create filename for hint list
        $filename = '{0}.xmlhint' -f $this.Id
        $hintPath = Join-Path -Path $this.Path -ChildPath $filename
        
        # use a hashtable to keep hint list
        $hints = @{}

        # read hint list if it exists
        $exists = Test-Path -Path $hintPath
        if ($exists) 
        {
            # hint list is xml data
            # it is a serialized hashtable and can be 
            # deserialized via Import-CliXml if it exists
            # result is a hashtable:
            [System.Collections.Hashtable]$hints = Import-Clixml -Path $hintPath
        }

        # if the argument is a string...
        if ($inputData -is [string])
        {
            # does username start with "!"?
            [bool]$promptAlways = $inputData.StartsWith($this.ClearKey)

            # if not,...
            if (!$promptAlways)
            {
                # ...check to see if the username has been used before,
                # and re-use its credential (no need to enter password again)
                if ($hints.ContainsKey($inputData))
                {
                    return $hints[$inputData]
                }
            }
            else
            {
                # ...else, remove the "!" at the beginning and prompt
                # again for the password (this way, passwords can be updated)
                $inputData = $inputData.SubString(1)
                # delete the cached credentials
                $hints.Clear()
            }
            # ask for a credential:
            $cred = $engineIntrinsics.Host.UI.PromptForCredential("Enter password", "Please enter user account and password", $inputData, "")
            # add the credential to the hashtable:
            $hints[$cred.UserName] = $cred
            # update the hashtable and write it to file
            # passwords are automatically safely encrypted:
            $hints | Export-Clixml -Path $hintPath
            # return the credential:
            return $cred
        }
        # if a credential was submitted...
        elseif ($inputData -is [PSCredential])
        {
            # save it to the hashtable:
            $hints[$inputData.UserName] = $inputData
            # update the hashtable and write it to file:
            $hints | Export-Clixml -Path $hintPath
            # return the credential:
            return $inputData
        }
        throw [System.InvalidOperationException]::new('Unexpected error.')
    }
}


# attribute [SuggestCredential()] suggests cached credentials
class SuggestCredentialAttribute : System.Management.Automation.ArgumentCompleterAttribute
{
    [string]$Path = "$env:temp\hints"
    [string]$Id = 'default'
  
    SuggestCredentialAttribute() : base([SuggestCredentialAttribute]::_createScriptBlock($this)) 
    {}

    SuggestCredentialAttribute([string]$Id) : base([SuggestCredentialAttribute]::_createScriptBlock($this))
    {
        $this.Id = $Id
    }

    hidden static [ScriptBlock] _createScriptBlock([SuggestCredentialAttribute] $instance)
    {
    $scriptblock = {
        param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
   
        $filename = '{0}.xmlhint' -f $instance.Id
        $hintPath = Join-Path -Path $instance.Path -ChildPath $filename
        
        $exists = Test-Path -Path $hintPath
        if ($exists) 
        {
            # read serialized hint hashtable if it exists...
            [System.Collections.Hashtable]$hints = Import-Clixml -Path $hintPath

            # hint the sorted list of cached user names...
            $hints.Keys |
              Where-Object { $_ } |
              # ...that still match the current user input:
              Where-Object { $_.LogName -like "$wordToComplete*" } | 
              Sort-Object |
              # return completion results:
              Foreach-Object { 
                  [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
              }
        }
    }.GetNewClosure()
    return $scriptblock
    }
}


# function uses a parameter -Credential that accepts both
# strings (username) and credentials. If the user submits a
# string, a cached credential is returned if available.
# only if there is no cached credential yet, the user gets
# prompted for a password, and the string is transformed
# into a credential.
# when the user prefixes a username with "!", all cached
# credentials are deleted´.
#endregion

# see: https://powershell.one/powershell-internals/attributes/custom-attributes
function Connect-MyServer
{
    param
    (
        [string]
        [Parameter(Mandatory)]
        [AutoLearn('server')][AutoComplete('server')]
        $ComputerName,

        [PSCredential]
        [CacheCredential('account')][SuggestCredential('account')]
        $Credential
    )

    # expose password:
    if ($Credential) {
      $password = $Credential.GetNetworkCredential().Password
      $username = $Credential.UserName
    }

    "hello $Username, connecting you to $ComputerName using password $password."
}

The code important for you is just this part:

# make sure you ran the code above to define the new attributes!

function Connect-MyServer
{
    param
    (
        [string]
        [Parameter(Mandatory)]
        [AutoLearn('server')][AutoComplete('server')]
        $ComputerName,

        [PSCredential]
        [CacheCredential('account')][SuggestCredential('account')]
        $Credential
    )

    # expose password:
    if ($Credential) {
      $password = $Credential.GetNetworkCredential().Password
      $username = $Credential.UserName
    }

    "hello $Username, connecting you to $ComputerName using password $password."
}

Once you run the code, you have one function Connect-MyServer which has two parameters: -ComputerName and -Credential.

Run Connect-MyServera couple of times, and you’ll notice that autocompletion learns from you.

It will suggest computer names and credentials that you entered previously. So this is a perfect user-centric scenario where you and your functions just provide the ability for the user to teach the computer names and credentials to your function over time.

Due to a bug in all PowerShell versions, autocompletion will generally never work inside the very same editor pane where you defined the attributes. It works like a charm in any other editor window, and of course in the interactive PowerShell console.

The cache is persistent and works across restarts. Credentials are stored encrypted. To clear the cache list, prepend the argument with “!”.

How this works

There is just a minor change to the param() block to enable this for any PowerShell function or script:

param
    (
        [string]
        [Parameter(Mandatory)]
        [AutoLearn('server')][AutoComplete('server')]
        $ComputerName,

        [PSCredential]
        [CacheCredential('account')][SuggestCredential('account')]
        $Credential
    )

For string-based parameters, use the new attributes [AutoLearn()] and [AutoComplete()], and submit a keyword. The keyword basically defines the cache list, and if you want parameters to share the same cache list, use the same keyword.

For credential-based parameters, use the new attributes [CacheCredential()] and [SuggestCredential()], and again submit a keyword. Like before, you should use the same keyword for the same credential cache list.

Wish List for the PowerShell Team

I believe this approach is so useful and adds so much advantage to the usability of any PowerShell function or script that my hope is that these attributes might be added to PowerShell natively at one time.

Currently, because of how the PowerShell engine works, there is the requirement for two attributes, one dealing with autocompletion and another dealing with caching. That is something only the PowerShell engine can fix and consolidate into one simple attribute.

Another challenge currently is that PowerShell modules do not support classes, so you cannot add the attribute definitions to modules. That, too, would be overcome when PowerShell shipped these attributes out of the box. Let’s keep fingers crossed!

PowerShell IoT (and GUIs, too)

2020-06-02T00:00:00+00:00

This is our all-purpose section where we combine topics like IoT, the brand-new notebooks (see below if you think I am talking about laptops), and GUI creation.

Only, there are no GUI sessions available. Originally, we planned to have them as well, illustrating how you can create user interfaces from PowerShell. Even though PowerShells intention originally was to do away with user interfaces and automate, it became so successful that it today is a valid rapid development architecture for small tools and software, so GUI creation always has caught a lot of attention. Due to Corona, we were unable to record all sessions, and so some sessions from Adam Driscoll about his awesom Digital Dashboard are missing.

Nevertheless, we will include GUI into our live panel, and if you have questions about IoT or GUI, please meet us:

We cordially invite you to participate in our live Q&A targeting PowerShell IoT, Notebooks, GUI. It is taking place June 3, 2020 at 8pm CEST, and you’ll have a chance to meet the speakers, other security experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

PowerShell IoT v2 - What’s new, what changed and what I’ve learned

by Daniel Silva

PowerShell.IoT is a free, Open Source module that allows you to interact with IoT hardware.

Since I’ve become a maintainer of this repo, I’ve been working to migrate the code to use System.Devices from the dotnet team.

In this session, I will share with you what has changed, what’s new, and what I’ve learned since I’ve started to contribute to Open Source software, and also why you should too!

PowerShell on Raspberry PI - Making a connected greenhouse

by Jakob Gottlieb from the PowerShell team

After the success at Ignite 2019, on popular demand, here comes the deep dive on how to run and use PowerShell on Raspberry PI.

Join me as I tell the story about how I connected my backyard greenhouse to azure. Besides metrics, this includes automated watering and much more.

We will dive into configuring and running PowerShell on Raspberry PI, for newcomers, but also including more advanced tips and tricks for the experienced PoshPI’er.

You will learn how Azure is a great platform for IoT projects like this. We’ll be touching multiple services such as Log Analytics and Azure Functions combined with simple code in PowerShell.

And What about Docker?! who would use that in their 4m2 greenhouse?! Me!, I mean, Who wants to configure IoT Devices by hand?!

PowerShell in Notebooks

by Rob Sewell

Jupyter Notebooks are best known as tools for Data Scientists to display Python, Spark or R scripts.

Azure Data Studio is a data professional tool based on Visual Studio Code. Azure Data Studio includes PowerShell Notebooks in addition to SQL notebooks.

A notebook enables you to share words, images, code AND code results and will be extremely useful in many scenarios. I am already using it with clients for Incident Resolution Repeatable tasks Demoing new features.

In this session, we will examine PowerShell Notebooks and show you how useful they could be for you in your daily work-life

Notebooks + VS Code

by Sydney Smith

Visual Studio Code has been called the recommended editor for PowerShell 7.

Learn how to get started with VSCode using features like “ISE mode”, and then how to build your skill set to take advantage of Visual Studio Code’s rich feature set.

Jupyter notebooks allow you combine rich text elements with executable code. Learn how to get started building, and sharing PowerShell notebooks to take your documentation, and support to the next level!

VSCode and Jupyter notebooks are two tools that the PowerShell team has recently been investing in. Learn why we these tools are so valuable and, how to get started developing with them.

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

Pester and ScriptAnalyzer

2020-06-02T00:00:00+00:00

We are proud to present to you this years’ psconf.eu sessions related to Pester and PowerShell ScriptAnalyzer. And of course we are happy to see that Pester-inventor Jakub is delivering a talk - there can’t be a more authoritative coverage, and you can ask him all your questions in our live panel.

We invite you to participate in our live Q&A targeting Pester and ScriptAnalyzer. It is taking place June 2, 2020 at 8pm CEST, and you’ll have a chance to meet the speakers, other PowerShell experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

Building PowerShell, its VS-Code extension and debugging it

by Christoph Bergmeister

We all use PowerShell, it’s VS-Code extension or PSScriptAnalyzer in some way or another. Sometimes we’d like to either add a feature or have a customized version of it for some reason or need to debug a bug in those tools.

I will show how to build and debug those tools. Furthermore I will show features that I have made in various areas to the tools in the past and demo some small examples.

What’s new in Pester v5?

by Jakub Jareš from Finnland

Pester 5 brings multiple new features, many fixes and also some significant breaking changes.

In this talk I will demo the most significant improvements to the framework, point out differences from version 4 and give a quick guide to migrating to the new framework version.

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

PowerShell 7

2020-06-02T00:00:00+00:00

We are proud to present to you this years’ psconf.eu sessions related to PowerShell 7, future paths, guidance to PowerShell, and anything related. For other topics, please see the other pages on powershell.one.

We also invite you to participate in our live Q&A targeting these topics. It is taking place June 3, 2020 at 5pm CEST, and you’ll have a chance to meet the speakers, other security experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

PowerShell 7.1: A Next Gen Shell

by Steve Lee & Jason Helmick from the PowerShell team.

Modern shells should help you be successful as soon as you start typing. Tab completion and IntelliSense are just the beginning.

In this session, Steve Lee and Jason Helmick discuss some of the new shell improvements in 7.0 and the exciting plans we have in store for making 7.1 the most productive shell ever!

Join us to discuss the future of the shell.

PowerShellGet 3.0

by Sydney Smith from the PowerShell team.

The PowerShell team has done a complete re-architecture of the PowerShellGet module.

We will explain what changes this will mean for your user experience, and demo some of the latest features.

The Seven Deadly Sins of PowerShell

by Friedrich Weinmann

Father forgive me, for I have sinned. Life is a sinful thing, and we all commit the odd bad deed in our lives.

But there are a few unforgivable sins out there. Foul deeds that no penance can excuse. You know what I am talking about: The Seven Deadly Sins … of PowerShell!

Introducing the greatest sins you can commit in PowerShell, WHY they are bad, why people commit them and good ways to meet the same ends without loading up immense technical debt.

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

PowerShell Deep Shit

2020-06-02T00:00:00+00:00

psconf.eu originally is a place for PowerShell experts and professionals to come together and brainstorm about new things, edge cases, secrets, and un(der)documented features - so no wonder we have rich content in this discipline!

What’s even better: you can meet all the speakers and experts live in our Q&A to ask all the long standing questions you never really found good answers for.

If you’d like to look at different topics and maybe are more interested in security or basic questions, please see the other videos and pages on powershell.one.

We cordially invite you to participate in our live Q&A targeting PowerShell deep shit topics. It is taking place June 3, 2020 at 7pm CEST, and you’ll have a chance to meet the speakers, other security experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

Querying Wikidata with a glimpse of SPARQL

by Thorsten Butz

Wikidata represents the underlying basement of Wikipedia, it’s the collaboratively edited knowledge base filling up Wikipedia with data.

Querying Wikidata enables you to gain access to to a universe of information, just in case you know how to answer the right questions.

This session provides an insight to wikidata/wikimedia queries by SPARQL, the semantic query language from W3C.

Module System Deep-Dive

by Rob Holt from the PowerShell team

The PowerShell module system, whereby commands are portioned into convenient collections of functionality, is a twisted beast that has to make functionality separable but still convenient and accessible from the command line (a problem that module systems in other languages don’t have).

In this talk, we take a deep look at what actually happens when you run cmdlets like Import-Module and Get-Module, how commands are resolved from modules, how module manifests work compared to Export-ModuleMember, and some of the quirks and edge cases that occur because of the complexities of modules in PowerShell.

Classes & runspaces together - Async logging in PowerShell

by Jan-Henrik Damaschke

After you watched this session you will have an understanding of multithreading, especially with runspaces in PowerShell.

You will also have knowledge about how to abstract complex constructs with classes in PowerShell.

Did you ever had some issues with multithreading in PowerShell? In this session you will see a practical example for when multithreading in PowerShell really makes sense.

We will take a look at how to implement asynchronous logging and how to abstract a reusable class with PowerShell classes.

I Compare: PowerShell Edition

by Mathias R. Jessen

This session will focus on sorting and comparison of collections in PowerShell, specifically how to implement IComparer and IComparable types using PowerShell classes and how to leverage these with appropriate sorted built-in generic collection types.

To get everyone up to speed, in the first half we’ll cover:

Introduction to .NET generics and reusable types
Ordering 101: Ordered vs Sorted vs Grouped - PowerShell classes and inheritance
Then dive into: - Custom ordering using Sort-Object
IComparable - type-intrinsic sorting
IComparer - custom sorting
Sorted Collections (SortedList, SortedDictionary, SortedSet)

Become a parameter ninja

by James O’Neill

PowerShell parameters. Easy, right ? We write them most days without even thinking.

But the functions we create could be better to use, with code which is clearer and shorter – in other words easier -if we got their parameters absolutely right.

This session will start with tips for recognizing and improving parameters which ask their questions in the wrong way, or which don’t take the input that users want to supply.

This leads into when to declare parameter types and when not to and good and bad use of validation attributes. It will look at parameters sets, and when dynamic parameters are a good idea (and when they should be avoided).

It will cover the importance of argument completers, and different ways to write them which leads into the Ninja skills needed to create custom parameter attributes for tab-completing, transforming and validating values.

Don’t be scared of calling APIs!

by Graziella Iezzi

Everyone has heard the word API, but what are they? What are they used for in web applications? How can they make your life easier on a daily basis?

What can you actually automate? What limitations you can face, even using enterprise applications?

This talk will give you an answer to those questions based on my experience working with third-party web applications like Jira, Trello, BlueJeans, Slack, Workplace.

I’ll show you a few examples of scripts I developed in PowerShell to automate how to grant user permissions, how I worked around when certain information was not exposed, how it was hard to me to set up my first header and body to Invoke-RestMethod, how I used PSCustomObject to validate data and return results, and to send a report by email, how to handle the different types of pagination.

Just git it!

by Bartek Bielawski

You simply don’t git it! People will tell you why you should git, when you should git it, but how…?

Join me for fun ride where I will git you from zero to… git enough!

I won’t shy away from answering “why” and “when” question, but will git past that and see just how good git can get. Tools, modules and tips included!

Building a Custom PowerShell Host

by Adam Driscoll

This session will dive into building a custom PowerShell host.

It will show you how to do things like process input, output progress, write to the screen and accept input for non-PowerShell command-line tools.

Beyond lab: Scripting at Scale

by Evgenij Smirnov

This is a compressed version of the two-part real-world data gathering workshop.

We will look at some epic failures of scripts that look OK and work well in a small environment, then explore some routes of action to deal with huge amounts of data coming in from real-world scale sources like Active Directory, SQL or log stash.

PowerShell Scoping for Mere Mortals

by Anthony Allen

In this session we will have a look from the ground up at how scoping in PowerShell works.

We’ll start off from the basics of the differences between dynamic and lexical scoping, working our way through modifying variables in different scopes and digging into what session state is and how we can use it to modify variables and even function definitions in runspaces.

We will also look at the mechanisms of how PowerShell implements scoping behind the scenes to get a solid understanding of the principles shown.

This is the session for you who is a visual learner, there will be plenty of visualizations as well as lots of code examples, and dives into the PowerShell source code to demonstrate what we have learnt.

Going native: A non-developer’s tale

by Evgenij Smirnov

The integrative power of PowerShell wouldn’t be what it has become if it weren’t for its ability to incorporate native APIs.

Not all of them, however, have been designed in a way that makes immersion of native functionality into your PowerShell scripts and modules easy.

Not a developer myself, I invite fellow non-devs to join me on a journey towards successful integration of select Windows APIs into PowerShell - including obstacles I met along the way and recipes on how to overcome those.

After this talk, you will be more prepared to extend your PowerShell-fu towards native platform functionality and hopefully forewarned about some pitfalls to avoid and appropriate moments to give up and look for other ways.

After this talk, you will be more prepared to extend your PowerShell-future towards native platform functionality and hopefully forewarned about some pitfalls to avoid and appropriate moments to give up and look for other ways.

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

Security

2020-06-02T00:00:00+00:00

We are proud to present to you this years’ psconf.eu sessions related to PowerShell Security. For other topics, please see the other pages on powershell.one.

We also invite you to participate in our live Q&A targeting security topics. It is taking place June 2, 2020 at 7pm CEST, and you’ll have a chance to meet the speakers, other security experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

Managing Secrets from your dev box to the cloud

by Sydney Smith from the PowerShell team.

Advanced scripts that touch many systems require multiple secrets and types of secrets particularly when orchestrating across heterogeneous clouds.

The best practice is to not hard code any secrets in scripts, but currently this requires custom code on different platforms to handle securely.

Learn how the new secrets management model will allow you to securely use secrets to automate, manage and develop. Find out how to enhance your local and remote development experience with PowerShell secrets management.

Abusing Azure Active Directory: Who would you like to be today?

by Dr. Nestori Syynimaa

Azure AD is used by Microsoft Office 365 and over 2900 third-party apps. Although Azure AD is commonly regarded as secure, there are serious vulnerabilities regarding identity federation, pass-through authentication, and seamless single-sign-on.

In this session, using my AADInternals PowerShell module, the exploitation of these vulnerabilities to create backdoors, impersonate users, and bypass MFA are demonstrated. The purpose of this session is to rise awareness of the importance of the principle of least privilege and the role of on-prem security to cloud security.

Building the ultimate Azure AD hacking tool

by Dr. Nestori Syynimaa

How did I built the ultimate Azure AD hacking tool from the scratch AADInternals is an open-source toolkit for hacking and administering Azure AD and Office 365.

Come to see and learn how did I build the script-only module (seen in action at BlackHat USA & Europe 2019 Arsenal), what obstacles I had, and how I managed to overcome them!

AAD Internals is a PowerShell module where I’ve tried to put all the knowledge I’ve gained during the years spent with Office 365 and Azure AD. It is a result of hours of reverse-engineering and debugging of Microsoft tools related to Azure AD, such as PowerShell modules, directory synchronisation, and admin portals.

I decided to make the module a plain PowerShell script module, so that everyone could copy and paste the code to their own scripts as needed. In this session, attendees will learn real-life experiences of making one’s knowledge available to the community in the form of easy-to-use PowerShell module. As such, the session contains a lot of war stories and live demos - just what the devs are looking for!

You can open this web page in a separate window during the live event to submit live questions in real-time.

What the log?! So many events, so little time…

by Miriam Wiesner

Detecting adversaries is not always easy. Especially when it comes to correlating Windows Event Logs to real-world attack patterns and techniques.

Join me to find out how to match Windows Event Log IDs with the MITRE ATT&CK framework and methods to simplify the detection in your environment.

The PowerShell edition: see how to correlate events not only via the GUI, now you can automate it..!

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

Cloud, Azure and DSC

2020-06-02T00:00:00+00:00

This is not about DSC in the Cloud but rather we are combining the topics Cloud, Azure, and DSC in one panel. Below you find the awesome session videos touching on these topics, and we’d love to meet you live in our panel to discuss any questions you may have:

We cordially invite you to participate in our live Q&A targeting PowerShell Cloud, Azure or DSC. It is taking place June 3, 2020 at 6pm CEST, and you’ll have a chance to meet the speakers, other security experts, and ask any question you may have.

Please note that psconf.eu organizer and speakers are volunteers. While we are passionately committed to provide an awesome experience for you, we cannot guarantee that things will always go according to plan. There is especially no guarantee that every speaker who delivered free content below can in fact join the Q&A.

Is DSC Dead?

by Gael Colas & Michael Greene

Unless you are heavily involved with Desired State Configuration (DSC), and you’ve been paying attention to the DSC planning updates, the DSC Community Calls, you might have trouble seeing what’s going on with DSC.

In this session, we’ll try to briefly review the why and what of DSC, decrypt all the recent news and see how it looks today, and finally make some predictions on its evolution.

We’ll review DSC’s core principles and components, the differences between platform, solutions, resources and the community behind https://dsccommunity.org.

We will discuss how third parties, such as Chef, Puppet, Ansible, but also AWS, VMWare, Cisco are leveraging the technology. Next, we’ll see a demo the work done by the PowerShell team to make invoking DSC resources work from PowerShell 7 on any platform from the RFC I wrote.

We will discuss scenarios, current limitations and some tricks and tips you may find useful. Finally, we can’t talk about the future of DSC without spending some time on Azure Policy Guest Configuration, which leverages the new codebase of a DSC agent (sometimes called DSCv2 or LCMv2).

We’ll look at how you can leverage DSC resources, enact changes, and how hybrid scenarios can be addressed with Azure ARC.

As I’ve been lucky to be contracted by the DSC team to work with them and the PowerShell team for several months, feel free to bring your questions and feedback as I’m happy to forward your feedback!

Authoring class based DSC resources – notes from the field

by Bartek Bielawski

PowerShell classes were added to PowerShell language to improve experience for DSC resource authors.

In this session, you will learn how you can extend DSC with resources written in a form of PowerShell classes, complete with tips, lessons learned and common pitfalls.

We will also look into testing of authored resources to make sure that resource gets the job done.

Automated Application Testing With Azure Spot VMs & DevOps Pipelines

by Ben Reader & Friends

Automated Application Testing: How to make Azure Spot VMs and DevOps Pipelines do the work for you!

PowerShell classes were added to PowerShell language to improve experience for DSC resource authors.

In this session, you will learn how you can extend DSC with resources written in a form of PowerShell classes, complete with tips, lessons learned and common pitfalls.

We will also look into testing of authored resources to make sure that resource gets the job done.

Captain Kusto, do we have the Power?

by Mateusz Czerniawski

Azure Log Analytics (ALA) - what’s in it for me?

We all ❤ logs. But the True Power of Logs comes with what you can do with them.

Interested in building your own solution in under 15 minutes? It’s really easy with PowerShell to streamline the whole process Let’s talk about Logs as a Service - affordable, always available, easily customized and OS independent.

After this session you’ll know more about:

Azure Monitor
Kusto Query Language (KQL)
Rest API for ALA
Azure Dashboards
Power BI reports
Alert rules

Azure DevOps for PowerShell

by Barbara Forbes

Azure DevOps provides some great tooling for a DevOps working process.

But what about PowerShell? In this session, I will show you the different ways you can make use of Azure DevOps when working with PowerShell.

We will cover the basics: Connecting with GitHub, using the Azure DevOps repositories and creating CI/CD pipelines.

With the help of some practical demo’s and you will be able to get started for yourself right after this session.

Azure Functions in a hybrid world

by Jan Egil Ring

In this session we will start by looking into scenarios for using Azure Functions in hybrid environments, before we dive into the different options for running Azure Functions in your on-premises networks.

We will also look into best practices on how to organize and structure your functions, as well as see how we can store and retrieve global variables and credential assets.

Asking Questions

While live Q&A sessions are in progress, you can ask your questions by using our Q&A widget below. Note that you can also vote on questions others have submitted.

The live Q&A widget is closed when there is no live session in progress. Use our form at http://powershell.help to submit questions before or after live sessions.

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest!

Leave Comment

Please feel free to leave a comment if you have an organizational question or would like to share an idea.

psconf.eu Virtual Mini Conference

2020-05-30T00:00:00+00:00

Free Virtual Mini Conference

We kick this off June 2, 2020 at 5pm CEST, and you can watch it here:

If you are a speaker, we’ll send you a private invite link by Monday so you can join the panels and be “on stage”.

Our 25+ conference sessions are live already, and you can start watching them immediately: powershell.video. Please do so now and in the next days.

Our live sessions that we broadcast on this page June 2+3 are addressing your questions. That’s why we’d love you to watch the sessions now and then submit your questions.

To submit your question (anything PowerShell-related that is on your mind), please use our form. To ask questions in real-time during a live session, use our Q&A widget:

Asking Questions in Real-Time

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest.

Real-time questions are available only when live sessions are in progress.

You might want to open the live Q&A widget in a separate window.

Submitting Questions Offline

Feel free to submit as many PowerShell questions as you like via http://powershell.help any time!

We collect your questions and make sure they get addressed in the live panels. You can relax, lean back and watch the live sessions - knowing that your questions are already in the pipeline and will be asked on your behalf.

Schedule

There’s one single track. Below is our schedule.

Starting times of global events can be confusing. All times below are CEST (Central European Summer Time). Just click on any time below to automatically convert it to your local time, and you’ll never miss any session.

June 2, 2020

Date & Time	Topic
5:00pm CEST	Conference Opening
5:30pm CEST	Keynote with Jeffrey Snover & Joey Aiello
6:45pm CEST	Keynote Q&A
7:00pm CEST	PowerShell Security
8:00pm CEST	Pester & PowerShell Script Analyzer
9:00pm CEST	PowerShell Remoting

June 3, 2020

Date & Time	Topic
5:00pm CEST	PowerShell Suggestions, PS7, and PS Tips & Tricks
6:00pm CEST	Cloud and DSC (Desired State Configuration)
7:00pm CEST	PowerShell Deep Shit
8:00pm CEST	PowerShell GUIs and IoT

PowerShell Time Converter

If you’d like to use PowerShell to convert times from our timezone to your timezone, you can use this:

# ask for the session start time, i.e.: 6:45pm
param
(
  [Parameter(Mandatory)]
  [DateTime]
  $time
)

#region formatting preferences
# you can adjust these things to adopt the code to other use cases:
$culture = 'en-us'
$format  = 'h:mm:ss tt'
$cultureInfo = [System.Globalization.CultureInfo]::CreateSpecificCulture($culture)
#endregion formatting preferences

#region conversion details
# timezone to convert from:
[System.TimeZoneInfo]$fromTimeZone = Get-TimeZone -Name 'W. Europe Standard Time'
# timezone to convert to:
[System.TimeZoneInfo]$toTimeZone = Get-TimeZone
#endregion conversion details

#region perform conversion
$localTime = [System.TimeZoneInfo]::ConvertTimeBySystemTimeZoneId($time, $fromTimeZone.Id, $ToTimeZone.Id).ToString($format, $cultureInfo)
#endregion perform conversion

# output result
"Make sure you enter the session by $localTime!"

Quick Notes

Please help us spread the word by twitter and other channels. Simply point people to http://powershell.love!

Please keep in mind that we all (speakers & organizers) run this event as volunteers. We are no video or virtual conference experts, and we have a life, partners, kids, and a job.
There can be things going wrong, and in fact, with slightly adapted words of the titanic engineer: It’s not a question whether things go wrong but rather when. So let’s all together enjoy the best of this, and learn.
Our main focus is solid technology, so the first (and most important) part of this event is almost fail-safe: our sessions are recorded and available via a video platform for download and viewing. They will stay available, just like all the other sessions from previous years: powershell.video.
The live part on June 2+3 is a great way for you and us to connect, ask questions, have fun, and talk. See video feed and Q&A widget above to view the live stream and interact and ask live questions.

Thank You!

This virtual event was made possible by:

Our sponsors Microsoft, SystemFrontier, ScriptRunner and PowerShellOne decided to stick with the event this year and support the free virtual event.
Our speakers who agreed to record part of their original sessions for you.
Our core volunteers team consisting of Rob Sewell, Aleksandar Nikolic, and myself.
Our trusted video processor iStream who is supporting us and the entire event industry in these unusual times with advice and services.

If you’ve never been at psconf.eu, the best way to get a feeling for the welcoming spirit is a video from the last conference:

Leave Comment

Please feel free to leave a comment if you have a question or would like to share an idea.

psconf.eu Virtual Mini Conference

2020-05-30T00:00:00+00:00

Free Virtual Mini Conference

We kick this off June 2, 2020 at 5pm CEST, and you can watch it here:

If you do not see sliding images and hear music ten minutes prior to launch, then please clear your browser cache, or open this page in an incognito browser window. Apparently, on some systems the still image is cached a bit too long.

We sent all speakers a private invite link so you can join the panels and be “on stage”. If you haven’t received the link by now, please contact us.

Our 25+ conference sessions are live already, and you can start watching them immediately: powershell.video. Please do so now and in the next days:

Topic	Watch Videos (we turned them into collections)
PowerShell 7 & beyond	https://powershell.one/psconfeu/psconf.eu-2020/powershell-7
PowerShell Deep Shit	https://powershell.one/psconfeu/psconf.eu-2020/powershell-deep-shit
Security	https://powershell.one/psconfeu/psconf.eu-2020/security
Pester, VSCode, PSScriptAnalyzer	https://powershell.one/psconfeu/psconf.eu-2020/pester
Cloud, Azure, or DSC	https://powershell.one/psconfeu/psconf.eu-2020/cloud
IoT	https://powershell.one/psconfeu/psconf.eu-2020/iot

Our live sessions that we broadcast on this page June 2+3 are addressing your questions that you may have after watching the videos (which coincidentally is why we ask you to watch them before the live sessions).

But don’t worry. You can watch them later, too. In our live panels, feel free to ask any PowerShell-related question that comes to your mind. Please do ask questions to get things rolling - we’re hoping for your input!

To submit your question (anything PowerShell-related that is on your mind), please use our form. To ask questions in real-time during a live session, use our Q&A widget:

Asking Questions in Real-Time

You do not need to have a Vimeo account nor do you need to log in. Simply choose the option to Chat as a Guest.

Real-time questions are available only when live sessions are in progress.

You might want to open the live Q&A widget in a separate window. We’ll also monitor twitter, please use hashtag #psconfeu.

Submitting Questions Offline

Feel free to submit as many PowerShell questions as you like via http://powershell.help any time!

Schedule

There’s one single track. Below is our schedule.

Starting times of global events can be confusing. All times below are CEST (Central European Summer Time). Just click on any time below to automatically convert it to your local time, and you’ll never miss any session.

June 2, 2020

Date & Time	Topic	Moderator	See Also
5:00pm CEST	Conference Opening	Tobias
5:30pm CEST	Keynote with Jeffrey Snover & Joey Aiello	Tobias
6:45pm CEST	Keynote Q&A
7:00pm CEST	PowerShell Security	Aleksandar	view
8:00pm CEST	Pester & PowerShell Script Analyzer	Rob	view
9:00pm CEST	PowerShell Remoting	Aleksandar

June 3, 2020

Date & Time	Topic	Moderator	See Also
5:00pm CEST	PowerShell 7, PowerShellGet, General PowerShell Chat	Rob	view
6:00pm CEST	Cloud and DSC (Desired State Configuration)	Aleksandar	view
7:00pm CEST	PowerShell Deep Shit	Tobias	view
8:00pm CEST	PowerShell GUIs and IoT	Rob	view

PowerShell Time Converter

If you’d like to use PowerShell to convert times from our timezone to your timezone, you can use this:

# ask for the session start time, i.e.: 6:45pm
param
(
  [Parameter(Mandatory)]
  [DateTime]
  $time
)

#region formatting preferences
# you can adjust these things to adopt the code to other use cases:
$culture = 'en-us'
$format  = 'h:mm:ss tt'
$cultureInfo = [System.Globalization.CultureInfo]::CreateSpecificCulture($culture)
#endregion formatting preferences

#region conversion details
# timezone to convert from:
[System.TimeZoneInfo]$fromTimeZone = Get-TimeZone -Name 'W. Europe Standard Time'
# timezone to convert to:
[System.TimeZoneInfo]$toTimeZone = Get-TimeZone
#endregion conversion details

#region perform conversion
$localTime = [System.TimeZoneInfo]::ConvertTimeBySystemTimeZoneId($time, $fromTimeZone.Id, $ToTimeZone.Id).ToString($format, $cultureInfo)
#endregion perform conversion

# output result
"Make sure you enter the session by $localTime!"

Quick Notes

Please help us spread the word by twitter and other channels. Simply point people to http://powershell.love!

Please keep in mind that we all (speakers & organizers) run this event as volunteers. We are no video or virtual conference experts, and we have a life, partners, kids, and a job.
There can be things going wrong, and in fact, with slightly adapted words of the titanic engineer: It’s not a question whether things go wrong but rather when. So let’s all together enjoy the best of this, and learn.
Our main focus is solid technology, so the first (and most important) part of this event is almost fail-safe: our sessions are recorded and available via a video platform for download and viewing. They will stay available, just like all the other sessions from previous years: powershell.video.
The live part on June 2+3 is a great way for you and us to connect, ask questions, have fun, and talk. See video feed and Q&A widget above to view the live stream and interact and ask live questions.

Thank You!

This virtual event was made possible by:

Our sponsors Microsoft, SystemFrontier, ScriptRunner and PowerShellOne decided to stick with the event this year and support the free virtual event.
Our speakers who agreed to record part of their original sessions for you.
Our core volunteers team consisting of Rob Sewell, Aleksandar Nikolic, and myself.
Our trusted video processor iStream who is supporting us and the entire event industry in these unusual times with advice and services.

If you’ve never been at psconf.eu, the best way to get a feeling for the welcoming spirit is a video from the last conference:

Leave Comment

Please feel free to leave a comment if you have a question or would like to share an idea.

powershell.one

Setting Registry Values (Smart)

Setting Many Registry Values At Once

Pipeline To The Rescue

Pipeline Binding Conflict

Do it right: Setting Multiple Registry Values

Auto-Learning Auto-Completion

Add Auto-Learning Auto-Completion

How this works

Further Reading

Wish List for the PowerShell Team

PowerShell IoT (and GUIs, too)

PowerShell IoT v2 - What’s new, what changed and what I’ve learned

PowerShell on Raspberry PI - Making a connected greenhouse

PowerShell in Notebooks

Notebooks + VS Code

Asking Questions

Leave Comment

Pester and ScriptAnalyzer

Building PowerShell, its VS-Code extension and debugging it

What’s new in Pester v5?

Asking Questions

Leave Comment

PowerShell 7

PowerShell 7.1: A Next Gen Shell

PowerShellGet 3.0

The Seven Deadly Sins of PowerShell

Asking Questions

Leave Comment

PowerShell Deep Shit

Querying Wikidata with a glimpse of SPARQL

Module System Deep-Dive

Classes & runspaces together - Async logging in PowerShell

I Compare: PowerShell Edition

Become a parameter ninja

Don’t be scared of calling APIs!

Just git it!

Building a Custom PowerShell Host

Beyond lab: Scripting at Scale

PowerShell Scoping for Mere Mortals

Going native: A non-developer’s tale

Asking Questions

Leave Comment

Security

Managing Secrets from your dev box to the cloud

Abusing Azure Active Directory: Who would you like to be today?

Building the ultimate Azure AD hacking tool

What the log?! So many events, so little time…

Asking Questions

Leave Comment

Cloud, Azure and DSC

Is DSC Dead?

Authoring class based DSC resources – notes from the field

Automated Application Testing With Azure Spot VMs & DevOps Pipelines

Captain Kusto, do we have the Power?

Azure DevOps for PowerShell

Azure Functions in a hybrid world

Asking Questions

Leave Comment

psconf.eu Virtual Mini Conference

Free Virtual Mini Conference

Asking Questions in Real-Time

Submitting Questions Offline

Schedule

June 2, 2020

June 3, 2020

PowerShell Time Converter

Quick Notes

Thank You!

Leave Comment

psconf.eu Virtual Mini Conference

Free Virtual Mini Conference

Asking Questions in Real-Time

Submitting Questions Offline

Schedule

June 2, 2020

June 3, 2020

PowerShell Time Converter

Quick Notes

Thank You!