Rob Pleau
PowerShell, DevOps, and Linux enthusiast
Actions
I’m Bobby, the "PowerShell-on-Linux" guy. Since 2013, I've been scripting, automating, and occasionally confusing both Windows and Linux purists by running PowerShell everywhere, even on Arch Linux. My career has spanned roles in System Administration, DevOps, Cloud Security, and Application Security, but through it all, PowerShell has been my favorite shell.
Neovim as Your PowerShell IDE?! Speed Up Your Local Dev Workflow Today!
You've heard about these "Vim Wizards" but the truth is that you don't need to be a Vim Wizard to start using Neovim/Vim. You probably already live in the terminal so why not code inside of it as well? We'll dive into how you can use Neovim as your PowerShell editor of choice and how to set it up to do that!
In this session we'll cover:
- Why Neovim (or Vim)? It's fast! Seriously, like way faster than a traditional IDE. We'll talk about what Vim motions are and why they speed up our development flow.
- Vim versus Neovim, what are the differences?
- Where do you start? How to get Neovim up and running extremely fast.
- How to extend Neovim to start writing PowerShell by leveraging PowerShell Editor Services as our LSP (Language Server Protocol).
- Customizations don't need to be handcrafted, we'll see how to extend our Neovim with plugins.
- What the pros and cons are of Neovim versus VS Code.
- Do you like the idea of Vim motions but not quite ready to jump all in to Neovim/Vim? We'll talk about the Vim extension for VS Code.
We'll be honest about the strengths but also some of the current challenges on making the switch to Neovim.
If you attend this session I promise you this, you at least will finally know how to exit Vim!
Stop Writing Insecure PowerShell! Seriously.
Writing secure PowerShell doesn't need to be hard! There are tools available that will immediately aid you in securing your PowerShell code that come at no cost.
What we'll cover:
- A review of the in-box rules in PSScriptAnalyzer related to security.
- We'll look at how we can extend PSScriptAnalyzer rules with PowerShell InjectionHunter.
- How to create a custom PSScriptAnalyzer rule to cover something that might not exist yet.
- Wiring these up to a Github Actions workflow so we can not only run locally but in our CI/CD pipeline as well.
- Using Microsoft.PowerShell.SecretManagement to keep sensitive API keys/tokens and passwords out of your code.
- Lastly, trust what you use. Are you pulling in a dependency? Things to look for when reviewing external code dependencies.
Writing more secure code is a time investment that is much cheaper than a breach. Use these tools to start writing secure PowerShell code today!
Linux Shell Debates or: How I Stopped Worrying and Learned to Love PowerShell
It's time to stand up and make PowerShell as ubiquitous as Bash, Zsh, Fish, and all other shells in the Linux ecosystem. Stop being ashamed to use PowerShell on Linux!
In this session we'll dive into the following:
- Traditional text streaming shells compared to PowerShell
- In this section we'll break down the difference between 'traditional' shells found in Linux and PowerShell with live examples (pwsh/zsh/bash/fish)
- What is a POSIX compliant shell and do I need it?
- A lot of traditionalists will talk of needing something POSIX compliant, we'll look at what that means and briefly discuss the pros and cons of this approach.
- The elephant in the room, where does Python come into play?
- Python is a powerful language and is well established in the Linux world. We’ll touch on this a bit
- Using the native tooling you know and love is easy
- PowerShell allows the best of both worlds where you can use native PowerShell functionality as well as the built-in commands and tooling. We can see how PowerShell can expand on existing tooling.
- Finally we'll look at using PowerShell Crescendo to wrap non PowerShell commands into a more PowerShell-like experience with examples of some common commands found on a Linux system.
Don’t Stop at the PowerShell Pipeline. Build a CI/CD Pipeline for your PowerShell Module Deployment!
Do you have a module you want to publish to the PowerShell Gallery? Or perhaps you are publishing one already with “Publish-Module'' and realized you forgot to export a function before publishing, or maybe you had a syntax error. If only there was a way to catch these simple mistakes before you ship the code… Oh wait, there is!!!
Come to this session to learn how to get your modules published consistently and reliably with a CI/CD pipeline built with Github Actions.
In this session you’ll learn how to:
- Structure your module in a way that allows it to be easily deployed.
- Lint your module code with PSScriptAnalyzer.
- User Pester to validate your module is free from any common errors.
- Use Github Actions to automate the linting, testing and even deployment of your module.
Can we Make PowerShell… Blazingly Fast?!
PowerShell, like other scripting languages lets you get things done A LOT of different ways. Some of these ways are much faster than others. We’re going to look at a lot of the common pitfalls with PowerShell and see if we can work around them. We’re also going to see if we can make PowerShell... **Blazingly Fast**
We’ll put PowerShell through the paces and look at some of the following and more:
- foreach vs Foreach-Object vs .foreach() vs Foreach-Object -Parallel
- Arrays, Array Lists, and Generic Lists (oh my!)
- Where-Object vs .where()
- PSCustomObject vs Hashtables
- Filter left -> Format Right
- Function vs Cmdlet
- Native PowerShell command vs .Net objects
- PowerShell Jobs
At a minimum you’ll leave this session knowing ways to better optimize your scripts!
99 Problems, but Slow PowerShell Ain't One! A.K.A. Use Profiler to Find Performance Issues!
Do you have a PowerShell script, function, or module running slow and you want to identify the issue? Did you know that there is a PowerShell module called "Profiler" by Jakub Jareš that can help you identify where the issue exists? If you got slow code, this is the session for you! We'll learn how to use Profiler to find where potential code bottlenecks exist in our PowerShell code!
This is a bit of a continuation of "Can We Make PowerShell Blazingly Fast" from 2024 but don't worry, you didn't need to attend that to get the value from this session! We'll see how Profiler can help us identify those issues that cause our PowerShell code to run slow.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top