►
From YouTube: Whip Your Scripts into Shape Optimizing PowerShell for Speed with Joshua King - October 17th 2018
Description
Join us for an in-depth session with guest speaker, Josh King, who will be showing how small changes in code can have HUGE impacts on run times.
Josh King is a geek, father, and walking helpdesk. He is a Senior Infrastructure & Automation Administrator at a city council in regional New Zealand, working within a Windows and VMware environment.
Josh will be pointing out things everyday admins can do to speed up their scripts and highlighting unrealized bottlenecks that admins and developers write into their code every day that have unintended consequences.
He'll be highlighting ways you can improve your code so it's lightning fast as well as showing off techniques you can use to measure performance in meaningful ways based on statistical analysis. With a handful of his techniques tucked away in your tool belt your PowerShell code will be running faster than ever.
Buckle up for a demo-heavy session that can’t drop below 50 mph. When every second counts, you can’t sit around waiting for your script to finish.
Resources:
Scripts and Modules:
https://github.com/rtpsug/Meetups/tree/master/2018/10-October/Josh%20King
In addition to this talk, you can also check out Josh's excellent website: https://king.geek.nz/
Learn about VS Code from our last meeting: https://youtu.be/1O0ijuaEPqo
SUBSCRIBE to learn about PowerShell!
https://www.youtube.com/channel/UCiTuB6HZiupE8CJ71vkMFnA/example?sub_confirmation=1
LET'S CONNECT!
-- https://twitter.com/rtpsug
-- https://www.meetup.com/Research-Triangle-PowerShell-Users-Group/
A
A
B
A
Quote:
I'm
quite
real
programming
language
like
C,
sharp
and
a
lot
of
it
does
come
down
to
that
in
the
sugars.
Add
up
time,
because,
frankly,
if
you
get
a
bad
first
impression
and
yeah,
it's
going
to
take
your
impression
and
it
seems
to
be
a
pretty
common
proclaim.
So
this
was
a
screenshot
from
Google
back
in
April
and
the.
A
A
You
can
try
a
little
bit
more
about
that
module
behind
the
scenes
that
uses
posh,
sherry
stroke
and
that's
so
that
we
can
run
multiple
iterations
of
the
test
cases
at
the
same
time,
because
we
default
into
a
hundred
iterations
of
each
test
case.
So
unless
you
see
me
specifically
put
iterations
on
something
it's
running
a
hundred
times
for
each
case,
both
the
control
and
the
variation
and
the
only
reason
I've
ever
decreased.
A
The
winner-
and
we
also
see
the
minimum
maximum
just
to
get
some
context
around
it
and
what,
within
that
I'm
using
the
stopwatch
net
class
rather
than
the
built-in
music
command
commander,
and
that's
because
the
measure
command
command
that
actually
disregards
console
output,
which
is
the
subject
of
a
couple
of
our
tests.
So
if
we
use
measure
command,
we
miss
out
on
some
of
the
timings
and
we'll
see
an
example
of
this
before
we
start.
A
But
the
results
being
displayed
using
Adam
dress
skills,
powershell
universal
dashboard,
which
is
a
really
awesome
module
and
you
haven't
looked
at
it,
give
it
a
look.
Sorry,
that's
it
for
the
slides
for
the
first
part
of
us,
let's
jump
over
to
some
code,
so
we're
going
to
be
covering
eleven
topics
and
those
taught
yet
eleven
concepts
comprising
of
sixteen
demos
and,
at
the
end,
we'll
have
a
bonus
round
with
some
comparisons
between
Windows,
PowerShell
and
PowerShell
core,
and
these
demos
may
have
unexpected
results.
And
that's
sort
of
the
point.
A
I've
tried
to
pick
out
good
examples
for
each
of
these,
but
do
keep
in
mind
we're
dealing
with
a
small
sample
set
and
a
lot
of
these
increases
or
decreases
and
runtimes
will
vary
if
you're
dealing
with
a
hundred
times
or
a
thousand
times
the
sample
set.
That
I
am
I've
had
to
keep.
This
quote
slim
to.
A
B
A
A
So
our
results
are
always
measured
in
milliseconds,
so
the
control
took
an
average
of
just
under
20
milliseconds
and
our
variation,
which
one
took
an
average
of
you
might
as
well
say
it
was
instant
and
then
the
difference
on
the
right
is
the
percentage
increase
or
decrease
so
being
faster,
and
in
this
case
it
was
98
2%,
faster,
so
demos
I
mentioned
output
to
the
console.
So
let's
have
a
look
at
that.
First
and
I,
most
of
my
demos,
have
tried
to
keep
the
output
of
these
scripts
identical.
A
A
Just
to
drive
drive
the
point
home,
so
our
control
is
running,
get
trolled
item
on
my
drivers
directory
on
my
machine
and,
as
you
would
expect,
when
you
run
this
command,
it
outputs
the
listing
of
files
to
the
console,
the
variation
being
assigning
that
to
aveer
assigning
that
to
a
variable
now,
obviously-
or
usually,
that's
how
you
do
it
anyway,
but
it's
a
good
example:
four:
how
about
putting
something
to
the
consult
dose,
slow
things
down
so,
let's
and
that
did
work.
Let's
rerun
it.
A
A
Actually,
let's
run
this
one
again:
I
have
a
feeling
actually
so
it
my
demise
on
the
row
on
the
fly.
I
think
I've
got
data
sitting
in
my
data
folder,
so
it
does
depend
on
how
much
how
many
files
of
the
air,
whether
or
not
you've
got
access
to
them
and
but
basically,
when
you're
running
the
commands,
you'll
often
you'll
see
it
more
than
anything
else
like
when
outputs
go
into
the
console.
A
It's
slow
enough
that
you
can
sort
of
pick
out
the
patterns,
if
not
actually
read,
what's
showing
and
generally
with
something
like
this,
if
you
assign
it
to
a
variable,
it
just
runs
instantly,
but
you,
as
you
can
see
not
the
case
today,
but
we
are
talking
literally
milliseconds
here,
like
the
difference
being
point
three
milliseconds,
that's
a
really
easy
to
miss
that
one,
but
onto
something
that
will
have
a
measurable
impact
is
filters.
So
one
of
the
first
things
you
learn
when
working
with
PowerShell.
A
A
And
I
think
we're
all
more
release,
except
that
that's
what
we
should
do:
filter
the
objects
as
close
to
the
side
of
your
command
as
possible,
but
I'm
not
sure
how
many
people
have
actually
have
a
test
of
that.
So
our
control
here
is
we're
getting
some
events
from
my
applications,
log
where
the
ID
is
a
specific
number
and
that
was
created
within
the
last
hour.
B
A
Good,
actually
one
that
so
the
difference
here
is
this
command
is
actually
is
just
going
to
return.
The
events
that
I
want
this
one
is
going
to
return
all
the
events
from
the
application
log
pipe
them
through
deal
with
to
the
memory
and
then
filter
out
so
I
end
up
in
events
with
the
same
the
same
results,
and
if
we
look
at
those
results
piping
through
to
where
object
takes
1.3
seconds,
but
using
the
filter
within
the
commander
itself
is
40,
milliseconds
and
they're
being
about
a
97%
decrease.
A
So
yeah
filtering
to
the
left,
yes
makes
a
difference
if
the
command
that
has
a
filter
it's
worth
using
it
rather
than
relying
on
where
object
now
to
be
fear,
the
syntax
isn't
always
obvious,
and
it's
not
uniform
across
the
entire
space
of
commandlets
and
functions.
So
it
pays
to
look
at
the
help
and
look
at
the
examples,
and
hopefully
there's
a
decent
example
of
using
the
filters
in
a
similar
vein.
A
There's
the
concept
of
only
making
expensive
requests
once
so,
I
call
the
single
and
the
control
here
as
an
example,
as
we've
learned
to
use
the
filter
table,
that's
awesome.
Yeah
the
filter
hash
table,
but
now
we
want
to
get
an
event
from
our
evidence
and
an
event
from
our
suss
events
or
our
system
and
applications.
A
But
then
we
to
end
up
with
the
same
variables
at
the
end.
F
events
us
events
within
using
the
wear
method
to
split
them
out,
so
we've
got
a
prevents
looking
for
application
and
so
screens
looking
for
system
the
result
of
that
isn't
huge.
In
this
example,
we
you
might
see
decent
improvements
is
in
Active
Directory,
specifically
for
me,
it's
when
I'm
looking
for
both
contractors
and
staff.
A
A
B
A
The
for
pipelines,
let's
talk
a
little
bit
about
the
Boston,
so
PowerShell
is
great
need
to
remember.
To
run.
Powershell
is
great
at
giving
you
shortcuts
to
get
the
job
done.
So
here's
an
example
of
getting
all
my
services
that
are
currently
running
and
selecting
the
first
five
and
assigning
that
to
the
services
variable,
but,
as
you
can
see,
I'm
using
aliases
and
shortcuts
throughout
here.
A
A
And
for
such
a
small
change,
that's
quite
a
big
improvement
now
to
be
fair.
A
lot
of
that
is
thus
using
service
here.
So
in
PowerShell,
most
of
your
get
Commandments
you
can
leave
off
the
get
and
it
will
figure
out
through
a
quite
a
long
process
that
you're
actually
calling
get
service.
So
what
it's
doing
is
I
believe.
First,
if
you
call
service
it
first
looks
for
service
dot
exe.
It
then
looks
for
a
function
called
service.
A
B
A
The
files
in
my
team
directory
and
I
want
to
just
find
all
the
ones
where
the
links
are
greater
than
5,000
so
hoping
to
where
object.
Notice
on
beings
are
both
here
rather
than
just
typing
we're,
because
we
know
that
helps
now,
but
of
course,
and
I
think
it
was
I,
don't
remember,
it
was
PowerShell,
3
or
PowerShell
for
that
introduced.
The
wear
method,
which
is
this
dot,
wear
notation.
B
A
My
control
here
is
I'm
grabbing
my
PowerShell
version
from
the
version
table
and
if
you
haven't
seen
that
it
comes
out
as
an
object
that
looks
like
this
and
effectively
I
want
to
see
it
from
running
a
version.
That's
newer
than
5.1.1
five
zero,
zero,
zero
and
how
I
had
considered
doing
this
initially
was
I
was
going
to
split
that
version
on
the
period.
A
So
it
end
up
with
an
array
containing
five
in
one,
then
fifteen
thousand
and
I'd
go
through
and
check
the
major
version
being
the
five
against
the
first
element
and
then
go
down
to
the
minor,
which
is
the
one
and
in
the
build.
If
all
of
those
passed,
it
would
be
a
true
and
otherwise
folks,
as
you
might
expect,
there's
a
bit
a
way
to
do
that
and
that's
the
cast.
What
I'm?
Looking
for
as
a
version
object-
and
then
I
can
simply
go,
is
this
greater
than
that?
A
However,
lot
simpler
and
quite
a
lot
faster,
so
40%
mean
yes,
we've
gone
from
one
point:
six
milliseconds
to
0.9,
so
you're
never
going
to
notice
that
difference,
but
it
does
illustrate
how
knowing
like
until
I
found
out
about
this
I
had
no
idea.
I
could
cast
a
string
as
a
version
and
yeah
that
just
made
that
so
much
simpler,
so
a
better
version.
Sorry,
a
better
example
of
this
unnecessary
operations.
Topic.
A
Is
searching
for
something
in
a
hash
table,
so
in
this
example,
I've
got
a
hash
table
which
is
just
so
how
I
generated
this
hash
table?
Is
it's
a
list
of
all
of
my
running
processes
through
placated
about
10
times
with
a
number
appended
to
the
end,
so
I
don't
end
up
with
duplicate
keys,
basically,
I
just
wanted
to
end
up
with
a
fairly
large
hash
table
and
in
that
hash
table
I'm.
Looking
for
a
process
called
process
service
process
process
called
MMC.
A
So
how
I've
tried
to
look
for
that
as
I'm?
Looking
for
my
inch
well
I'm
looking
for
each
entry
in
my
hash
table,
looking
at
all
of
the
keys
checking
to
see
if
my
entry
matches
the
target
that
I'm
looking
for
MMC,
if
it
is
I
returned
true
and
I
break
out
of
my
for
each
loop,
so
at
the
point
it
finds
it,
it
stops
running
the
for
each
loop.
I
have
my
output.
The
variation
on
that
is
hash
tables
actually
have
a
method
called
contains
key.
B
A
It's
searched
for
it;
it
must
have
found
it
like
really
quickly.
Let's
try
changing
that
to
a
six,
so
here's
the
thing
if
it
finds
because
it
breaks
out
if
it
finds
it
right
away,
which
seems
to
be
a
random
chance
whatever
if
it
finds
it
right
away,
it
will
break
out
almost
as
quick,
if
not
quicker
than
the
method,
but
the
method
will
always
be
pretty
quick.
In
fact,
if
you
look
at
the
maximums
on
the
control
actually
something's.
B
A
As
I
said,
some
of
these
demos
aren't
going
to
go
as
I
expected
there.
We
go
that's
better,
so
this
is
the
revolt.
I
was
getting
consistently
when
I
was
running
through
these
prior
to
today.
A
half
so
I
expected
this
to
be
about
1/3
quicker,
so
15
milliseconds
compared
to
10,
but
as
you
can
see,
it's
a
bit
of
a
whack
of
the
drawer
some
times
and
on
this
topic
of
unnecessary
operations.
I've
got
a
third
example,
a.
A
A
So
we've
shaved
off
about
two
whole
seconds,
totaling
about
80%,
so
yeah,
going
from
two
and
a
half
seconds
using
the
get
content
just
get
content,
yep
get
content
and
trimming
it
down
to
half
a
second
which,
if
I
remember
correctly,
this
is
the
directory
worth
two
hundred
odd
files.
So
yeah
again,
if
you're
dealing
with
thousands
of
files
expect
a
substantial
speed-up
and.
A
A
bit
more
about
the
language
reading
the
help
documentation,
because
on
the
surface
that
makes
sense
you
get
your
text
files,
you
read
under
content
from
them
and
then
you
search
through
the
content,
knowing
that
select
string
handles
a
lot
of
it.
For
you
there's
something
you
only
know
when
you
know
it.
Yeah.
A
And
a
lot
of
the
speed
increases
we've
seen
so
far
is
because
we
using
the
features
of
PowerShell
that
make
PowerShell
easy
to
use.
So,
as
you
get
more
and
more
help
using
using
your
system
to
do
our
tasks,
its
abstracting
away,
the
lower
level
stuff
from
you,
but
that
abstraction
has
some
overhead
associated
with
it.
A
A
A
A
You'll
often
see
collections
are
stablished
like
this,
so
you've
got
a
variable
with
an
empty
collection,
and
all
we're
doing
here
is
using
the
random
class
to
generate
a
thousand
random
numbers
and
each
random
number
we're
using
plus
equals
to
add
it
to
the
collection,
but
our
that,
as
you
might
expect
a
little
bit
expensive
and
my
preferred
way
of
actually
doing
with
us
is
using
specifically
ArrayList
and
calling
the
add
method
on
them
and
you'll
notice.
I've
got
null
equals
at
the
start.
We'll
cover
that
in
these.
A
A
B
A
B
A
Somewhere,
where
you
will
I
mean
it's
not
it's
not
actually
garbage
collection,
certainly
speaking,
but
if
you're
using
calm
objects,
you
would
want
like,
if
you're
launching
a
launching
word
from
PowerShell
you'd,
want
to
close
that
word
instance.
So
you
don't
end
up
locking
files
and
anything
weird
like
that
happening,
but
that's
yeah.
A
B
B
A
B
B
A
A
And,
of
course,
when
you
start
talking
about
arraylists
and
that
you
end
up
hearing
so
arraylists
are
what
I
like
to
use
for
my
collections.
So
in
this
example,
we're
going
to
use
ArrayList
skin
and
we'll
compare
it
against
another
way
of
creating
your
collections,
which
is
why
bother
initializing
it
at
all?
Why
don't
you
just
assign
the
output
of
your
for
each
to
a
variable
and
I.
B
A
Even
if
it
is-
and
that
case
well
point
two
milliseconds
between
them,
even
if
it
is
faster,
I
just
prefer
using
the
ArrayList
because
yeah
you
end
up
with
those
other
methods.
We
were
just
talking
about,
and
yeah
I
like
the
control
of
being
Odette,
specifically
add
something
and
yeah
so
call
it
personal
preference.
The
same
reason,
I
assigned
to
know
I
guess,
is
because
I
prefer
this
notation
to
the
other
options
and
it's
faster
than
out
now,
which
is
where
we
go
next.
B
A
B
A
B
A
How
I
had
no
equals
in
the
previous
example?
So
I
guess,
let's
have
a
look
at
why
so.
This
is
my
ArrayList
example
again,
but
this
time
on
piping
to
the
command,
let
out
null
which
looks
clean
and
readable
and
make
sense,
but
as
you
would
expect
at
this
point,
we
got
a
pipeline.
We've
got
a
command
alert,
it's
going
to
be
slower,
and
so
let's
will
compare
out
mount
and
assigning
to
null
Oh.
A
Going
from
0.1
seconds
down,
yeah
2
milliseconds,
so
I
mean
it
at
this
point:
it's
not
going
to
be
a
shocker.
This
isn't
that
out,
nulls
dramatically
slower
again
pipeline
command
lot,
but
let's
have
a
look
at
the
alternative,
so
we've
got
null
equals
well
one
of
the
alternatives
and
that's
casting
to
void.
A
So
technically-
and
this
has
been
true
most
times
of
run-
this
technically
casting
to
void-
is
quicker,
but
I
prefer
not
to
use
it
and
that's
partly
personal
preference
and
partly
because
you
can't
put
this
void
at
the
front
of
everything,
whereas
I
haven't
run
into
a
situation
where
I
can't
assign
to
no,
but
frankly,
as
long
as
you're
not
typing
to
up
now
you'll
be
fine
and
another
option
is
using
the
redirection,
syntax
and
redirecting
to
now.
So
this
one.
A
A
Speed
improvements,
which
is
doing
things
in
parallel,
so
all
of
these
test
cases
have
been
using
Posterous
job
to
run
all
multiple
test
cases
at
once,
and
that's
so
that
we're
not
sitting
here
waiting
for
me
to
like
enumerate
a
thousand
goods
a
thousand
times
twice
or
a
hundred
times
twice.
So
an
example
of
this.
An
operation
is
pinging
a
bunch
of
addresses
out
on
the
internet
and
yes,
I'm
using
test
connection
here
rather
than
the
dotnet
class.
But
there's
the
cover
need
to
slow
it
down
a
little
bit.
A
So
in
my
control
here,
I've
got
a
list
of
targets
which
is
you
know,
Google's
DNS
proudly
is
the
NES
and
a
random
new
site
here
in
New
Zealand
I'm,
going
to
iterate
through
each
of
those
and
one
at
a
time
I'm
going
to
test
the
connection
to
it
by
sending
to
echo
request,
set
up
returning
to
or
false,
or
rather
storing,
true
or
false,
and
then
outputting
an
object
that
contains
what
I
find
what
the
response
was.
So.
A
A
A
A
B
A
As
an
aside,
while
this
is
running
this,
all
of
these
demos
were
originally
lined
up
to
run
and
visual
studio
code
and
as
I
pulled
up
each
example.
The
test
cases
run
automatically
there
we
go,
but
that
broke
last
night,
so
I've
had
to
switch
over
to
the
ISE
and
I'm
running
these
menu
Li
the
DC
73%
faster.
A
So
we
might
actually
use
this
as
if
you
needed
to
go
off
to
your
entire
fleet
of
desktops
and
look
for
a
particular
file
in
a
particular
directory.
If
you
can
do
50
desktops
at
once,
rather
than
one
at
a
time
because
it's
going
to
be
a
hell
of
a
lot
faster
and
posh
iris
job
is
just
there's
a
module.
I
prefer
to
use
for
it
because
it's
worked
well
for
me
so
far,
so
there
it
is
all
of
those
demos,
but
I've
got
a
little
bit
of
a
bonus
round.
A
A
A
A
And
when
I
went
to
run
this
initially
I
edited
their
example
a
little
bit
and
couldn't
figure
out
why
I
wasn't
seeing
what
they
were
seeing
so
in
this
case
I'm
getting
a
thousand
random
numbers
and
grouping
them,
and
this
was
specifically
one
of
the
examples
that
Microsoft
gave
a
PowerShell
core
being
faster.
But,
as
you
can
see,
Windows
PowerShell
took
68
milliseconds
PowerShell
Corps
took
74
and
yeah,
that's
slower.
A
A
B
A
A
So
that's
all
of
our
demos.
Let's
quickly
go
back
to
the
slides
and
wrap
up
so
here's
the
question
after
all
of
that
is,
are
these
examples
are
silver
bullet
and,
as
you
would
have
expected
from
or
might
have
expected
after
some
of
those
demos
didn't
quite
work.
How
I
expected
them
to
the
simple
answer
is
no,
and
part
of
that
is,
while
some
of
these
methods
are
going
to
be
faster,
you
might
run
into
memory,
consumption
or
CPU
bottlenecks,
depending
on
specifically
what
you're
working
on
our
bigger
data
sets,
are,
etc.
A
Implementing
some
of
these
without
fully
understanding
what
you're
changing,
might
break
a
working
script
and
we'll
touch
on
what
to
do
about
that
and
the
next
slide
and
your
environments
are
snowflake.
So
I
know
what
works
for
me
in
my
environment,
on
my
servers
on
my
desktops
and
that
might
not
follow
through
on
your
environment.
A
Measure
twice,
as
you
saw
I,
had
to
run
a
couple
of
those
tests
multiple
times
and
every
time
I
ran
them.
I
got
something
different
and
on
some
of
them
that
was
so
tight
that
who
won
swapped
in
revisit,
especially
at
the
moment,
if
you're
looking
at
PowerShell
core
when
PowerShell
core
6.2
comes
out,
revisit
your
tests,
this
fish
there,
potentially
when
those
updates,
might
change
something
going
to
server
2019
/
2016
might
change
something.
Keep
your
tests
handy.
A
If
the
landscapes
changed
at
all
and
worry
about
optimization
after
it's
working,
so
don't
go
into
a
don't
unless
you
know
exactly
how
you
implement
something
so
like,
for
instance,
for
me:
I
always
use
ArrayList,
so
I
always
assigned
to
No.
There
are
certain
things,
I
always
do,
but
if
it's
not
your
standard
worry
about
getting
your
script
working
first
and
then
optimize
it.
If
that's
even
what
you're
looking
for
nobody's
saying,
you
have
to
have
fast
scripts
and
a
big
thing
is
test
your
code.
A
If
you've
got
Pierce
to
test
for
your
code,
you
make
a
breaking
change,
trying
to
optimize
it.
You
should
know
pretty
quickly
and
because
you're
only
changing
one
thing
at
once.
You
should
know
what
broker
and
especially,
if
you're,
working
out
of
source
control,
you
should
be
able
to
roll
it
back
pretty
quickly
too.
A
B
B
A
So
that
average
is
coming
from
measure
measure
object,
so
what's
coming
out
of
the
stopwatch
as
I'm
getting
the
elapsed,
milliseconds
and
I
just
get
a
collection
of
a
hundred
hundred
numbers,
then
I
whip
off
the
the
smallest
one
and
the
biggest
one
and
then
pass
it
through
to
measure
object
and
get
the
minimum
maximum
and
average
out
of
it.
Okay
have.