►
Description
Does this sound familiar? You love PowerShell because it's awesome and, with PowerShell, you can create automation to eliminate manual tasks. But... you don't love writing the documentation for your code....
Yeah, we hear you. Most people don't look forward to the documentation because it can be tedious. But what if you could AUTOMATE your documentation as well?
Join guest speaker Stephen Valdinger for a look at how you can add beautiful docs to your projects with automation. We'll look at a few simple things you can do right now to take your PowerShell documentation to the next level. By the end of this demo, you will see how easy it is to create your documentation on the fly!
Speaker Bio:
Stephen Valdinger aka Steviecoaster is a technical support engineer for Chocolatey. Stevie is one of those guys who just oozes code from his pores. He automates almost everything he works on. Stevie is a huge fan of open source and an active contributor to the PowerShell community.
About the Research Triangle PowerShell User group (RTPSUG):
The Research Triangle PowerShell Users Group (RTPSUG) is the largest PowerShell group in the world! We meet twice a month to discuss all topics related to PowerShell and automation. Our topics cover beginner to advanced concepts and offer people a chance to learn new skills and ask questions. Our mission is to create a space for all attendees to feel welcome, ask questions, and be part of a community.
For more information on our group, please visit any of following links:
WEB: https://rtpsug.com
MEETUP: https://www.meetup.com/Research-Triangle-PowerShell-Users-Group
LINKEDIN: https://www.linkedin.com/company/rtpsug/
TWITTER: https://twitter.com/rtpsug
GITHUB: https://github.com/rtpsug
A
Hey
everybody
welcome
to
another
meeting
of
the
research
triangle:
powershell
user
group.
My
name
is
mike
canakis.
Today
is
august
18th
and
tonight
we
are
welcoming
in
a
guest
host
in
absence
of
phil
bossman,
who
is
on
a
previous
engagement.
So
I'm
welcoming
in
my
son,
nico
canakas,
hey
nico.
How
are
you
tonight.
B
A
A
Stevie's
having
a
good
time
I'll,
be
here
so,
ladies
and
gentlemen,
tonight
our
guest
speaker
is
stephen
valdinger,
who
is
a
personal
friend
of
myself
and
nico,
he's
a
very
active
community
member
and
he
works
for
chocolaty
and
he's
got
some
awesome
topics
that
he
likes
to
talk
about
tonight,
you're
going
to
be
talking
about
how
to
create
autumn
documentation,
right,
correct
and
yep,
and
and
so
like
give
people
like
a
little
bit
of
an
intro
like
creating
documentation
sucks.
So
what
makes
this
different
tonight?
What's
the
gist.
B
B
A
All
right
so
you're
saying
we
use
command
line.
We
use
powershell
to
help
us
automate
tasks.
We
can
do
the
same
thing
and
try
to
figure
out
how
to
do
that
with
documentation
for
the
tasks
that
we
normally
run
exactly
cool.
So
for
those
people
in
our
audience
that
may
not
know
who
you
are.
Can
you
give
us
a
little
bit
of
your
background?
How
you
got
started
in
the
field?
What
you
usually
do
on
a
day-to-day
basis.
B
Sure
so
day
to
day,
I'm
a
solutions
engineer
at
chocolaty,
so
I
help
new
customers
and
existing
customers
with
whatever
their
problems
are
complex,
not
complex.
Maybe
they
have
an
idea.
They
need
some
help
in
implementing
that.
That's
what
I
do.
I
I
help
people
automate
the
hard
stuff
so
that
they
can
go
on
and
tackle
other
things
that
you
know.
B
A
B
A
B
I'm
going
to
go
ahead
and
share
my
screen,
I
think
yeah
there
we
go
and
I'm
going
to
do
two
things
clear
this
and
make
it
a
little
bit
bigger
a
little
bit
bigger
yeah,
that's
cool,
we're
gonna,
make
that
nice
and
big
and
we're
gonna
take
a
step
all
the
way
back
to
the
beginning
of
your
journey
with
powershell
when
you're
just
getting
started,
using
a
new
module
or
a
new
tool,
and
you
want
to
learn
how
to
use
it.
What's
the
best
way
to
do
that
in
powershell
the
get
help
commandlet.
B
This
thing
is
amazing,
right
in
your
console,
you
have
access
to
all
the
documentation
for
the
particular
command
that
you
want
to
run
in
the
case
of
what
I
want
to
show
off,
I'm
going
to
say:
git
help,
connect
nexus
server
and
it's
going
to
load
basic
help.
Information
for
me
right
here
in
in
my
console,
because
I've
defined
that
help
inside
of
my
function.
Right,
there's,
there's
this
block
of
text
at
the
top
of
the
function.
B
It's
called
comment
based
help
you
fill
that
out
and
that's
what
the
help
system
uses
to
give
you
all.
This
cool
information
and
you
can
get
really
really
detailed-
you
can
say,
get
help.
That's
full
and
it'll
give
you
the
full
contents
of
everything
in
that
comment
based
out.
So
it
gives
you
all
your
parameters,
what
their
types
are
if
they
accept
pipeline
input,
whether
they
accept
wild
cards,
some
examples,
some
syntax.
It
gives
you
all
this
really
cool
stuff
right
here
in
your
console,
but
it's
in
your
console.
B
That's
what
get
help
online
for
so
when
you
say,
get
help,
connect,
nexus
server,
dash
online
and
you
hit
enter.
You
get
a
web
browser
and
it
takes
you
to
the
online
version
of
the
documentation
where
you
can
slide
it
over
here.
Out
of
your
way,
you
can
be
in
your
console,
you
can
be
typing
away
doing
whatever
you
need
to
do
and
you
can
reference
the
documentation
over
here.
It's
not.
B
A
B
How
did
I
get
from
here
to
here
and
there's
a
couple
of
powershell
modules
and
utilities
that
you
can
use
along
the
way
that
will
enable
you
to
not
have
to
write
a
single
bit
of
markdown
or
worry
about
how
you
use
this
thing
and
build
this
system?
It's
just
all
done
for
you
and
I've
got
a
github
repo
called
beautiful
docs,
and
if
we
open
up
this
web
browser
over
here,
I'm
going
to
close
this
out
and
go
here.
B
B
It
opens
it
up
and
code
space
is
right
in
your
browser.
You
get
vs
code,
so
you
don't
have
to
worry
about
being
somewhere
else.
Super
super
nice
to
be
able
to
really
quickly
make
a
change
and
commit
it
right
to
your
repo
right
in
the
browser
and
have
the
same
experience.
You
would
do
locally
super
super
nice.
B
B
So
if
we
look
at
this
over
here
in
the
left-hand
side,
we've
got
a
docs
folder,
there's
an
index.md
in
here,
that's
the
the
home
page
for
this
particular
module.
So
when
you
go
to
the
doc
site,
this
is
what
will
be
on
on
that
home
page
in
this
make
docs
template.
Folder
is
a
yaml
file
that
the
utility
make
docs
uses
to
configure
and
know
where
the
documentation
is
and
all
that
good
stuff.
B
This
is
a
configuration
file
for
that
application
and
make
docs
is
the
thing
that
is
what's
building
that
static
website,
where
all
that
documentation,
lives
and
and
hosts
all
that
on
github
pages
for
you.
So
it's
it's
really
really.
Nice
really
really
easy
to
use
and
we're
going
to
walk
through
it
step
by
step.
B
As
we
go
through
this
talk,
and
if
we
look
at
my
source
directory,
I've
got
a
really
really
really
simple:
powershell
module
that
I've
put
together.
I've
got
a
psd1
file
which
is
kind
of
boilerplate.
It's
it's
really
bare
bones,
because
my
build
pipeline
takes
care
of
putting
it
all
together
for
me,
but
this
is
enough
information
for
my
pipeline
to
take
it
and
update
it
and
make
it
correct,
and
then
in
my
public
folder
is
where
all
of
the
functions
for
this
module
live.
B
So
I
just
pulled
a
couple
of
functions
that
I
have
out
on
my
gist
site
and
moved
them
inside
of
here.
So
I've
got
a
function
called
opengit
repo
has
a
parameter
process
block.
You
know
typical
function.
What
makes
all
the
magic
happen
is
this
section
right
here?
This
is
comment
based
help
inside
of
powershell
and
if
you've
got
a
function
written-
and
you
don't
have
this
in
it-
you're
not
done
yet.
I'm
sorry,
but
that's
just
the
way.
B
It
is
you're
not
done
until
you
have
this,
because
if
you
give
something
a
script
to
an
end
user
and
it
doesn't
have
instructions
with
it
on
how
to
use
it,
they're
not
going
to
use
it.
That's
just
fact:
that's
how
it
is
everywhere.
If
you
go
to
github
and
you
go
to
a
project
and
you
look
on
there
and
there's
no
documentation,
no
examples
on
how
to
use
the
thing.
What
do
you
do
you
leave
that
repository
and
go
find
another
project
that
has
better
documentation,
so
you
can
get
started
with
it.
A
B
A
A
Good
got
a
question
for
you,
so
you're,
starting
with
a
module
right,
so
so
a
person
that's
getting
started
with
comment
based
help
and
they're,
adding
it
to
their
functions
right.
So
what
happens
if
they
haven't
gotten
to
the
module
stage
yet,
and
they
just
have
a
loose
array
of
functions?
Can
they
can
they
follow.
A
B
A
Fine,
and
and
for
the
people
that
are
watching
that
have
a
handful
of
functions
and
haven't
created
a
module.
Yet
a
module
is
not
that
challenging
to
make
at
least
the
basics
of
it,
and
what
a
module
is
going
to.
Allow
you
to
do
is
to
be
able
to
make
your
code
portable
and
make
it
easy
to
install
with
one
simple
command
line.
B
B
B
Whatever
you
want,
and
then
you
can
hit
tab
and
I
have
code
that
new
code
lens
thing
turned
on,
so
it
does
weird
things,
but
you
can
type
through
every
section
and
do
what
you
need
to
do,
and
you
can
you
know
tab
down,
shift
tab
to
go
back
up
all
that
good
stuff,
but
it
makes
it
really
easy
to
add
that
comment
based
out
you
don't
have
to
worry
about
knowing
what
the
syntax
for
synopsis
description
parameter.
All
that
stuff
really
is
just
hit.
B
Pound,
pound
and
vs
code
will
put
it
in
there
for
you
and
then
you
can
just
tab
through
it
and
fill
it
out
and
if
you've
got
something
with
like
900
parameters.
You'll
have
900
parameters
in
your
comment.
Base
help
it'll
grab
every
parameter
so
that
you
can
document
it
super
super
helpful.
I
I
like
it
a
lot.
I
think
that's
probably
one
of
my
favorite
features
of
vs
code
is
it's
just
some
of
the
snippets
that
it
has
to
make
your
life
a
little
bit
easier.
B
B
Because
we're
not
going
to
use
it,
let's
save
this
pipeline,
so
I've
got
it.
I've
got
the
pipeline
in
two
flavors.
I've
got
the
gui
version
here
that
I've
built
so
that
I
can
walk
through
it
and
talk
about
it,
and
then
I've
also
got
it
in
pipeline
form
which
is
available
in
that
repo.
So
you
can
just
copy
this
gamble
and
have
a
template
that
you
can
use
in
your
own
azure
devops
instances,
and
I've
also
got
one
there's
a
yaml
file
in
that
repo
for
github
actions
as
well.
B
So
to
do
some
of
the
work
of
creating
my
module,
I'm
using
module
builder-
I
don't
know
if
everybody
knows
who
jacob
is
jayco
on
twitter
or
in
the
powershell
slack
and
discord
super
smart
guy.
He
wrote
this
thing,
which
makes
it
really
easy
to
glue
together
a
module
with
just
a
simver
type
notation.
So
it's
it's
really
really
cool
and
makes
it
really
quick
and
easy
to
build
a
module
with
it.
B
So
I'm
installing
the
module
builder
module
onto
this
hosted
agent,
and
then
I
need
a
couple
of
additional
things
so
that
I
can
start
building
my
documentation
and
I'm
going
to
leverage
chocolatey
for
that,
because
I'd
get
in
trouble.
If
I
didn't
right
so
I
need
a
couple
of
things.
I
need
git
version,
which
is
a
really
cool
tool
that
inspects
the
history
of
a
particular
branch.
B
So
when
your
pipeline
checks
out
your
code,
git
version
analyzes
all
the
commits
and
everything
based
off
of
that
checkout
and
tries
to
be
smart
and
analyze,
things
that
end
analyze,
what
the
semantic
version
of
the
module
should
be
now
there
are
ways
that
you
can
control
it
through
config
and
all
that
good
stuff
and
also
through
tagging
things.
So
if
you
tag
a
particular
branch
at
version
0.1.1
for
example,
and
then
push
that
tag
onto
the
branch,
git
version
is
going
to
assert
the
version
for
the
tag.
B
Now
that's
getting
kind
of
into
the
weeds
and
outside
of
the
scope
of
the
talk,
but
that's
what
git
version
does
it
just
determines
what
the
version
of
the
module
should
be,
so
that
the
rest
of
your
build
pipeline
can
reference
that
version,
and
you
don't
have
to
even
worry
about
versioning
your
module
anymore
either.
Let
your
build
pipeline
do
that
for
you,
so
we
get
git
version.
B
So
it's
all
really
really
slick
once
you
get
it
all
glued
together
and
because
the
powershell
gallery
was
down.
While
I
was
building
my
talk,
we
happened
to
have
the
platypus
module
up
on
the
community
repository,
so
failed
myself
out
of
gene
next
step
is
just
setting
up
git
version.
This
is
just
saying
hey
what
what
version
of
git
version
should
I
install?
I
want
the
latest
5.x
branch,
and
then
I
determine
the
symbor
with
the
git
version
yaml
file
that
is
stored
inside
of
the
repository
there's,
nothing
interesting
in
it.
B
We're
not
gonna
we're,
not
gonna
dive
into
that
next
step.
Let's
build
a
module
at
whatever
version.
Git
version
tells
me
it
should
be.
So
that's
what
this
step
does
that
generates
my
module
for
me
after
I
do
that
and
I
have
that
module.
I
publish
it
to
the
pipeline
artifacts
feed
so
that
I
can
go
in
and
download
it
and
it
and
inspect
it
later.
B
B
B
B
Stuff
so
yeah
on
zero.
Fourteen
two
now,
where
was
I
at
so
this
build
script,
is
really
simple:
it's
a
build.ps1
with
a
bunch
of
switches
and,
depending
on
what
switch
you
use,
is
what
code
gets
executed.
It's
a
really
really
rudimentary
stolen
from
josh
king
way
of
doing
stuff
inside
of
a
pipeline.
B
So
I
say
the
root,
which
is
the
root
of
the
repository
into
the
docs
folder,
so
platypus
when
new
markdown
help
runs
it's
going
to
look
at
all
the
commands
inside
of
this
module
and
read
their
comment
based
help
and
generate
a
markdown
file
for
that
comment-based
help,
and
I
think
let
me
see,
does
it
have
it.
I
can't
make
this
very
much
bigger
than
what
it
is
now,
but
let
me
see
if
I
have
it
in.
B
B
Didn't
save
it,
so
no,
I
don't
have
the
I
don't
have
the
actual
docs
they
just.
They
don't
exist
on
the
root
of
your
repo,
which
is
kind
of
the
point.
You
don't
really
want
your
reference
docs
to
live
with
your
code.
You
want
them
to
live
separate
and
that's
what
make
docs
actually
does
and
how
it
works,
and
we'll
talk
about
that
once
we
get
to
that
point.
B
So
you
could
absolutely
say
new
markdown
help
dash
command
and
give
it
whatever
you
want.
So
in
this
example,
you
could
say
like
open,
git
repo,
for
example,
and
say
the
output
folder
is
the
same
thing:
root
docs
whatever
now
that
that
means
that
that
command
has
to
be
available
in
the
running
session
when
you
run
this
command
for
to
work.
So
if
you've
got
like
a
file
share
or
something
like
that
say,
I've
got
get
child
item.
B
B
A
Okay,
so
I'm
going
to
blow
up
your
demo
here
for
a
second,
because
because
you're
doing
awesome
right-
and
I
love
what
you're
doing,
but
I
have
a
feeling
that
there's
more
than
a
handful
of
people
that
are
going
to
be
watching
this
at
home,
that
aren't
coming
in
through
our
powershell
user
group
that
are
like
whoa.
He
hit
a
lot
of
stuff
there
that
I'm
not
necessarily
familiar
with.
So
what
you're
showing
here
is
how
to
fire
off
and
build
comments.
A
Common
comment
based
health,
correct
markdown
files
from
the
comment
based
help
using
the
platypus
module
using
the
new
markdown
command
right.
Okay,
so
that's
the
platypus
module.
There
was
also
another
module
import
import
module
builder,
which
you
talked
about,
which
was
from
jakel,
joel
bennett
right
and
we
just
kind
of
grazed
on
that,
and
then
you
also
mentioned
pipelines
and
azure
devops,
and
for
someone
like
when
we
started
with
the
new
hey.
This
is
comment
based
help
and
then
we
fire
up
a
pipeline.
There's
going
to
be
some
people
that
are
like
whoa.
A
So
maybe,
when
you
get
to
a
point,
I
would
love
to
see
a
way
to
build
what
you're
going
to
show
without
a
pipeline
if
they
want
to
run
on
their
machine
in
manual
scripts
with
the
modules
so
sure
we
could
do
that
later.
But
just
in
case
people
don't
understand
how
azure
devops
works
and
a
pipeline
and
calling
scripts
right,
yeah
sure.
A
I
saw
that-
and
I
was
going
to
mention
it
for
the
people
at
home-
they're
not
going
to
see
the
chat
but
the
so
the
reason
I
was
asking
stevie
for
that
was
because
the
platypus
stuff,
I
think,
is
straightforward
for
most
people
right
what
stevie
was
just
showing
on
the
screen
was
a
bunch
of
markdown
files
that
were
generated
from
scripts.
That
are,
I
hope,
everybody's
familiar
with
markdown.
That's
very
plain
text
code
that
can
be
interpreted
into
a
standard
layout
right.
So
then
you're
going
to
have
your
markdown
files.
A
What
I'm
saying
is
people
probably
didn't
understand
the
github,
the
azure
devops
pipeline,
where
he
had
like
four
scripts
in
a
row.
So
all
I'm
saying
stevie
is,
if
you
get
a
chance,
let's
just
walk
back
and
go
through
those
kind
of
steps
at
some
point
when
it
makes
sense
for
you,
because
I
could
just
imagine
someone
going
to
devops.
A
B
Break
it
we'll
break
it
down
a
little
bit,
but
just
to
show
you,
since
we
were
just
mentioning
a
plot
aps,
just
or
platypus
just
went
through
and
created
all
these
markdown
files,
here's
one
of
the
markdown
files
that
it
just
created.
So
it
takes
all
that
stuff
in
the
comment
based
help
and
literally
turns
it
into
markdown.
B
B
Do
you
care
so
much
when
you
just
want
it
automatically
generated
to
be
that
pedantic
about
things
probably
not
doesn't
really
matter?
It
still
looks
great
on
the
website,
but
if
you
are
a
little
bit
ocd
about
things,
that
is
something
that
we'll
be
aware
of
with
platypus,
that
it
does
break
some
of
the
newer,
more
downlinting
rules.
B
B
An
open
source
tool
right
yeah,
absolutely
absolutely
so
you
can
go
to
make
dogs
their
website.
Their
getting
started
guide
is
pretty
awesome,
creating
a
project
all
that
good
stuff.
If
you
do
this
make
doc's
new
my
project,
it
just
generates
a
cmo
file
and
some
other
boilerplate
stuff.
So
you
don't
really
have
to
run
that,
like
I
didn't
run
that
here.
In
this
instance,
I
just
created
a
make
docs.yaml
file
and
added
what
I
needed
into
it.
B
But
if
you
are
just
getting
started,
just
follow
the
get
starting
guide
and
say:
hey.
How
do
you
install
this
thing?
Let's
create
a
new
project.
It'll
walk
you
through
all
that
thing
all
that
stuff.
It's
got
a
really
cool
thing
in
it
called
mcdoc
serve,
which
starts
up
a
little
mini
web
server
and
allows
you
to
go
to
this
website
locally
on
your
box
to
see
what
your
docs
are.
Gonna
look
like
before
you
publish
them
anywhere,
which
is
kind
of
really
really
cool.
Actually.
B
On
my
machine
now,
obviously
the
only
thing
I
have
in
my
documents:
folder
right
now
is
my
index
because
I
haven't
generated
with
platypus.
There's
nothing
else
in
that
docs
folder.
So
I
just
get
this,
but
that's
really
as
simple
as
it
is
to
get
started
with
make
docs
you
say:
make
docs
create
whatever
your
project
name
is.
B
B
B
B
B
If
you've
already,
you
know
you,
you
use
git
in
your
terminal,
all
the
time.
Anyways
you've
got
your
your
pat
or
your
whatever
authentication
method.
You're
using
to
push
already
to
your
repository
make
docs
is
just
going
to
use
that
same
stuff.
It's
just
going
to
use
your
your
get
configurations.
It's
on
your
machine
to
make
this
github
deploy
thing
work
where
it.
A
A
B
B
B
Happen
for
me,
as
the
latest
verb.
Well,
I
can
see
your
point.
There
would
be
a
little
bit
more
work
to
ensure
that
the
versioning
happens.
So,
ideally,
what
you
would
do
is
in
your
build
step
when
you're
building
the
module
and
you're
asserting
this
version
in
your
platypus
step
in
here
once
we
get
to
the
right
make
that
right
make
doc
section
here.
B
B
B
B
Go
to
my
stevie
coaster,
dot,
dev
domain.
So
if
you
go
to
stevencoaster.beautifuldocs
you'll
get
the
documentation
for
this
module.
If
you
go
to
steviecoster.com,
I
think
it's
yeah,
I'm
pretty
sure
it's
nexus,
0
you'll
get
the
documentation
for
that
module
so
on
and
so
forth
makes
it
nice
and
consistent
for
me
to
just
have
everything
kind
of
on
brand.
I
guess
so.
I
have
vanity
vanity
url
set
up
for
github.
B
B
B
B
So,
let's
grab
this
open,
git
repo
url
for
a
second,
so
there's
a
couple
different
ways:
you
can
do
it.
You
can
do
it
in
the
comment
base,
help
with
that
link
and
just
paste
the
link
here
or
the
I
think,
the
better
way.
At
least
I
think
it
it's.
The
better
way
is
to
go
to
help
in
your
command
binding
and
go
help.
Uri
equals.
B
B
A
B
A
B
B
B
B
B
A
So
it's
like
well
while
you're
looking
for
that.
Let's
talk
that
through
because
that's
what
I
was
interested
in
before
so
the
basic
pieces
of
what
we've
been
talking
about
tonight
is
step.
One
is
you
got
to
make
some
comment
based
help?
That's
just
a
no-brainer,
that's
where
we
start
and
then
you're
going
to
use
platypus
to
generate
markdown
files
from
the
comment-based
help
and
then
we're
moving
on
to
use
other
tools
to
publish
those
markdown
files
into
the
make
the
docs
website.
So
we
can
skip
the
pipeline
and
we
can
go
to
individual
scripts.
A
B
B
B
B
B
B
To
get
it
all
working,
I
can
throw
what
I'll
do
for
everybody
here
and
everybody
that's
going
to
watch
the
video
in
the
future
check
the
the
repository
I'll
put
a
powershell
script
inside
of
there.
That's
a
really
simple,
hey
here's
step,
one!
Here's
step,
two,
here's
step
three
kind
of
thing
to
walk
you
through
doing
it
outside
of
a
pipeline
as
well.
A
B
A
B
A
B
B
Works
yeah
and
that's
how
it
works,
but
that's
all
you
have
to
think
about.
The
only
thing
you
should
have
to
think
about
is
your
comment
based
help
inside
of
your
script
and
because
your
script
isn't
done
until
you
have
it,
you
should
never
run
into
the
situation
where
you
can't
do
something
like
this.
B
B
That
will
kind
of
change
things
in
here,
because
I'm
referencing
paths
and
things
like
that.
That
might
be
different
for
you,
so
you
might
have
to
tweak
some
things,
but
by
and
large,
if
you
take
this
gamel
and
plug
it
into
an
azure
devops
pipeline
and
just
go
over
it
with
a
fine-tooth
comb
and
change
paths
and
things
like
that
and
hit
run,
you
should
have
documentation
for
your
module
at
the
end
of
that
run.
A
So
we'll
be
going
over
how
to
instantiate
your
first
pipeline,
how
to
pull
in
code
from
a
repository,
how
to
push
that
code
either
to
an
on-prem
server
or
up
into
the
cloud
and
we'll
go
through
those
steps
in
a
slow,
build
up
fashion,
so
that
you
can
understand
what
stevie's
doing
here.
So
you
don't
have
to
look
at
the
console
and
say:
oh,
my
god.
I
have
no
idea
what
he
did
and
to
be
fair,
the
same
logic
or
the
same
sort
of
structure.
You
can
do
with
a
jenkins
pipeline,
a
get
github
actions.
B
Yeah
yeah
and
it
can
be
a
straight
up,
powershell
script
too.
I
mean
I
I'll
I'll
put
one
of
those
in
the
repel.
So
if
you're
watching
the
recording
on
youtube,
hi
everybody
go
to
the
repo,
there
will
be
a
script
in
there
that
will
mimic
what
the
pipeline's
doing
just
hey
run.
This
thing
and
you're
done.
B
B
The
documentation
anymore,
it
can
just
happen.
It's
beautiful.
I
just
recently
discovered
big
docs,
so
I've
been
playing
with
it
for
a
couple
of
weeks.
Now
is
all
I've
all
I've
been
playing
with
it,
but
I
need
to
go
back
through
a
couple
of
my
old
modules
now
and
wire
this
stuff
up
for
the
rest
of
it,
spend
some
time
and
tweak
things
and
get
things
working.
The
way
I
want,
but
yeah
I'm.
I
want
to
do
this
to
all
of
my
modules
now
that
I've
discovered
this
tool.
A
Speaking
of
old
modules
in
this
process
is
there
anything
that
would
be
useful
in
terms
of
highlighting
so
let's
say,
you've
got
ten
functions
and
five
of
them
have
great
help
sections
the
other
five.
Don't
is
there
anything
here
that
would
point
that
out
or
do
you
need
to
fall
back
to
like
script,
analyzer.
B
B
A
So
if
you're
going
to
write,
functions
and
you're
going
to
publish
a
module,
you
really
shouldn't
have
to
need
a
pipeline
to
remind
you
to
complete
your
help
at
the
time
that
you're
publishing
stuff
you
shouldn't
be
making
a
module
without
help
right.
So
green.
It's
a
it's
a
valid
point
and
I
understand
what
we're
talking
about
and
there's
nothing
wrong
with
it.
But
we
really
need
to
drive
home
the
fact
that
you're
not
ready
to
publish
a
module
until
you've
created
help
files
for
the
functions
not
create
the
functions,
make
a
module.
A
Oh,
let's
go
back
and
fill
in
the
help
that
I'm
missing,
because
that's
how
you
get
into
whole
into
trouble
now.
I
know
the
guys
have
blown
me
up
on
chat
already
because,
like
everybody
does
that,
but
these
are
the
habits
that
we
that
we
make
that
cause
us
grief
in
the
future
right.
So
we
have
to
stop
and
leave
time
to
make
help
part
of
the
process
of
building
the
module,
not
an
afterthought
afterwards.
B
A
B
B
A
A
Oh,
I
didn't
I
forgot
about
that
right,
so
it's
just
got
to
become
and
and
then
and
I
I
go
back
to
a
little
bit-
I
think
maybe
jeff
hicks
who
and
another
presentation
was
saying
he
usually
starts
his
functions
by
writing
his
help,
because
that
designs,
that
you
know
that
sort
of
defines
this
idea
of
what
he
was
looking
for
it
to
do
exactly
right
and
then
he
writes
the
code
to
match
the
help,
because
the
help
is
really
this.
The
scaffolding
that
told
him.
This
is
what
I
expect
my
function
to
do
right.
A
A
I
think
putting
this
into
the
pipeline
is
the
trust
but
verify
ask
action
of
sitting
down
and
saying:
hey.
I've
got
a
module
out
there.
I'm
I
am
taking
people's
pull,
pull
pull
requests
and
you
need
to
have
help
in
it
and
if
there
isn't
help
in
it,
then
the
build
dies.
Let's
you
guys
are
all
100
right.
A
I'm
not
saying
don't
do
this,
I'm
just
saying,
as
as
people
who
write
code-
and
maybe
you
are
the
person
who
represents
sort
of
like
pushing
new
ideas
forward
at
your
company,
we
really
should
be
putting
forth
the
idea
that
the
help
comes
with
the
code,
not
use
the
code
and
three
weeks
later,
I
get
around
to
writing
the
help
file
right,
so
it
just
becomes.
You
just
need
to
enforce
that
idea.
I
I
mean
I
I've
heard
stephen
fox
mention
in
a
in
a
demo.
He
did
for
chattanooga
two
years
ago.
A
He
started
a
new
company,
that's
very
devops
oriented
and
they
don't
accept
code
pulls
unless
it
has
a
pester
test
right,
that's
not
complete,
so
it's
just
a
thought
process
that
you
put
forward
right.
If
you're
going
to
build
functions,
you
build
help
to
go
with
those
functions
because
I
think
help
in
a
function
or
if
you
don't
have
help
in
a
module.
How
do
you
expect
people
to
figure
out
what
exactly
your
function
does?
A
Well,
you
kind
of
beat
me
to
it,
because
what
I
was
going
to
say
is
the
reason
you
most
likely
built
the
function
and
the
module
is
to
make
it
portable,
so
either
you
can
install
it
on
different
machines
or
you
can
give
it
to
other
people.
So
the
help
really
should
be
part
and
parcel
of
that
work,
and
I
will
get
off
my
soapbox.
I'm
sorry
well,
there's
enough
times
that
I've
looked
at
modules,
even
at
microsoft,
where
it's
along
the
lines
of
yup.
They
have
help.
They
have
the
bare
basic
help.
B
I'm
I'm
good.
I
I'm
good.
I've
shown
you
everything
I
wanted
to
show
you.
We've
talked
about
everything.
I've
wanted
to
talk
about,
I'm
open
for
questions.
We
can
go
off
on
tangents.
We
can
do
whatever
we
want
at
this
point,
but
I've
shown
you
how
to
publish
documentation
without
thinking
about
it.
Mission
accomplished.
A
All
right
so
with
that
we're
going
to
say,
first
of
all,
thank
you
stevie,
because
this
was
a
lot
of
fun.
I
like
this.
I
I
walk
away
from
this
feeling
like
I
can
go
back
to
work
tomorrow
or
next
week
and
I
probably
can
publish
some
help
pretty
quickly.
You
know
maybe
another
half
hour
of
just
farting
around
with
some
different
scripts
and
figuring
out.
A
How
to
do
it
so
makes
me
feel
like
I
can
get
something
useful
done
quickly
and
that's
probably
the
big
reason
why
people
don't
get
the
help
done
to
start,
because
it
feels
like
it's
an
arduous
task,
so
dude
awesome
job
tonight,
as
always.
Thank
you
so
much
for
presenting
for
us.
I
really
love
what
you
did
tonight.
Thank
you.
A
All
right
so
with
that
we're
going
to
wrap
this
one
up
if
you're
watching
this
on
youtube-
and
you
made
it
this
far
thanks
for
sticking
with
us,
we're
gonna,
we're
gonna,
make
some
suggestions
to
you
now
and
some
other
things
that
might
be
useful
for
you,
so
make
sure
you
visit
our
channel
and
check
out
all
of
our
content.
We
have
about
100
videos
of
content,
just
like
stevie's
tonight.
If
you're
not
familiar
with
the
group,
you
can
join
us
live
on
any
wednesday.