PowerShell Deep Shit

Watch sessions about mindblowing and fun PowerShell techniques, learn advanced know-how, and meet us in our live Q&A!

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.