►
From YouTube: .NET Design Review: System.CommandLine
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
B
Do
an
introduction:
there
has
been
a
certain
amount,
I
think
of
the
confusion
and
lack
of
information
that
we've
shared
on
this
and
so
I
think
it's
gonna
really
help
if
initially
I
give
a
little
bit
of
an
overview
and
then
I'm
gonna
turn
it
over
to
John,
and
hopefully
we
have
what
you
want.
Emo's
out,
we
didn't
have
a
chance
to
ask
many
questions
about
what
was
most
useful
in
this
room
today.
B
C
B
A
B
Right,
okay,
so
at
any
rate,
I'll
try
to
keep
this
fairly
short,
but
I
wanted
to
start
with
the
most
basic
passion
we
have
about
this
project,
which
is
that
authors
of
anything
command
line
either
infant
or
output?
Anything
should
not
have
to
work
very
hard
to
give
this
fantastic
user
experience
to
their
end
user.
B
Our
users,
not
the
potentially
tens
of
thousands
of
people
that
might
ever
use
the
be,
is
it
from
an
operating
point
where
our
passion
is
ultimately
around
the
millions
of
people
that
may
be
able
to
use
that
so
I'm
going
to
talk
about
the
authoring
experience
today,
but
I
think
it's
helpful
to
understand
that
our
real
passion
goes
one
step.
You
know
on
that,
and
the
second
thing
is
we're
going
to
talk
about
parsing
today,
but
in
some,
what
it
is,
the
most
grown-up,
it's
the
one
ready
to
go.
B
However,
we
think
it's
also
one
of
the
not
most
important.
We
think
the
most
important
part
of
this
is
opening
of
18100
and
some
better
abstractions
across
the
output
side
of
it.
The
rendering
the
terminal
side
system
consoles
pretty
weak
on
some
stuff
on
that
and
we
are
working
across
the
code
and
that
is
terminal
and
on
all
of
this,
especially
on
the
rendering
side
we
are.
B
We
are
part
of
an
ecosystem
and
we
are
very
much
interested
in
solving
it
from
an
ecosystem
point
of
view
and
there's
been
some
people
that
have
misunderstood
that
and
I
like
to
make
sure
that
we
sort
of
get
that
off
the
table.
We
are,
and
you
want
to
go
to
or
notice
that
that's
kind
of
look
through
this.
That's
our
passion-
and
this
is
some
of
the
areas
that
were
working
in
so.
G
B
H
So
I
think
the
the
short
version
there
is
that
system
that
console
has
not
it
wasn't
originally
designed
to
work
on
on
virtual
terminal
is
an
automatic
Samar
and
what's
in
place.
Now
is
a
bit
of
a
shim
and
it
breaks
down
in
a
few
places.
The
abstraction
is
kind
of
hard
to
use
in
some
cases,
because
if
you
want
to
write
output
and
console
app
on
has
been
redirected,
the
expectation
is
you're
writing
to
plain
text
non
UTS
output.
You
give
a
the.
C
H
Practice,
though,
with
virtual
terminals
and
in
the
Mac
and
Linux
world,
you're,
probably
right
into
a
to
a
terminal
that
understands
is
that
way,
and
these
mixed
modes
there's
no
programming
model
really
to
understand
what
mode
you're
in
to
understand
what
kind
of
terminal
your
home
and
whether
output
has
been
redirected.
It's
always
up
to
the
end-user
to
figure
this
out
so
things
that
are
fairly
common
gestures.
Terminal
usage,
such
as
redirect
the
output
will
blow
up
a
lot
of
kinds
of
command
line
as
well.
H
You
know
if
I
mean,
if
I,
if
I
read,
if
I
have
a
d'oeuvre
directory
application
that
is
gonna
write,
output,
I
want
it
to
be
ANSI
enabled,
but
then
I
go
in
redirect
output,
even
if
I've
correctly
detected,
that
I've
put
is
redirected,
I'm
likely
to
spit
a
whole
bunch
of
ansi
escape
characters
into
a
file
which
is
ultimately
managed.
So
these
are
the
kinds
of
problems
that
exist
in
the
space.
H
B
From
a
p.m.
point
of
view,
it
would
have
been
I
want
that
to
be
blue
and
I,
don't
want
to
have
to
tell
you
how
to
make
it
work.
So
that's
another
level
at
which,
where
we're
looking
at
this
so
I
want
to
go
on
past
console,
but
I
wanted
to
talk
about.
That
is
the
fact
that
we
actually
see
this
as
a
super
important
place
in
the
future.
The
structure
of
this
project
has
been
to
be
open
source.
B
It's
been
a
side
project
almost
exclusively
and
the
beginning
of
that
I
think
it's
worth
it's
worth
mentioning.
So,
first
of
all
there
there
had
people
have
implied
that
we
didn't
look
at
other
other
parsers
and
that's
simply
not
true.
So
we
did
look
at
other
parsers.
We
did
find
some
real
and
we'll
talk
about
why
we
think
that
that
the
approach
that
we're
taking
is
important.
B
standing
on
stage
didn't
understand
all
the
details
couldn't
have
given
a
good
answer,
even
if
I
wanted
to,
and
it
was
time
to
go
on
and
mark
Nicholas
raised
his
hand,
and
he
said
many
of
you
know,
mark
Michaelis
and
he
said
in
great
mark
Michaelis
very
shortened
to
the
point
fashion.
He
said,
please
don't
write
another
commandant,
parser
and
I
said
feedback
taken,
went
on
the
discussion
afterwards,
John
walked
up
to
it.
Spent
five
minutes.
Talking
to
us,
yeah
mark
walked
up
to
me
and
he
said.
B
Not
only
should
you
do
this,
I
will
help
you
find
a
team,
and
so
mark
has
been
our
external
sponsor
through
in
Chinese
company
Intel
attack.
He
has
brought
us
devs.
You
know
open-source
steps,
people
that
volunteered
he
has
co-sponsored
the
two
or
three
three
hackathon
three
thoughts
that
we
did
that
were
very
important
in
standing
direction.
We
got
some
code
written,
but
the
really
important
thing
is
that
helped
us
Honea
three
members
of
the
community
that
were
a
total
of
people
who
have
contributed
to
this.
Do
a
hackathon
or
not
is
50.
A
B
50,
so
we
have
very
much
been.
We
have
reached
out
at
that
level,
not
so
much
to
always
to
experts.
People
will
actually
be
users,
although
Nate
McMaster
was
also
important
at
the
beginning,
part
of
this
we'd
reached
out
to
him.
He
also
agreed
that
we
wanted
to
take
a
step
forward.
There's
been
some
changes
since
then,
and
how
he's
supporting
his
stole
and
we
want
to
work
with
them
and
what
he's
doing
as
well
as
everybody
there.
B
So
we
can
I,
don't
want
to
feel
defensive
about
that,
but
I
also
believe
it's
really
important
to
lay
that
as
a
groundwork
that
we
absolutely
want
to
work
inside
the
community,
and
if
we
can't
convince
you
that
we
are
doing
interesting
things
that
other
parsers
aren't,
then
that's
a
different
conversation
that
I
really
want
to
start
with
that
to
have
an
open
mind
here,
so
you
can
scroll
it
up
because
we're
saying
down
to
market
chaos
and
we
put
mark
McAllister
plot
okay.
So
the
big
thing
that's
missing
is
a
syntax
abstraction.
B
Many
of
the
parsers
that
people
have
written
have
been
written.
I
need
to
get
something
done
they
effectively
because
of
that
written
from
the
outside
in
this
is
what
I
want.
This
is
how
it
accomplished
it.
It
has
been
access
to
resources
that
have
written
five
on
your
part.
How
many
parsers
have
you
written
in
dotnet
three
tools
using
how.
I
B
Actual
parsers,
like
that
the.net
parser,
the
other
parsers,
this
is
long
histories.
My
point
is
that
we
have
written
a
lot
of
parsers
in
this
building
and
we
were
drawn
on
that
we're
saying:
okay,
you
know,
there's
some
things.
We
got
right
and
some
things
we
got
wrong
and
I
started
into
this
because
for
dotnet
tools,
I
went
in
I
tried
to
create
something.
I
said
what
parser
should
I
use.
Somebody
suggested:
I
use
the
one
in
the
dotnet
CLI
I
went
in
I.
B
Looked
at
that
I
said
it's
completely
unusable
and
I
went
through
my
process
of
going
through
several
quarters.
So
a
couple
things
right
now,
just
it
is
later
the
API
we're
going
to
show
you
is
intended
to
sit
under
app
models
and
many
people
will
use
app
models.
Our
proof
of
concept
is
dragon
free,
although
we
think
there's
a
long
way
together
after
that.
So
just
a
few
features
I.
Don't
think
these
are
really
the
core
of
this
this,
but
the
point
is:
can
you
scroll
down?
B
So
we
can
see
all
the
pictures
like
that
yeah
this
whole
section
right
here
yeah.
So
some
things
are
expected.
Some
things
are
sometimes
occur
in
other
parsers,
but
because
our
passion
is
about
that
end
user,
this
is
users
are
non
options.
This
is
our
can't
do.
Without
is
these
things
right
in
here,
so
you
write
a
parser.
You
have
help.
You
write
a
parser.
You
have
tab
completion
suggestions,
there's
a
small
asterisks
on
that,
because
you
still
have
to
get
it
into
the
shell.
B
The
end
user
always
has
to
get
it
into
the
show,
but
for
system
command
line
you
get
into
the
show
once
and
then
all
system,
family
and
applications
feed
through
that,
and
so
it's
not
once
for
every
command
line
app
it's
once
period,
and
that
is
a
protocol
we'd
like
to
share.
So
we
hope
that's
going
to
go
beyond
that.
Linux
POSIX
for
the
up
/,
or
all
that
we're
working
to
make
that
as
little
as
possible.
They
that's
little
as
possible
through
the
point
of
view.
B
The
author
one
thing
I'm
missing
here
that
we're
not
saying
is
that
there's
certain
things
that
the
end-user
should
define,
not
the
author
and
so
there's
various
things
along
that
line.
Getting
that
more
on
the
rendering
side,
so
there's
things
about
how
rich
the
output
should
be
is
one
of
the
things
that
would
be
on
from
the
point
of
view
of
the
end-user,
not
the
point
of
the
unit
author,
so
we've
got
some
things
that
are
for
authors.
This
is
some
of
the
places
we're
going.
B
This
is
really
important
to
us
both
giving
and
vision-impaired,
but
we're
set
up
for
that.
This
is
basically
saying
that
we
can't
output
your
definition
or
your
parse
result
and
whatever
format
you
want,
and
so
what's
important,
is
that
we'd
be
able
to
take
that
definition
and
put
it
out
for
jaws,
2
or
whatever
reader
support
we're
trying
to
do
and
we're
not
going
to
do
anything
like
big
we're
just
going
to
give
the
output
that's
needed
for
a
reader
to
be
able
to
fully
support
this.
B
B
G
D
G
A
A
G
A
That's
I
think
I
think
what
Kathleen
is
saying
to
put
to
most
people
immutable
mean
like
sorry
for
most
people,
individual
means.
It
is
raft
at
the
platform,
kids
and
exclusively
raft
at
the
platform.
Kids
right,
that's
and
I
think
that's
usually
because
things
live
in
column
and
we
can't
ship
them
independently,
but
the
immutable
they
basically
have
the
option
to
version
it
independently
if
we
have
to,
but
practically
speaking,
if
you
do
plan
your
project,
it's
already
late
for
that.
So.
B
B
B
H
Unfortunately,
and
some
of
those
involved,
things
like
forwarding
and
transforming
arguments
with
validation
in
between,
as
we
forward
arguments
to
msbuild
and
to
vs
test,
we
want
to
validate
from
the
floor
pass
in
the
mouth
accessibility
problem.
One
of
one
of
the
reasons
why
this
was
difficult
is
because
there
were
no
core
syntax
models
that
were
inspectable
after
parsing,
and
there
were
another
thing
that
was
kind
of
a
missing
piece.
Was
the
ability
to
actually
tokenize
most
parsers?
Don't
have
the
ability
to
Ho
tokenize?
H
They
sort
of
trust
that
things
we
pre
tokenized
by
the
time
main
is
invoked.
So
we
said:
well,
if
you
wanna,
be
able
to
just
do
a
pure
parse
straining
book
and
have
the
tokenization
be
corrected
and
understand
that
it's
in
fact
a
model.
There
were
a
bunch
of
other
things.
We
could
then
do
with
that.
H
This
is
a
big
place
for
most
developers.
Don't
have
the
time
or
energy
or
expertise
to
go
and
build
these
scripts
once
for
each
different
shell
and
make
sure
they
work
cross-platform,
which
is
why
tab-completion
tends
to
be
only
seen
a
very
small
number
of
command
line.
Absolutely
said,
how
can
we
general
has
some
of
these
capabilities,
so
we
took
that
parser
work
and
started,
and
that's
that's
the
thing
that
was
the
pitch
to
mark
michaelis
a
couple
of
years
ago.
At
the
end,
you
can
sum
up.
These
are
capabilities.
H
Well,
we
want
to
bring
to
an
end
user,
but
the
API
that
we
have
where
I
wasn't
right,
and
so
we
want
to
try
and
build
something
from
the
ground
up
around
some
of
these
experiences.
When
we
started
using
it,
then
we
said:
okay,
no
one
actually
wants
a
parser.
They
actually
want
the
arguments
to
their
app
and
they
want
an
end
user
experience.
So
that
mean
please.
H
We
took
the
lead
from
the
parts
of
it:
the
first
iteration,
okay,
actually
the
parser
by
itself
is
totally
uninterested
and
then
so
we
started
looking
at
things
like.
You
know:
support
for
rich
model,
binding
model
line
into
object,
graphs
being
able
to
express
the
inputs
you
want
without
having
to
directly
configure
the
parser,
which
is
the
dragon
fruit
experiment
that
can
you
mentioned
better
I/o
handling,
rendering
things
like
this
kind
of
grew
out
of
that.
J
G
I
was
about
to
say
that
one
of
the
main
things
that
I
ran
into
existing
projects
and
parcels
is
that
the
barrier
to
entry
seemed
to
be
very,
very
high.
What
I
wanted
is
initially
I
literally
want
something
like
one-liner
and
I
know
that
I
will
be
expanding.
My
art
to
have
more
and
more
capabilities,
but
I
don't
want
to
suddenly
learn
complicated,
syntax
and
grammar
and
define
something
because
I
just
want
to
see
whether
the
first
argument
is
a
or
B
yes
and
then
evolve
it
over
time.
Yeah
I.
B
B
Drawing
it
fits
an
app
model
that
we
have
where
you
get
strongly
typed
arguments
domain
and
because
you
have
downloaded
the
package,
you
have
an
extra
thing
in
your
script
that
goes
in
the
wraps
back
in
a
main,
so
you've
got
this
is
this?
Is
your
world?
This
is
what
you're
right.
You
don't
know.
The
package
write
this
one
up,
okay,
so
that
is
that.
Is
that
what
we
mean
when
we
say
app
model?
We
think
that
there's
probably
another
case
think,
but
we
haven't
written
it
yet.
B
But
one
way
to
do
it
is
that
the
student,
this
you
have
a
complex
object,
you
it's
quite
complex
and
then
what
you're
doing
is
you
are
filling
that
object
and
the
whole
you're
again
dropping
it,
and
this
is
coming
there
also
there's
reasons
you
may
not
want
to
wrap,
because
then
it's
in
your
stack,
so
there's
also
you
do
the
same
thing
without
wrapping
this
way,
so
that
you
don't
have
the
commit
system
command
line
in
your
stock.
So
it's
written
so
all
those
things
work
so.
B
Dragonfruit
is
the
app
model
we
built
to
prove
that
we
were
at
models
from
the
beginning.
It's
the
proof
of
concept
has
gotten
a
little
bit
of
attention,
because
if
this
is
what
you
want
to
do,
okay,
this
is
dirt
simple
and
by
the
way,
this
type
right
here
this
could
be
direct.
This
I
think
we're
working
on
package.
I,
don't
know
if
it's
done
yet
so
this
can
be
rich,
and
then
that
would
be
supported
by
suggestions
and
completion.
The.
H
Thing:
that's
that's
worth
noting
here
in
terms
of
discard
describing
in
half
model
another
one
that
came
up
recently.
Someone
asked
for
a
convention
when
they
could
add
an
invoke
method
directly
to
their
command
object
and
her
our
command
object,
add
invocation
to
and
we
were
able
to
make
that
work
and
just
about
five
lines.
It
gives
you
parse,
diagramming
and
debuggers,
there's
a
bunch
of
different
aspects
to
it
that
you
get
for
free.
H
So
this
is
really
a
way
of
shaping
an
api
to
a
specific
convention
that
you
might
decide
visit
the
convention
I
want
to
use,
but
most
of
the
logic
of
this
thing
is
actually
in
the
core
system,
and
so
you
could.
Similarly,
you
could
write
a
model
that
was
attribute
driven
or
you
could
write
a
DSL
or
things
like
this
by
by
manipulating
the
underlying
API,
alright
smell
icky
with
you.
B
G
B
And
dragonfruit
gets
into
your
to
your
build.
I
mean
dragon
foot
puts
something
in
your
build,
so
this
is
pretty
intrusive
for
some
programmers.
This
is
not
something
that
you're
going
to
put
everywhere.
We
would
never
use
this
for
the
from
the
dotnet
stay
alive,
for
example.
However,
we
would
use
another
app
model.
We
could
we're
likely
to
use
another
app
model,
which
is
likely
to
be
something
that's
based
on
an
inheritance
model.
G
C
B
Could
be
also
that
we
decide
that
what
belongs
in
the
VCO
is
actually
there
are
a
PR
we're
going
to
show
you
how
you
would
work
directly
against
the
wrong
API,
and
it
could
be
that
the
raw
API
is
what
belongs
in
closer
in
and
that
the
app
model
should
be
separate
to
get
packages
that
kind
we
can
happen.
The
other
can
be
as
many
as
the
world
wants
to
have
against
the
raw
API
and
the
rakia
is
intended
to
be
usable
when
I
set
me
up
from
complicated
it's
a
less
complicated.
B
That's
all
about
that
API
surface
we've
got
dragon,
for
instance,
nearly
the
beginning,
so
the
fact
that
we
did
in
that
model-
that's
always
been
there,
but
we
felt
like
underneath
that
it
had
to
be
usable
and
that's
where
we've
been
doing
the
evolution.
That's
where
we
plan
to
do
the
user
study,
because
people
are
talking
about
this
people
like
this.
B
If
you're
this
simple,
you
like
this
okay,
once
you
start
having
nested
canals,
we
don't
have
the
answer
yet
for
that,
even
if
you
have
it,
we
haven't
felt
like
we're,
ready
release
those
app
models,
and
also
you
wouldn't
mind
at
all
community
would
mind
at
all.
If
somebody
else
did
those-
and
so
that's
part
of
why
we
focus
now
after
this
on
that
API
service.
A
Yeah
I
mean
like
the
one
suggestion
that
I
had
to
carefully
and
John
was
because
we
wanted
to
use
a
sturdy,
but
the
basis
show
us
the
code
that
they
would
expect.
Basically
scenario
that,
because
the
user
stars
are
usually
the
you
know,
getting
started
with
an
API.
And
then
you
see
like
what
is
the
task.
And
then
what
does
the
API
usage
that
they
expect
as.
B
B
At
the
interstate-
and
it
doesn't
answer
your
question
101-
do
you
want
to
gather
it?
But
let's
see
if
this
helps
start
answering
that
question.
So
what
the
user
study
is
is
a
series
of
steps
with
code
that
we
think
somebody
might
come
up
with
there's
of
course,
different
ways
that
they
could
come
up
with
it,
but
so
you
create
a
console
application
just
to
get.
You
started.
Let's
first
make
sure
that
that's
also
fun
ethics.
B
They
can't
create
a
console
application,
we're
not
a
different
interpretation
of
what
they're
doing
as
an
again
package
here,
we're
adding
system
command
line,
which
is
our
core
package
dragon
fruits
of
difference.
This
would
command
like
dragon.
Fruit,
I
think
it's
delays
that
gets
thrown
in
oh
we're,
not
Microsoft.
Oh
dear
okay,
I
didn't
know
that
we're
supposed
to
all
be
Microsoft.
What.
D
B
B
H
Sure
so
this
is
the
invoke
here,
starting
without
with
there's
a
root
command,
which
you
don't
need
to
specify
a
name
before
you
can
specify
a
name
for
it.
It
can
be
parsed
either
way,
but
one
of
the
intentions
of
the
root
command
is
that
it
will
understand
in
context
the
name
of
your
application,
your
executable
or
the
alias,
by
which
it
was
invoked
in
so
in
a
complete
command
line,
submission
which
can
include
a
string.
It's
also
able
to
parse.
H
B
B
H
We,
our
expectation,
is
not
that
you
would
switch
on
that
behavior,
but
you
can
because
the
tokens
are
there
where's.
The
argument
here
is
a
command
argument.
What
you're
seeing
here
is
a
pill
collection,
initializer
I
can
switch
between
a
couple
of
different
syntax
examples
here.
What
for
the
user
study?
We
sort
of
said
that
this
might
the
collection
initializer
might
not
be
the
most
discoverable,
but
it's
there,
because
it's.
B
B
Have
a
I
went
through
the
user
study
trying
to
be
stupid
and
trying
to
be
a
user
and
came
up
with
a
difference
of
syntax
that
I
thought
might
be
more
discoverable,
and
so
this
is
a
different
view.
To
the
same,
these
are
do
exactly
the
same
thing.
We
sort
of
think
you
might
graduate
to
this
closer
to
the
other
one.
Obviously
anyone
could
just
make
those
all
done.
It
off.
I
think
yeah,
yeah,
okay,
so.
H
So
the
thing
that's,
the
the
collection
initializer
allows
you
to
nest.
Commands
sub
commands
all
the
way
down
with
arguments
options
inside
of
them
right.
So
you
can.
If
you
want
to
have
that
nested
structure
all
in
one
declaration
it
lets
you
do
that,
but
they're
just
you
know,
the
add
method
is
really
just
calling
an
argument.
Optional
add
command,
so
there
are
api's
for
all
of
those
them
okay.
So
you
want
to
flip
back.
A
You
can
ask
them
questions
on
what
this
means
so
I
get
the
the
argument,
when
you
say
a
new
argument
of
string
name.
That
makes
sense
right.
That
is
there.
That
is
the
thing
that
people
pass
to
it
and
their
name
is
not
the
thing
you
say
it's
just
whatever
we
refer
to
it
in
the
help.
Right,
yes,
and
the
handler
I
suppose
is
the
thing
that
gets
invoked
when
everything
was
parsed
right.
When
you
call.
H
H
B
This
so
string
appears
that
say,
hello
and
string
appears
as
the
is
the
type
argument,
and
this
is
actually
something
make
fun
a
lot
with
and
we'd
be
happy
to
show
you
where
our
pain
point
was
but
I.
Don't
think,
that's
something
that's
actually
going
to
change
in
the
run
time
about
how
generics
work.
So
we
we
have
a
lot
of
pain
around
this
point
that
createhandler
has
right
now
42
overloads
because
of
different
type
parameter
count.
You
know
different
guarantees
on
type
numbers
to
type
around,
as
you
might
need
to
pass
and
that's.
H
A
H
This
is
okay.
This
is
the
idea
to
do
it
by
name.
So
it's
a
name
transform.
You
know
because
the
obviously
option
they
might
have
delimiter
with
hyphens,
and
things
like
this-
that
are
comment:
POSIX,
convention
or
slashes
that
are
comment
windows
conventionally
sure
we
know
how
to
parse
both
the
so
it's
a
name
based
matching
which
is
inspired
by
asp.net,
which
has
been
a
convention
they're
named
ace
matching
on
model
binding
for
many
years,
but
it
still
turns
out
to
be
a
fairly
like
once
people
understand
that
it
works
that
way.
H
H
Matching,
but
ordinal
only
makes
sense
if
the
code
is
small
enough,
that
you
can
see
it
all
at
the
same
time,
so
we've
had
people
say
hey.
This
would
be
a
nice
thing
to
do.
You
could
certainly
support
a
convention
like
that
pretty
easily
based
on
the
quarry
of
the
eyes,
but
right
now
we're
imagining
so.
A
F
Of
the
problems
with
teleca's
generally
is
that
many
developers
are
tempted
to
or
the
compiler
can
create,
automatically
a
wrapper
around
the
actual
method
you
intend
on
calling-
and
that
means
things
like
parameter
names,
attributes
on
the
parameters,
attributes
on
the
method
you
intend
to
call
could
get
lost
during
that
process.
That's
actually
why
I'm
pessimistic
about
things
like
this
that
take
a
delegate
rather
than
a
straight-up,
nothing
and
vote
like.
F
C
Think
it's
also
worth
worth
calling
out
here
and
it's
something
that
I've
hit
every
time.
I've
used
system
command
mine
is,
the
argument
is
optional,
meaning
if
you
invoke
just
hello,
it
will
invoke.
You
won't
get
any
error
handling
with
this
code
here
and
it
will
just
say
hello
exclamation
point
right,
because
you
can
declare
it.
B
H
One
of
these
things
have
actually
changed
so
because
one
of
the
changes
that
we
made
that
I
think
influenced
both
of
these
things.
There
is
support
for
a
required
option
which
a
lot
of
people
ask
for
an
argument.
You
can
have
multiple
arguments
of
different
types
right,
so
if
you
think
of
a
move
command
where
it
takes
multiple
arguments,
you
might
have
up
a
file
info
and
a
directory
info.
So
you
move
argument
1
to
argument
2
and
the
Erinyes
of
those
arguments
can
be
defined.
H
So
you
could
say
you
know,
I've
done
an
era
teeth
at
allows.
5
different
arguments
for
one
type
of
violent
foes.
Final
arity
allows
executives
where
the
area
is
exactly
1
and
that's
right,
so
this
influence
is
whether
things
are
required
or
not.
But
it's
also
it's
a
little
bit
of
a
complex
API
in
that
sense.
Well,
and
that's
also
for
options,
not
arguments.
That's.
H
So
that
API
has
also
changed,
which
of
us
that
we
have
option
of
T
and
don't
need
to
go
directly
like
syntactically.
An
option
has
a
child
argument,
but
we've
kind
of
flattened
that
out
in
the
surface
API,
not
in
the
court
parser.
The
underlying
parser
has
to
understand
syntactically
distinct
from
one
another,
but
the
API
has
simplified.
So
you
don't
need
to
think
about
the
option.
The
argument
that
is
attached
to
an
option
and.
B
H
Given
that
a
second
given
this
diagram
to
explain
some
of
the
terminology
here,
this
argument
here
is
you
don't
need
to
access
it?
You
can
just
info,
you
just
create
an
option
directory
info,
so
you
don't
need
to
happen.
You
don't
need
to
use
it.
This
part
right
here.
That's
a
that's
a
recent
change
that
we're
kind
of
working
through,
because
so
typically
these
things
that
you've
asked
in
there
you
can
and
then
either
arguments
or
options.
So.
G
Do
you
really
call
these
types
argument
of
the
adoption
of
teeth?
Yes,
so
I
don't
know
if
we
want
to
start
like
more
detailed
review
but
yeah
some
d,
we
want
a
I
would
be
concerned
with
this
to
me
seems
so
I'm
kind
of
trying
to
understand
long-term
picture
like
when
we
end
up
with
this
year.
Right
and
I
I
can
tell
you
my
opinion,
I,
don't
know
if
you
know
it's
read
by
the
whole
team.
G
I
think
that
we
should
have
something
super
simple
built
into
the
platform
and
then
have
underlying
low-level
ideas
like
there
are
other
flexibility
for
people
who
may
be
the
simple
thing
doesn't
work
for
them.
Maybe
they
have
a
different
preference
about
syntax
and
whatnot.
So
to
me,
these
things
will
be
in
the
low
level.
Yes,
the
pocket
and
therefore
I
would
not
use
really
good
names.
Like
argument
of
the
adoption
of
the
for
low-level
thoughts,
yeah.
A
A
Adoption
is
that
they're
not
very
specific
to
your
domain
like
option
of
T,
for
example,
like
has
been
used
by
other
people
to
just
better,
have
a
better
version
of
nullable.
They
do
type
so
I
would
I
would
say
that
come
up
with
some
prefix
at
least
so
you
can
yeah
differentiate
them
from
you
know
other
arguments
and
other
options,
but
then
also
here
in
terms
of
concepts,
I
mean
I.
L
G
B
Interviewed
two
people
I'm
surprised
many
people
do
not
relate
to
the
syntax
of
their
commands
as
a
CLI
when
I
even
inspected.
So
this
has
been
used
by
a
number
of
people
in
this
building,
saving
them
having
to
understand
or
write
a
different
parser
and
as
I've
worked
with
them
their
syntax
and
on
their
help.
That
is
very
jarring
for
them
to
think
about
that
as
CLI.
So
we
can
work
on
the
right,
prefix
I'm,
all
for
that,
but
no
problem
with
data.
But
it's
a
shock.
B
G
B
Right,
so
why
don't
we
go
through
what
we've
got
here
and
then
we
can
talk
some
more
once
you
get
argument
and
the
reason
I
did
this
user
study.
This
way
is
that
I
talked
to
two
emo
about
some
things
about
the
user
study
before
he
left
for
vacation
and
it's
gone
and
completely
available
to
me.
Well,
I
actually
do
this
work
thanks
a
lot.
K
B
Kidding
I,
you
know,
I
think
that
there
is
a
space.
You
know
the
challenge
is
going
to
be
whether
they
can
get
an
argument
passed
and
get
invoke
in
that's
a
place
where
most
concerned
about
right
now
will
be
a
little
bit
more
on
that
I
want
to
come
back
to
what
you
said.
Christophe
it's
a
little
bit
later
and
then
adding
an
option.
We
hope
is
easy
once
you
get
the
rest
of
it.
We
hope
this
part
is
kind
of
easy.
B
H
B
And
this
by
the
way,
was
in
direct
response
to
writing
about
running
into
a
problem
with
something
he
was
doing
with
it,
and
he
felt
something
was
too
difficult
and
both
the
specific
thing
he
was
going
after
may
want
that
thing,
something
we
directly
support
and
just
say
here
you
go
because
it
was
finally
a
project
file,
it's
very
common
for
us,
but
but
what
he
needed
to
do
to
do
that.
We
realized
that.
Maybe
we
should
do
anyway.
B
H
H
B
Yes,
so
you
could
say,
result
by
parent,
not
equal
to
block,
and
then
you
can
say
that
this
fails.
So
there
was.
You
can
fail
your
course,
and
so
you
could
say
this
fails
need
to
get
a
message
there.
If
it's
not
attached
to
correct
parent
of
the
tree
River,
it
would
be.
I
will
say
that
working
with
people
on
the
syntax
of
their
command
lines,
once
I
write
that
up,
which
is
hi,
I'm
Maya
things
to
do.
B
Felis
I
do
that
as
rarely
as
possible,
because
her
health
becomes
nonsense
once
you
do
that,
there's
no
real
way
to
express
it
so
as
much
as
possible
trying
to
have
it
be
at
the
command
level
that
you
split
things
up
into
groups
and,
like
the
first
demo,
button
that
syntax,
it's
still
I,
still
think
it
could
be
better.
But
the
first
one
was
incomprehensible.
I
mean
now
it's
okay,
but.
D
G
H
What's
there
yeah
in
this?
In
this
example,
the
tokens
that
you
will
receive
were
only
the
ones
that
were
syntactic.
It
is
really
building
a
syntax
trigger,
so
the
tokens
that
you're
going
to
receive,
even
if
you're
buried
way
down
inside
of
a
bunch
of
other
sub
commands
and
there's
other
options
and
everything
else
you're
going
to
be
receiving
the
tokens
that
only
were
applied
to
that
specific
object
right
so
you're.
H
C
G
B
B
Working
on
getting
the
rights
and
rules
that
you
can
hit
more
easily
so,
for
example,
everything
around
strongly
typed
and
Aaron
T
is
handled
for
you,
we're
working
on
types,
getting
the
right
set
of
type
someplace
for
you
and
named
correctly,
so
there's
there's
an
array
of
things
we
should
be
handled
like
you
know,
for
everybody
all
the
time.
We
also
recognize
that,
no
matter
what
we
think
of
you're
gonna
have
some
off-the-wall
thing
that
nobody
else
wants.
That's
just
for
you
and
we
need
a
way
to
do
that
and
well.
This
is
called
parse.
B
It
may
not
be
the
perfect
name,
because
all
you're
doing
is
taking
one
two
three
and
deciding
what
you
want
to
do
to
it.
So,
for
example,
you
might
say
hey
tell
me
if
this
wouldn't
work,
hey,
they
should
actually
be
1.
2
3
smash
together
forget
spaces,
okay.
So
this
is
something
very
weird
that
you
want
to
do.
Nobody
else
wants
to.
Maybe
you
want
to
comment
to
a
limit?
1,
comma
2,
comma,
3?
B
Okay,
so
this
is
you
taking
that
transforming
it
the
way
you
want
it
to
be
transformed
and
then
moving
on,
and
so
it's
I
think
it's
important
to
understand
that
a
it's
a
limited
case
and
being
Horace's
almost
not
the
right
name
for
it.
It's
almost
more
of
a
transform
that
you're
doing
to
the
result,
and
maybe
that
name
is
wrong.
I
guess.
A
It's
better
example.
Looking
for
files,
you
would
like
to
say:
does
the
file
already
exists,
or
is
it
actually
a
valid
file?
Name
yeah,
but
those
are
the
kind
of
things
you
would
build
where
you
would
say.
Oh,
if
it's
a
relative
path,
I
want
it
to
be
relative
to,
let's
say
some
other
extreme,
the
director
that
is
not
common,
sorry.
A
Correct
me,
if
I'm
wrong,
but
like
the
validators,
are
always
in
the
context
of
a
very
particular
argument
right,
so
I
think
Chris
of
the
original
question
was
what,
if
you
have
mutual
dependency
between
saying
well,
if
you
do
this
operation-
and
you
need
to
specify
this
this
or
that
maybe
the
other
thing
you
have
to
specify
one
of
these
two
like
at
that
point.
You
talk
about
something
that
is
on
top
of
all
the
arguments
you
have
and
I
guess,
that's
just
a
complete
custom
rule
that
I
write
and.
H
Different
approaches
you
can
take
to
that,
but
yes,
you
so
the
simple
result:
that's
passed.
If
you
say
parse
argument,
the
simple
result:
that's
passed
in
there.
It
has
the
syntax
tree
available,
but
you
come
up
there's
also
a
middleware
Python
application.
So
you
can.
If
you
want
to
see
the
parse
result
as
a
whole
object
and
say:
okay,
I
know
what
command
was
invoked.
I
know
what
options
are
on
there
kind
of
thing.
You
can
do
that
as
well.
It.
B
Just
add
one
thing
to
that:
you
can
do
it
that
way.
It's
the
only
way
today.
This
is
a
problem
that
I'm
continuing
to
think
on
for
an
entirely
different
reason.
So,
first
of
all,
I
don't
want
to
make
this
so
simple.
You
do
it,
because
it's
extremely
difficult
for
end-users,
when
you
do
this,
this
is
hard
for
end-users
period.
I'm,
so
I
hesitate
to
make
it
easy.
However,
today
your
ability
to
express
that
in
health
is
zero.
It
just
there's
just
no
way
to
do
it.
B
If
I
could
come
up
with
a
way
just
have
those
kind
of
interdependencies
clear
and
help,
then
I
would
drive
it
through.
So
that's
the
way
you
would
define
it,
but
not
so
much
because
I
want
to
make
that
easy,
because
it's
really
not
something
that
I
mean
I
wanted
a
lot
of
people
to
do
everything,
but
I
don't
really
want
to
encourage
people
who
think.
G
Yes,
I
totally,
did
you
know
what
I
was
saying
before
I
believe
we
should
end
up
with
something
very
prescriptive
and
simple
in
the
VCL
built
in
at
some
point.
We
should
be
packaged.
This
is
how
you
do
command
line.
It
has
restrictions.
Maybe
it
has
syntax
that,
frankly,
is
a
bit
less
convenient
for
the
benefits
that
you
were
saying
for
the
benefit
of
the
you
know,
end-user,
who
then
uses
the
app
I
do
really
like
the
philosophy
by
the
way
of
focusing
on.
C
A
Mean
it's
kind
of
raised
in
that
this
tool
right.
They
have
low
level
building
blocks
and
then
they
have
high
level
kind
of
extension
methods.
Fluid
API
is
kind
of
things
to
wire
stuff
together.
Without
writing.
You
know
a
hundred
lines
of
code,
but
it
also
means
you
can
wire
these
things
pretty
much
in
any
combination
you
want,
which
is
quite
powerful.
H
I
think
this
there's
actually
one
distinction
that
this
brings
up
and
it's
one
of
the
places.
So
we
have
the
option
of
T
argument
of
T,
but
there's
also
a
non-generic
option
market
and
the
reason
is
that
those
are
intended
to
be
configured
by
a
convention.
So
if
you
have
a
method
info,
you
say:
I
want
to
use
this
method
in
from
here.
Yeah.
G
H
So
I'm
gonna
write
my
own
code
that
reflects
over
the
parameters
to
this
method
info
and
builds
the
parser
based
on
them,
which
is
exactly
what
the
dragonfruit
model
is
doing.
You
can
handle
these
things
at
a
non-generic
context
and
say:
okay.
The
type
for
this
argument
will
be
type
of
this
right.
The
type
for
this
option.
When
you
talk
about
this
and
you
can
directly
control
the
Erinyes
of
things
so
we're
deriving
arity
based
on
the
expected
and
bound
to
type
option
of
t.
H
H
G
If
I,
if
I,
understand
how
the
dragonfruit
works
I
like
it,
that's
why
that's?
How
I
would
want
to
start
I
get
one.
You
know
what
I
have
two
options:
initially
boolean
and,
and
the
number
I
just
said
who
even
in
parameters
and
I'm
done
and
then
I.
Can
you
know
as
long
as
I
it's
I,
don't
know
how
it
scales
like
what
happens
after
a
while
doesn't
get
super
super
messy.
The.
C
Only
problem
I
ended
up
encountering
with
dragon
fruit,
because
I
talked
to
John
like
over
a
year
ago
about
command
line
and
I
started
using
that
for
clang
sharp
when
I
was
doing
some
work
on
that
and
dragonfruit
ended
up
working
really
well.
But
the
problem
I
hit
with
it
was
argument,
validation,
logic,
but
there's
been
some
improvement
since
then,
including
in
the
low-level
API,
which
is
what
clang
sharp
is
currently
using
and
I
think
that
it
could
end
up
in
that
right
area
and
what.
C
G
H
The
lower
level
API
is
let
you
do
things
like
define,
custom,
validators,
custom
parsing
to
the
types
that
you
want
to
to
output.
You
can
define
whether
or
not
you
know
equals
or
colon
or
space
or
valid
delimiters
between
a
an
option.
Token
and
an
argument
token
or
moreover,
more
than
one
token
you
can
define
whether
unpark
opens
are
an
error
on
so
if
it
gets
so
we
have
support
for
double
dash
on
parse
tokens.
You
get
that
in
the
parser
zone,
so
doc
that
CLI
uses
this.
H
Take
total
control
over
and
sometimes
you
want
to
say,
yeah,
there's
an
unrecognized
token.
There
that's
inner
and
this
in
practice,
the
diamond
CLI.
The
rules
for
that
were
different
for
different
verbs
for
different
sub
commands.
So
those
capabilities
are
there
but
dragonfruit
right
now,
because
it's
some
convention
based
and
so
opinionated.
We
didn't
go
and
design
ways
to
access
all
of
that
complexity.
H
But
this
right
here
is
the
dragon
fruit
setup.
So
you
can
see
you
know
we're
configuring,
a
loop
command
based
on
a
method
over
configuring,
the
help
based
on
documents
and
then
use
defaults,
and
what
you're
seeing
here
is
a
whole
bunch
of
stuff.
That's
just
built
in
right,
so
you
can
configure
the
stuff
directly
yourself,
but
we're
saying
we'll:
do
you
automatically
get
help?
You
automatically
get
a
version
option,
a
parse
directive,
which
is
a
way
of
understanding.
J
J
A
J
K
H
Is
again,
this
is
the
kind
of
students
it's
there
as
an
end-user
thing
as
well,
so
that
you,
you
know
a
lot
of
a
lot
of
command
lines,
have
a
dry
run
option.
This
is
kind
of
an
equivalent,
but
you
should
built-in
at
the
parser
level.
So
you
can
understand.
How
is
the
parsec
one
you
to
understand
this
before
the
actually
and.
H
J
D
B
Kind
of
off
of
standards
in
a
few
places,
and
one
of
the
things
is
that
there's
a
clear
need
to
give
things
to
the
parser
earlier,
in
addition
to
what's
going
through
to
the
actual
CLI
itself,
and
we
use
the
square
brackets
for
that,
that's
something
we
would
be
very
willing
to
change.
If
other
people
in
the
community
doing
other
part
search
said
no,
we
should
be
doing
something
else,
but
we're
using
square
brackets.
It
has
to
be
distinct
from
and
asked
me
to
stick
from
arguments
and
that's
been
clearly
going
to
the
parser
later.
B
B
H
We
have
the
option
to
the
command
line
filter.
You
don't
need
to
use
it
in
my
mind,
builder,
using
syntax
that
we
showed
before,
but
these
things
might
need
to
be
sorry
that
it
was
a
there's
still
there's
a
little
bit
of
a
transition
there
between
what
we
originally
has
a
new
immutable
API
that
we
made
the
API
mutable
to
better
facilitate
building
custom
API
services
on
topic.
Although.
H
F
C
And
I
tried
using
this
before
the
fluent
was
fully
there
and
I
hit
a
lot
of
places
where
I
was
like
I've
got,
instead
of
being
able
to
just
say,
like
new
argument,
dot
blah
blah
blah
blah
I
actually
have
to
declare
an
explicit
variable
named
Arg
and
then
initialize.
It
then
call
helper
methods
and
then
finally
pass
it
to
add
argument
and
I
was
just
a
pain.
But,
having
said
that,
like,
if.
G
H
B
L
B
Files,
what
RSP
files
are
SP
pods
right
responsible,
that's
another
thing
that
is
just
automatic,
but
if
you
don't
want
that,
you
want
your
own
way
to
do
that.
You
can
certainly
put
that
in.
We
have
some
other
ways
we
would
like
to
be
able
to
have
help
the
customize
that's
a
very
important
area.
It's
run
into
a
few
problems
around
the
console,
abstractions,
and
so
we're
so
working
some
details
on
that.
Just
and
it's
one
of
things
that
we
need
to
work
at
least
across
the
company
and
not
the
partial
and
Windows
turn.
B
My
house
is
a
networking
group.
I
know
they
are
unless
there's
about
four
or
five
groups
in
a
working
group
on
getting
our
experience
on
the
terminal,
and
one
of
the
things
is
we're
like
it's
members
of
dotnet
like
we
do
not
want
to
be
where
rich
is
standing
up
on
stage
and
talking
about
great
than
Windows
terminal.
Is
it
some
great
feature
it
has
that's
dependent
on
better
of
you,
t100
support
them
system.
Console
has
and
dotnet
is
completely
flat
that
it
can't
be
on
the
stage
and
we're
starting
at
same
zero.
B
We
are
about
two
weeks
out
from
being
able
to
be
on
stage
with
anything
which
shows
so
you
know
we're
we're
staying
right
behind
him.
That
is
not
it's
not
funded
and
that's
like
a
lot
of
work
and
we're
probably
going
to
have
to
fund
that
part
before
it
can
actually
go
into
like
really
blossoming.
However,
it
is
in
the
field
and
system
diagnostic
system.
Diagnostics
are
lights
on
that,
so
we
already
have
that
dependency.
They
couldn't
do
it
without
it.
B
H
F
A
I
A
But
I
think
the
one
thing
we
should
tell
people
is
that
analyst
only
do
is
read
line
in
right
lines:
I
guess
we
need
to
talk
about
colors
positioning.
Basically,
you
use
it
as
a
terminal
of
like
you
know,
window
worth
and
window
highs
and
all
the
other
stuff
that
console
has
console
does
not
work
very
well
like
it
starts
with
the
fact
that
some
of
the
api's
we
can't
even
implement
right.
A
If
you
ask
for
window
words
on
anything
but
windows,
it
blows
up
because
we
don't
know
how
to
retrieve
it
and
I
think
in
general,
the
way
colors
work
on
windows
or
used
to
work
before
they
had
first
class
BT
support
is
not
great
cross-platform
either.
So
I
think
for
everything
that
is
not
just
basically,
the
stream
based
reading
and
writing
I
think
we
should
stay
people
away
from
so
I
suppose
a
new.
H
Specific
you
mentioned
system
type
terminals.
Specifically,
there
is
one
of
the
things
that
we've
done
here.
This
is
one
of
the
connection
points
between
the
rendering
work,
sort
of
application
framework
side,
which
includes
the
bars
here,
are
a
couple
of
abstraction
that
we
have
apartment.
Initially,
we
we
understood
them
as
improving
testability,
which
is
I
console,
and
I
console
eventually
split
out
for
my
terminal.
So
any
notion
of
statefulness
is
gone.
H
Freeze
these
things
and
I
terminal
it's
still
very
much
a
sketch
of
where
we
think
we
might
go,
and
that's
one
of
the
things
we're
working
on
which
Turner's
team
with
and
working
with
the
PowerShell
team
on
is
figuring
out.
What
that
obsession
ideally
should
look
like
I
console
is
a
strict
standard
instead
about
standard
error
and
nothing
more
they're,
just
extremes
and
in
fact
those
streams
themselves.
H
Maybe
you
know
the
text
writer
that
reader
or
not
the
way
that
actions
they're
either
because
the
notion
of
passing
an
object,
the
fruit
to
it
presupposes
some
kind
of
formatting
and
you
can't
really
talk
about
formatting
without
talking
about
whether
you're
in
an
ANSI
terminal
or
not
or
whether
you
really
wrecking
output.
So
it's
very
much
simplified.
What
I
console
me
is,
but.
A
To
give
you
an
idea
of
what
the
problems
are
so
like
VT,
because
it's
stateful
like
you
can
position
your
cursor,
but
a
very
common
thing
on
UNIX.
Is
you
have
a
pager
right?
Basically,
you,
when
you
say
git
log,
it
automatically
pipes
to
a
pager
that
basically
stops,
and
then
you
have
personal
support
to
scroll
up
scroll
down.
A
The
thing
that
writes
to
the
console
doesn't
know
it's
being
paged
so,
but
but
you
still
want
to
have
colors
write
it
so
the
way
because
the
colors
are
in
line
the
pager
can
actually
retain
them
and
like
we
paint
them
and
you
scroll
up
scroll
down
right,
which
on
Windows,
doesn't
work
this
way.
So
when
you're
on
Windows,
for
example,
you
redirected-
and
you
know
you
try
to
like
emit
colors
like
bad
things-
will
happen
right.
So
like
these
things,
don't
necessarily
composing
the
way
you
want.
A
If
you
want
to
completely
abstract
it
away
like
at
some
point,
just
have
to
make
a
decision,
whether
you
know
you're,
assuming
weekly
100
support
or
you
don't.
But
you
can't
really
completely
hide
the
fact
that
you've
acquired
at
some
point
but
I
think
it's
very
clear
that
for
cross-platform
I
think
that's
the
way
we
need
to
do
it.
Anyways
if
you
want
you,
I,
have
to
look
great
on
Mac
in
the
next
step
and.
H
B
As
we
can
to
the
eye
console
in
a
terminal,
I
think
that
is
something
that
this
group
will
be
intensely
involved
in,
as
well
as
these
others
group
Suites,
but
that
the
shape
of
that
is
important.
There's
a
lot
of
people
that
will
that
will
have
input
to
that,
including
everyone
on
this
team
to
to
get
that
right.
That
may
not
fly
in
a
different
location.
My
guess
is,
in
the
end,
that
that
were
wound
up
in
a
different
location.
That
system
command
line.
B
H
K
K
A
One
thing
I
became
II,
look
at
some
concrete
examples,
because
I
mean
Aguirre
started
with,
like
you
know,
hello,
world
kind
of
scenarios
for
the
for
the
command-line
parser.
So
the
thing
I
would
like
to
see
like
just
go
for
your
scenarios
a
little
bit
further,
because
I
have
some
questions
on
how
okay,
what
I
consider
basic
stuff
like
how
they
would
look
like
so.
B
Take
this
far
because
I
was
imagining
a
single
user
study
and
I'm,
actually
imagining
that
it
will
take
somebody
quite
a
while
to
do
that
stuff.
That
says
figure
out
the
invoke,
and
all
of
that
our
experience
in
working
with
people
in
community
is
that
we
is
a
challenge
we
don't
know
yet
how
to
solve
that
challenge.
Yeah.
B
B
Email
did
was
ask
us
to
propose
a
study.
Yes,
can
you
give
us
feedback
on
how
we
should
do
to
stay
and
then
we'll
do
this
day
and
I
have
a
list
of
things
that
I
when
I
went
through
it?
I
have
concerns.
There's
a
there's,
a
guy
like
15
concerns
about
people.
They
run
into
a
problem
here.
Some
of
them
may
be
fixable.
Some
of
them
were
still
really
struggling.
We
really
already
thought
a
lot
about
invoke
in
the
handler
and
how
to
make
that
easier.
So
far,
we
haven't
had
an
insight.
B
G
G
A
A
Dc
licensee
own
is
talking
massive
efforts
because
guess
what
we
didn't
call
our
method,
seola's
initialize.
We
gave
them
other
names
that
were
we
thought
good,
but
turns
out.
Nobody
could
do
the
mapping
in
their
head
and
that's,
I
think,
the
one
thing
you
probably
want
to
focus
on
of.
Like
you
know
the
five
lines
of
code.
We
expect
the
hell.
What
developer
to
ride?
Do
these
names
and
concepts
make
sense?
I
think
I
haven't
an
option
or
perfect.
A
B
B
I
agree
with
you
and
we've
struggled
a
little
bit
about
that
very
first
point
that
you
get
in
and
my
version,
if
you
switch
over
to
so
don't
looked
at
my
versioning
since
I
want
to
show
them
kind
of
the
right
way
to
do
it,
instead
of
showing
them
what
I
did,
which
was
what
I
think
you'll
fall
into
actually
my
first
version
yes
and
hello:
this
really
should
there's
no
mine,
I
just
went
straight
to
command
because
insecure
I
don't
know.
What's
going
to
happen,
if
you
start
editing
this
tomorrow,
I
think
it.
B
C
B
G
G
G
A
I
mean
this
is
the
problem
of
any
polymorphic
thing,
because
one
thing
that
vs
generally
sucks
at
is
you
can't
explore,
derive
types
easily.
You
can
see
base
types
using.
You
can't
explore
the
five
types
easily
so
when
they
know
what
the
base
that
is,
you
expect
I
mean
unless
the
type
names
have
very
consistent,
naming
and
they're
the
same
namespace
people
have
no
way
to
finding
them
and
I've
seen
this
in
in
you
know
anything
that
is
a
Dominator.
You
have
like
an
abstract
based
on
them,
and
people
don't
find
stuff.
I.
A
Think
that's
that's
one
thing.
The
other
thing
I
would
say
with
the
collection
initializers
is
we
do
the
same
thing
in
JSON
people
like
when
they're
there,
because
people
like
to
write
declarative
code,
but
most
of
the
time
like
would
you
want
to
make
sure?
Is
that
the
normal?
Rather
than
fix
our
suggestions
to
say?
Oh,
you
can
use
an
initializer
here,
probably
don't
work
in
your
case
because
you
have
big
do
directly.
You
say
thought
and
argument,
because
I
think
they
only
work
with.
A
So,
like
that's
the
other
thing
like
make
sure
that
those
pop,
because
then
people
discover
that
from
there
but
but
I
think
it's
fair
to
say
the
way
people
usually
work
is
they
find
a
rule
type
and
then
they
basically
just
dot
off
of
that
thing
and
see
what
happens
right,
and
so,
if
you
don't
have
methods
or
or
things
on
them
that
make
sense
to
them.
The
the
amount
of
people
that
just
got
get
lost
is
very,
very
high.
That's.
B
There
was
a
couple
things:
I
have
to
come
back
and
do
this
was
a
little
bit
there's
a
few
things
that,
but
the
one
that
were
most
concerned
about
it,
which
is
the
one
we're
gonna
see
in
the
user
study,
is
the
handler
and
invoke
relationship,
and
we
just
haven't
yet
figured
out
a
way
to
simplify
that
out.
Yet
any.
A
B
H
A
H
So
invoke
is
just
invoke
invoke
a
second
there
they're,
just
convenience
methods.
Actually
what
they
do
internally
is
exactly
what
you're
describing
there's
the
intermediate
step
that
we
said
most
people
don't
care
about
the
parser
itself.
Most
people
don't
care
about
the
parse
result
itself.
They
want
to
go
from
input
to
bound.
You
know
strongly
typed
objects
as
quickly
as
possible,
which
is
that
was
the
dragon.
Fruit
was
trying
to
see.
How
much
can
we
simplify
that?
But
what
you're
doing
all
of
those
you
know
and
those
steps
along
the
way
are
all
present
there.
H
H
H
And
they're
different
overloads
here
that
that
will
do
a
split
on
the
component
on
string
input,
for
example,
or
parse
the
arts
and
what
they're
doing
it's
passing
a
parser
they're
building
the
parser
building
up
the
middleware
parsing
it
getting
back
a
parse
result.
So
you
can
do
the
same
thing
once
you
have
that
command
object,
there's
as
well,
there's
extension
methods
to
go.
You
know
command
parse
or
option
dot,
parse
or
argument
dot
parse.
What
they're
doing
is
they're
building
up
the
parser
and
handing
you
back
a
parse
result
which
is
effectively
describes
how.
A
H
A
H
H
B
H
Get
value
or
default
and
there
are
both
again
there's
this
kind
of
set
of
generic
and
non-generic
api.
Since
we
know
what
the
type
is,
but
you
may
not
know
at
a
compile
time
there
they
get
get
value
or
default
will
return.
The
correct
you
know
correctly
bound
value,
but
coming
back
as
an
object,
immunity
so.
A
H
Could
be
either
one
right,
so
you
don't
know
when
you're
using
this
API,
you
don't
necessarily
know
whether
someone
configure
the
parser
to
have
a
default
value.
So
maybe
you
have
an
option
of
type
in
all
right.
Then
they
set
the
default.
Value
is
123.
When
you
call
get
value
into
fall,
I
get
you're,
gonna,
get
hundred
twenty-three,
getting.
H
A
default
value,
you're
gonna
get
the
default
for
time
right.
There
make
sense,
and
the
other
thing
that's
interesting
to
know
about
this
API.
You
can
reuse
options,
option
of
argument
and
command
objects
at
different
points
in
your
hierarchy
right,
so
you
might
have
an
option
that
you
want
to
apply
to
several
different
verbs.
You
know
have
a
verbose
option.
It
applies
to
several
different
verbs
and
their
leaf
nodes
in
here
and
your
command
hierarchy.
This
will
go
and
find
again.
This
is
a
syntactic
thing.
A
I
think
I
know
what
you
said:
I'm
gonna
tell
show
you're
basically
saying
that,
because
you
can
have
multiple
commands.
Logically,
you
have
different
instances
of
there's
verbose
and
there
might
be
distinctively
different
because
they
might
have
different
default.
They
might
have
different,
they
can
be
yeah,
they.
H
E
B
As
long
as
you
make
your
families
very
short,
like
you're,
just
giving
the
the
method
name,
then
it
doesn't
distract
from
your
view
of
medium-sized
Eli's,
so
the
size
of
the
dotnet
CLI
is
not
going
to
look
good
like
this
and
if
you're
just
doing
something
as
simple
as
something
we're
talking
dragon
food
it
does.
It
only
helps
you
a
little
bit
then
on
middle,
like
this
kind
of
middle
level.
B
If
you
seem
like
complexity,
it's
really
nice
to
see
it
this
way,
and
we
think
that's
where
a
lot
of
authors
are
going
to
the
authors
that
need
this
are
going
to
land.
If
we
just
take
two
commits,
if
you
just
think
to
values
you're
going
to
survive,
if
you
just
use
ours,
you
don't
use
anything.
You
won't
have
help,
though,
because
it's
actually,
apparently
you
don't
get
there
really
simply
ten
lines
of
code
to
get
how
about
put,
and
so
it's
one.
G
B
This
works
all
the
time
and
so
like
right
now
it's
because
it's
not
that
complicated
that
you
can.
You
can
imagine
that,
but
by
the
way
on
that
the
big
thing,
when
I
write
out
my
CLR
a
document,
the
biggest
thing
is
fantasize,
doing
that
and
write
up
as
much
of
your
CLI
as
you
can
for
the
next
five
years.
When
you
start
because,
then
you
have
a
coherency
over
time
as
they're,
just
adding
things
as
you
think
of
them,
in
which
case
you
will
be
coherent
and
IB,
give
you
examples.
C
H
Correct
this
is
it's
not
legal
in
this
case,
because
I
haven't
said
that
that
option,
so
the
default
option
arity
for
int
since
the
default
model
binding
convention
doesn't
know
how
to
take
two
different
values
for
this
right
and
conflate
them.
So
you
have
two
tokens
here.
If
you
were
to
do
a
custom,
parser
I
think
if
I
passed
in
the
argument
that
with
the
parts
delegate,
what
I
would
see
is
that
the
result
for
the
hex
option
has
two
tokens
on
you.
K
A
I
H
G
A
A
After
an
vocals
called
like
what
is
your
error
handling
like?
Do
you
if
I
say
help,
for
example
like
if
you
do
something
right,
which
means
you
take
care
of
terminating
the
application
and
printing
the
help?
Yes,
and
that's
it's
presumably
some
high
level
thing
that
comes
from
don't
use
defaults
where
I
can
say,
don't
use,
help
page
or
something
right.
Yes,.
B
It's
not
useful
and
we
have
a
default
that
probably
needs
another
pass
system
work
on
it.
That
I
did
not
put
descriptions
in
mind
partially
because
I
don't
think,
that's
something
our
users
are
going
to
initially
jump
to
buy,
but
arguments
options
and
commands
all
have
the
ability
to
add
a
description.
H
B
A
Presumably
you're
you
were
you
work
similar
to
internet
right,
exactly
the
handles
are
executed
in
order
and
it
used
two
forces
the
last
one,
and
then
they
can,
after
somebody
up
before
me,
already
define
engine
and
then
do
nothing,
basically
right
so
there.
So
the
person
that
authors
this
thing
and
the
person
calling
the
method
is
both
they're,
both
in
control
and
what
the
orders.
Speaking
of.
G
G
H
G
So
let's
say
this
command
and
you
have
an
option
that
is
an
INT
calm.
Let's
say
you
have
another
option:
there
is
not
an
int,
let's
say
it's
a
boolean.
There
are
some
and
I
want
what
they
are
kind
of,
like
maybe
I
use
around
terminology.
Maybe
there
are
not
options.
You
have
to
specify
either
boolean
Orient
like
I,
have
to
create
two
comments
or
I
can
just
create
one.
The
commands
are
verbs.
H
So
commands
within
they
kind
of
a
line
to
the
way
that
we're
thinking
about
this
is
a
command
will
align
to
one
method.
So
if
you
have
two
different
commands,
probably
they're
gonna
align
to
two
different
method
calls
just
like
controller
methods
on
ASP
demo,
and
each
of
them
can
have
their
own
independent
inputs.
So.
L
B
So
I
think
the
scenario
is
that
it
skits
I
know
I'm
writing
on
the
board.
I'm.
Sorry,
blue,
blue,
blue,
true,
okay,
you
can't
anything
else.
You
have
to
be
one
of
those
two.
You
can't
do
anything
else
right,
but
is
it
going
to
be
an
integer
little
boolean?
So
is
it
he's
a
good
amount
of
glue
to
true
I
think
we
need
to
think
a
little
bit
more
about
that.
It's
a
it's
a
good
scenario,
get
some
of
these.
The
way
that
the
options
and
arguments
that's
what
I
would
like
to
solve.
B
Validation
happens,
the
way
types,
what
types
are
supported
around,
how
options
and
arguments
interact
with
each
other?
You've
asked
a
couple
questions
on
that:
it's
a
really
good
area,
but
it's
super
complicated
and,
as
I
said,
my
main
thing
there
is
that
this
cannot
be
expressed
in
normal
health.
The
way
that
you're
used
to
seeing
help
come
out
and
say:
well,
you
can't
you
can't
express
that
right
now,
so
we
haven't
built
those
those
broader
expectations
that
have
to
be
part
of
it
and
it
should
be
a
unified
whole.
B
If
we
solve
it,
it
should
be
unified.
Otherwise,
you
figure
out
your
answer
to
all
of
those
questions.
We
shouldn't
do
it
halfway,
in
my
opinion,
that
if
we
raised
something
into
we're
going
to
make
it
easy,
it's
also
easy
in
health.
It's
also
easy
in
time
suggestion
it's
also
going
to
be
easy
to
an
accessible
reader.
When
we
go
into
that,
it's
also
gonna
be
easy
to
do
it
once
we
have
that
picture,
and
we
know
how
to
express
that
into
some
sort.
B
G
Though
I
can
touch
it,
some,
like
the
you
know,
the
high
level
opinionated
API
should
have
all
the
properties
that
you
just
said.
I
totally
agree,
I
wonder
whether
the
low-level
API
does
not
need
to
be
like
super,
basically
flexible.
You
know
parser
that
can,
if
I
have
this
scenario,
I
can
represent
it.
It.
G
H
G
I
was
asking
about
my
friend
Blair,
it's
just
a
property,
because
I
would
be
met.
I
I
couldn't
yet
model
metal
model
that
you
do,
support
it
and
the
way
to
implement
it
is
I
have
two
methods.
One
takes,
you
know
an
int
1
takes
boolean
and
I
provide
two
handlers,
and
then
you
will
automatically
select.
You
know
you
will
detect
what
the
type
of
the
parameter
is
and
that.
H
Would
actually
be
fairly
straightforward?
The
validation
part
that
you
need
to
be
able
to
do.
You
know,
interrogate
the
parse
result
and
say:
oh
either
this
one
or
that
one
or
it's
a
validation
error.
And
then,
once
you
know,
what's
inside
the
harsh
result
which
you
can
explore
using
that
API,
you
could
effectively
implement
overload
resolution
and
that
would
actually
be.
A
But
isn't
a
single
handle
logically,
the
most
powerful
model,
because,
basically
it's
you
you're
deciding
what
you
want
to
do,
that
you
want
to
keep
them
the
same
differently
or,
like
you,
write
the
logic
that
says
well,
if
you
specify
either
continue
or
born,
skip
or
edit
undo
I.
Do
this
thing?
If
you
didn't,
then
I
assumed
maybe
I'm
not
entirely
sure.
That
means
it's
an
adequate
scenario
right,
but
I
mean
the
one
thing
that
I've
seen
in
command-line
parsing.
When
you
say
the
only
different
by
type
usually
ends
up
happening.
Is
you?
A
You
have
a
single
logical
operation
and
then
there's
just
multiple
ways.
You
can
represent
the
input.
So,
for
example,
in
get
terminology
you
can
specify
a
branch
in
a
different
way,
so
you
can
either
have
a
branch
name.
You
can
have
the
slash.
You
know
ref
syntax.
You
can
have
these
artificial
things
like
hat
with
back
ticks
and
other
things,
so
there's
multiple
syntactic
representation.
But
logically
the
thing
you
are
pressing
is
not
a
string.
It's
what
they
call
like
a
ref
spec
one
if
I
were
ever
so.
A
What
you
would
specify
here
is
a
ref
spec
and
then,
logically,
when
you,
when
you
add
your
option,
you
would
say
option
of
ref
spec,
and
then
you
have
your
own
pricing,
would
where
you
either
accept
the
string,
the
string
of
that
string.
But,
logically
you
do
you
take
it
as
a
singular
value.
You're
not
you're,
not
like
it's
very
rare,
to
have
completely
different
semantics.
If
the
only
thing
that
differs
is
the
type
name
because
because
it.
G
Would
be
different
operations?
I
wouldn't
have
different
semantics,
it's
just
in
example.
We
think
could
go
back
to
the
example.
You
see
there
said
the
starry
night
yeah
the
the
code
sample
where
you
provide
the
traveler.
You
know,
there's
a
method
say
hello
below
I
would
strongly
typed.
If
I
heard
two
different
repair.
Let's
say
you
know.
Basically
I
can
pass
one
and
true,
and
maybe
maybe
I
can
pass
either
two
or
true
and
true
means.
G
One
I
would
have
two
methods,
like
the
sake,
hello
and
basically
say
if
ditch
if
true
is
passed
and
when
I
just
called
the
you
know
larger
method
that
takes
an
int
passing
one
and
if
false
is
passed,
I'm
gonna
call
it
with
zero.
Otherwise
there
is
a
very
you
know,
flexible
method
that
can
take
an
integer
you've.
B
Think
that
there's
something
I'm,
gonna
contemporary
call
a
virtual
command,
which
I
think
we
would
have
a
great
desire
for.
So
it's
a
sub
command,
the
user
never
knows
about.
So
when
you
have
a
set
of
features
that
belong
together,
you
can
have
a
for
your
ability
so
and
the
integer
and
the
boolean
would
be
separated
on
the
column
again
just
a
virtual
command,
because
everything
is
different
about
them
and
one
of
them.
B
You
have
to
have
an
integer
and
it
gets
to
your
other
question
when
you
have
a
set
of
things
that
belong
together
and
rebase
example.
So
if
we
had
something
called,
though
I'm
just
temporarily
calling
a
virtual
command
for
the
users
unaware
of
this,
it
allows
me
to
organize
help.
It
allows
me
to
start
in
to
a
pattern
by
which
the
user
types
exactly
the
same
thing.
B
They
are
today
where
we
can
crack
open
this
set
of
problems,
and
so
thank
you
for
the
things
you
like
forward,
just
started
the
wheels
grinding
in
a
way
that
I
actually
think
the
middle
to
crack
by
one
and
give
good
information
on
both
tack,
completion
and
hello.
So
if
you
have
any
one
of
these
three
things,
then
you're
in
this
world.
G
So
first
it
was
not
even
asking
about
this
specific
feature:
I,
don't
know
whether
it's
useful
and
what
not
I
have
two
things.
One
is,
as
I
already
said,
the
loner
that
IP
I
should
be
very
flexible
in
my
opinion,
but
second
one
is
I
asked
this
question,
because
that
was
my
mental
model.
Initially,
when
I
looked
at
that
code,
sample
I
thought
you
must
have
a
way
to
sit
to
supply
multiple
handles,
but
I
don't
see
it
in
their
API
and
I
was
asking
why
and
so
why?
G
When
did
I
think
that
you
must
have
a
way
to
supply
multiple
handlers,
because
if
there
is
only
100
first
I,
don't
see
a
reason
to
even
up
sign
this
property
one
hand.
Therefore
this
command.
Well,
then,
I
just
call,
you
know,
provide
a
bit
of
the
command
and
then
call
invoke
passing
the
the
only
handler
that
you
can
ever
have
as
an
argument.
G
H
H
And
we'll
we'll
sort
of
potentially
even
derive.
You
know
we're
right
now
we're
deriving
the
types
and
the
era
using
the
validation,
but
for
those
types
of
things
like
that,
but
you
could
potentially
even
derive
this
notion
of
groupings
of
arguments
that
are
valid
together
or
require
together
yeah
yeah.
H
But
actually
knows
that,
there's
a
missing
there's
a
missing
piece
of
context
here
and
oh,
maybe,
if
I
have
a
graph
with
a
whole
bunch
of
commands
right,
I'm
going
to
invoke
on
the
route
command.
So
if
there's
a
handler
that
corresponds
to
each
of
the
sub
commands,
which
might
be
arbitrarily
nested
deep,
like
in
the.net
CLI,
don't
add
package
I,
don't
know
at
this
point
in
time
whether
my
args
satisfied
on
that
ad
package
or
not
net
build.
H
K
H
What
I'm
do
if
you
have
a
command
with
no
handler
it's
in
balance,
so
it's
invalid
to
did
invoke
just,
for
example,
it's
in
violent
in
a
lot
of
command
lines
too
close
to
get
I
can't
just
say:
get
I
can
do
get
some
commands,
but
about
Nestle
a
lot
I
can
invoke
just
on
that,
and
that
will
give
me
information
right.
So
if
it
has
a
handler,
you
can
invoke
that
command,
regardless
of
whether
it
has
child
commands.
K
Then,
when
you
like,
when
you
we
keep
saying
you
have
command
in
some
command,
I'm
picturing,
you
know,
without
that
CLI
or
get
bored
any
of
the
utilities
that
can
keep
their
syntax
before
yeah.
For
the
normal
I
am
a
program.
I
do
one
thing:
I,
don't
care
about?
Are
zero
I
just
want
my
arguments
that
do
stuff?
Is
that
still
command
like
because
I
don't
feel
like
I'm
building
a
command?
At
that
point,
I'm
I
mean
that's.
K
B
C
H
So
that's,
but
so
a
good
example.
There
would
be
so
you
would
need
recommend
in
that
particular
example.
It
was
in
the
word
file.
The
movement
doesn't
need
a
name,
so
that
was
kind
of
like
one
of
the
things.
That
was
a
mistake
inside
the
word
document.
That's
one
of
the
distinctions
that
through
command
doesn't
need
a
name
because
we
know
the
name
based
on
the
invocation.
You
can
supply
a
name,
and
that
has
implications
for
how
we
render
out,
but.
H
Can
also
say
Newcombe
a
new
clan
if
you
want
their
fungible,
but
if
you
say
command
is
required
on
a
name,
that's
really
different
and
then
the
child,
you
know,
objects
that
you
put
in.
There
are
defining
your
options,
arguments
which,
in
your
case,
you
have
to
put
one
argument.
That
would
be
an
int
1
argument
evaded
we've
done,
but
in
that
simple
case,
that's
kind
of
a
smooth
spot
for
the
dragonfruit
experiment,
which
is
you
have
a
strongly
typed
main
you
don't
care
about
any
of
the
parser
objects
at
all.
B
Don't
have
been
a
special
validation,
yeah
there's
a
few
other
things
that
go
in
along
that
line.
It's
easy
to
that
that
app
model
was
was
really
it
was.
It
was
a
prototype
of
proving
out
the
notion
of
app
models.
It
is
extremely
useful
until
you
hit
the
world
you
really
at
the
walls
in
those
things
and
we've
managed
to
get
through
health,
which
in
tab-completion
set
or
suggestions,
we
wrote
there
and
then
the
basic
operation.
That's
what
we
go
through
we're
not
if
you
want
a
default.
One
can
still
do
that.
B
G
L
H
Think
we
could
do
that.
We
didn't.
We
didn't
know
that
next
step
with
everything
in
terms
of
the
design
we
in
some
ways
it
was,
was
able
to
say,
what's
the
simplest
thing
we
can
do,
does
the
underlying
API
Lowe's
build
that
thing
with
all
the
bells
and
whistles,
and
then
we
kind
of
stop
there
with
it,
but
yeah
that
would
absolutely
possible
I.
H
Think
the
question
that
is,
how
do
you
design
the
interface
if
I'm
supposed
to
use
many
I
understand
man
is
mean
and
the
jump
from
string
args
to
strongly
typed
arguments
was
pretty
into
it,
but
multiple
mains
maybe
isn't
as
intuitive
how
to
represent
some
of
the
man's,
maybe
not
how
to
configure.
You
know
like
the
validation.
We
didn't
really
go
to
that
next
step
and.
B
We
think
that
there's
some
really
interesting
other
app
models
and
one
of
which
is
there's
there's
a
couple
ways
to
do
it,
but
basically
having
a
structure
that
represents
the
data
you
want
and
then
there's
a
couple
of
variations
of
this
approach,
and
so
you
hand
in
a
complex
type,
which
represents
the
tree
of
information
that
you
want
and
then
you're
able
to
query
that
later,
with
or
without
envelopes
in
place
within
that.
So
there's
there's.
B
We
thought
we've
done
a
lot
of
thinking
on
this,
but
in
terms
of
actually
getting
to
the
point
that
we
were
the
simple
one
we
could
put
out
and
not
be
a
lot
of
feedback
on
I.
Think
these
other
app
models
are
actually,
you
know
going
to
be
opinionated
in
ways
that
are
really
going
to
desire
a
lot
of
feedback,
and
we
haven't
yet
been
at
a
position
for
that
process.
B
I
think
we
are
now
so
I
think
getting
some
of
these
back
and
also
the
first
round
of
actually
trying
to
build
those
I
did
and
the
entire
code
base
got
thrown
away,
because
what
it
showed
was
that
we
had
some
real
weaknesses
in
the
underlying
API
in
order
to
build
out
models,
it
was
too
hard
to
build
the
app
model.
What
I
built
was
too
crazy.
Hard
and
I
wrote
it.
B
You
know,
don't
really
have
a
lot
of
opinions
on
it,
so
forgive
me
that
I
didn't
throw
it
away
to
be
mean
or
because
I
can't
write
code.
It
was
because
oh
wow
I
want
to
push
a
bunch
of
that
stuff
into
other
places,
and
then
we
haven't
gotten
back
to
that
question,
which
would
also
get
into
attributed
models,
get
talked
about
a
lot,
and
so
we
probably
need
an
attributed
model.
It's
the
way
people
think
so,
but
but
it
has
morals
so
I.
G
Really
would
love
to
see
the
dragon
fruit,
but
a
bit
more
expanded
like
if
it's
supported,
overloads,
I.
Think
it's
I,
don't
fully
understand
the
difficulty
with
like
you
know,
the
nested
commands
and
whatnot
and
I
try.
You
know
I,
you
have
so
much
experience,
I
trusted.
You
cannot
scale
past
that
point,
but
I
can
imagine
like
I
start
with
as
a
very
simple
program.
It
has
some
arguments
and
I
want
to
add
an
option.
G
Okay,
what
I
just
add
an
option:
keep
going
well
then
I
discovered
that
I
have
a
kind
of
branching
the
tree
correct.
It's
not
just
an
option
when
I
just
create
a
second
main,
and
now
it
has.
You
know
slightly
different
types
and
you
match
which
one
you
call
and
then
I
do
my
thing
in
domains
and
of
course
they
wouldn't
be
Maine's.
Yeah.
C
G
C
G
C
B
Issue
I
think
for
this
we
could
largely
a
lot
of
those
nuances
are
not
going
to
be
there
I'm,
not
too
worried
about
that.
My
concern
is
actually
then
I
personally
would
really
be
hesitant
to
do
that
until
I
also
had
a
really
good
song
Khmer
story,
because
I
think
that,
from
a
user
point
of
view,
in
most
cases
it's
the
problem
with
get
in
most
cases
for
users
that
are
coming
to
the
CLI
they're
not
going
to
make
the
investment
in
it.
B
You
get
that
there
is
a
reason
that
you
have
either
an
integer
or
boolean
in
most
cases
and
stating
that
as
a
sub
command.
This
is
what
we
went
into
ml
net
and
they
wanted
to
do.
You
know
20
different
options
and
all
these
complex
things
does
it.
Actually
what
they
need
to
do
is
grab
them
with
a
sub
command,
and
it
made
a
much
much
Singers
I
see
a
lot,
so
I
find
doing
what
you're
suggesting
I
would
just
want
to.
B
At
the
same
time,
we
had
a
good
sub-command
story,
so
you
could
choose
between
it
and
I
could
lay
out
the
reasons
you
would
want
to
be
one
or
the
other,
because
I
think
there
are
good
cases
for
both,
but
I
think
the
sub
command
story.
Sort
of
is
the
one
to
lean
into.
Unless
you
know
yeah,
that's
too
much
typing
people
really
aren't
gonna
want
to
do
that
and
then
use
the
the
other
story.
They
pick
an
integer.
A
boolean
and
Colin
is
strongly
typed
in
those
two
types
of
strings.
H
J
C
B
H
Probably
is
that
makes
closest
yeah.
You
can
set
the
name
property
on
it,
yeah
that
will
have
ever
helped
and
it
will
look.
It
will
also
give
it
a
hint
if
you
want
to
parse
a
whole
string
input,
so
you
want
to
go
back
through
a
log
file
and
parse.
All
the
inputs
like
this
or
you've
got
a
command
line
here.
You're
writing
up
grapple
or
things
like
that's
right.
These
scenarios
are
support.
H
So
here
you
can
see,
you
know,
the
command
result
is
the
command
that
was
invoked.
So
if
you're
in
a
hierarchy
of
subcommands
commanders
I'll,
give
you
that
route
command
is
that
we
can
use
order
to
contribute.
So
everything
from
that.
What
you're
asking
about
you
notice
is
unmatched
and
on
parsed
opponents,
so
unpassed
tokens,
our
things
where
you
said
and
everything
after
that
is
on
our
stones,
right,
dotnet,
Ron,
everything
after
that
gets
passed
along
to
the
application
that
you're
building.
A
H
Only
negative
space,
yeah
yeah,
it's
the
posix,
operants
yeah,
everything
after
this
is
operates.
Yeah
unmatched
tokens
are
things
that
didn't
match,
something
that
you
defined
inside
of
the
grammar
for
your
CLI,
but
and
you
can
on
a
command
my
command
basis.
You
can
say,
consider
these
to
be
errors
or
don't
so
what
we're
doing
in
a
lot
of
cases
dotnet
build.
For
example,
dotnet
build,
has
some
quantum
tokens.
It
knows
about
it'll,
parse,
those,
but
then
unmet.
It
says,
don't
error
on
match
tokens.
Anything
we
don't
match.
H
C
And
I
think
you
ended
up
fixing
it
somewhat
when
I
talked
to
you
last
time
was:
if
you
have
a
option
with
arity
one
or
more
options,
then,
and
that's
the
last
one
you
specify,
then
you
can
get
into
a
confusing
case
where
it
interprets
everything
after
that
as
options
rather
than
as
on
parse
tokens
right.
That's
a
painful.
D
K
So
one
piece
of
feedback-
oh
I'll,
give
four
images
when
you,
when
you
exceed
the
complexity,
the
Dragons
we
can
do
switch
to
the
manual
is
have
a
very
good
story
of
this
is
how
you
build
the
tree
representing
exactly
what
we
were
doing
for
you
at
that
time,
because
or
an
analyzer
that
does
the
automatic
yeah
like
something
needs
to
give
you
the
code
of.
If
you
do,
this
you're
in
the
exact
same
state
you
were
with,
but
dragging
through,
because
like
I
dealt
with
asp.net
is
two
and
two
or
three
one:
no
conversion.
B
A
One
thing
that
we
should
talk
about
is
the
UX
study.
I,
think
I
mean
in
the
end
of
that,
gets
you
all
when
you
think
you're
ready
to
the
UX
study.
The
thing
is
that,
depending
on
how
you
set
it
up,
the
one
thing
you
want
to
be
really
make
sure
is
that
when
you
have
like
four
or
five
scenarios,
and
then
people
fail
at
scenario
one
then
very
often
they
can
two
to
three
or
four
or
five,
because
they
tend
to
be
building
on
top
of
each
other
at
least
partially.
A
So
you
really
need
to
make
sure
that
people
have
a
very
high
chance
of
succeeding
in
scenario
if
they
can't
find
your
court
I'd
pretty
much.
The
rest
of
the
study
is
not
very
insightful
anymore
and
then
the
second
four
minutes,
like
you
know,
we
need
to
talk
about
how
you
get
the
people,
because
in
the
past-
and
we
do
this
with
those
external-
you
get
very
mixed
bag
of
people.
That
I'm
also
not
sure
super
insightful,
but
I
mean
we.
We
now
of
Twitter
another
ways.
A
Even
on
the
team,
we
can
have
a
bunch
of
people
that
I've
never
seen
the
API
and
give
you
feedback,
which
is
the
first
step,
as
always,
I
think
more
interesting
than
you
know,
a
blog
post
with
with
comments,
because
you
actually
have
somebody
in
depth
that
you
can
observe
and
very
often
when
you
don't
know
what
the
answer
is.
Yet
you
you
know,
the
names
are
not
ideal,
but
then,
when
you
see
what
people
are
actually
searching
for
you,
okay,
then
maybe
Pope.
A
You
know
four
or
five
people
look
for
a
name,
starting
with
that.
Maybe
we
should
have
that
as
a
prefix,
but
very
often
you
can
actually
find
answers,
but
just
observing
people,
but
then
you
know
again,
like
you
will
get
the
study,
you
will
get
the
study
results
and
then
you
know
you.
You
basically
know
like
how
far
you
are
from.
Can
somebody
succeed?
You
know
parsing
a
command
line,
app
the
text
and
three
arguments
and
random,
as
the
file
name
is
required,
is
optional
right
and
the
answer
is
nobody
can
do
that
then.
A
B
C
A
Oh,
your
XID
is
like
usually
an
hour
long
right
right
and
you
have
like
five
scenarios,
which
means
usually
the
first
one.
You
expect
most
people
to
succeed
within
five
to
ten
minutes
right,
they've
after
five
to
ten
minutes.
They
still
don't
see,
lighted
in
above
the
town,
that's
probably
pretty
bad
and
we
actually
had
people
fail
entirely
on
scenario
one,
but
for
the
most
part,
that
was
because
they
were
totally
an
experienced
developers
but
like
for
the
most
part
like
if
I
would
say
for
any
API.
A
If
a
person
trying
to
find
the
core
entry
point
in
your
API
after
10
minutes
and
browsing
object,
browser
failed.
That's
a
problem
of
the
API.
Thank
you,
because
that
is
the
number
one
thing
because
usually
when
they
find
the
core
type,
then
intellisense
will
you
know
advertise
other
other
concepts
to
them.
They
usually
are
able
to
then
stumble
their
way
at
least
somewhere
right.
If
they
can't
find
the
cordoning,
then
you're
kind
of
screwed.
Sorry.
A
The
repo,
no
because
that's
the
whole
point
right
I
mean
like
II.
Yes,
it
is
true
that
once
we
have
documentation
and
Stack
Overflow
people
will
just
copy
and
paste
snippets.
But
then
the
question
is
still:
if
I
show
you
a
snippet
that
I
already
wrote,
if
the
names
don't
make
sense
to
you,
it's
still
a
magic.
You
know
spell
incarnation
kind
of
thing:
we're
like
okay,
sure
that
works,
but
I,
don't
know
why
it
works.
I,
don't
know
how
it
works
and.
A
G
Because,
usually
sample
is
approximation
of
what
little
ones
not
exactly,
but
one
comment
I
would
have.
So
if
we
agree
with
the
philosophy
of
we
have
a
low-level
API
that
is
optimized
for
flexibility,
meaning
if
I
want
to
write
a
parser
I
will
be
able
to
and
high-level
API
for
the
opinionated
majority.
You
know
80%
scenario,
it
seems
like
the
study.
Should
you
should
study
the
opinionated
ABI,
not
the
low-level
idea.
I
am
today.
It
seems
like
the
study
is
designed
to
test
the
low-level
idea.
B
And
I
think
that
that's
inside
the
God
and
is
partially
I
think
driven
by
some
thoughts
we
had
in
the
past
that
are
now
updated
around
interacting
with
the
VCO
and
so
I
think
that
we
had
very
good
feedback
from
MIMO
and
others
early
on
that
your
API
should
be
more
useful
than
it
is.
We've
done
a
lot
of
work.
There,
we've
moved
it
to
where
we're
pretty
okay
with
it,
but
it's
still
too
hard
for
a
user
who
doesn't
want
to
think
about
a
parser.
A
Say,
though,
it
depends
on
your
level
right
low-level
cookies
I
mean
you
know.
Utf-8
Jason
reader
was
like
structs,
which
is
hard
to
use
or
an
API.
That
is
just
slightly
more
verbose,
but
still
easy
to
use
right
to
me.
The
difference
between
reading
food
and
an
idealistic
version
of
this
is
just
the
amount
of
characters
you
have
to
type
like
a
normal
user
that
has
I
don't
know
a
year
or
two
years
of
that
experience
should
not
find
this
code
to
write.
You
know
it's
usually
hard
or.
G
Hard
to
read
well,
but
so
now
you
I
think
what
you
just
said:
I
detect
that
you
think
this
is
the
mainland
scenario
yeah.
It
is
not
a
low-level
API,
so
it
may
be
a
valid
position,
but
I
think
we
as
a
team
should
decide.
Is
there
low-level
API,
really
long
level
for
writing
higher-level
models
or
we
expect
developers
to
use
it
directly
to
implement
their
apps?
And
you
know
like
fan
and.
B
You
say
three
levels,
which
would
be
unfortunate
from
point
of.
There
is
a
very
low
level.
You
know
we're
here,
you're
deep
in
the
weeds
and
you're
doing
some.
You
know
you're
doing
intense
validation,
you're
wandering
around
the
tree
to
do
some
intense
validation,
there's
some
stuff
that
you
can
come
up
with.
It's
gonna
be
low
level,
no
matter
what
and
we're
going
to
have
some
dragons
or
solutions,
this
kind
of
rests
in
the
middle
right.
G
And
I
suspect,
if
we
want
the
low
level
API
to
be
ultimately
flexible,
like
the
goal
is
any
syntax
that
I
have
in
my
existing
comment
that
I
need
to
be
able
to
represent
it.
It
will
be
complicated.
You
will
not
like
it
will
never
be.
You
know,
official
to
use
and
understand.
Well,
it
will
literally
be
a
person
foreigner
literally
grammar.
You
will
be
able
to
write
their
programming
language
in
its
static
methods.
K
C
G
Worries
me,
because
you
see
this
is
the
problem
with
sometimes
people
trying
to
create
low-level
API
and
make
it
simple
is
that
when
code
is
already
written,
it
all
looks
simple.
The
problem
is:
if
I
now
want
to
write
the
code,
I
go
to
the
namespace,
I,
see
50
or
60
times,
concepts
that
I
cannot
understand
and,
like
writing
call
discard,
reading
call.
Yes,
if
somebody
already
knows
how
to
do
it,
how.
A
Developer
right
I
mean
it
is
true
that
anybody
who
does
compiler
stuff
tends
to
be
warned
the
advance
side,
because
you
have
to
have
a
working
model
on
what
the
thing
does
that
you're
looking
at
and
any
sort
of
second
alysus
I
mean
if
you
can
effects
coop
or
CCI
like
it,
is
a
very
specialized
crowd,
but
it's
not
the
average
guy,
but
I
would
say
the
one
concern
I
have
of
command
line.
Parsing.
Is
that?
A
Even
if
you
say,
even
if
you
polish
dragon
food
more
I,
think
what
will
end
up
happening
is
that
it
will
be
a
convenience
thing.
I
think
there's,
there's
too
much
stuff
in
the
wild
that
you
have
to
do.
That
will
be
very
hard
to
express
programmatically
at
that
level,
which
means
that
a
good
chunk
of
a
people
will
have
to
work
with
the
what
you
consider
low.
G
Level
API
you
like
that
idea
that
Jeremy
had.
Basically
you
start
with
dragon
fruit,
you
we
add
overloads
and
maybe
some
other
things
that
we
discovered
that
you
know
people
want
to
do
in
common
scenarios
right
and
then,
when
you
run
into
a
wall,
you
run
a
tool
on
your
program
and
it
generates
this
code.
And
then
you
keep
going
with
the
local
API
I.
Think
that
would
be
very
nice
end
to
end
story.
It.
A
Would
be
but
I
mean
to
me,
you
draw
a
line
right
if
you
look
at
sequel,
command
versus
EF.
There's
also
two
philosophies.
Some
people,
just
don't
like
you
know,
entity
binding
the
reflection
right.
They
just
want
the
expressiveness
of
I
arrived,
my
secret
behind
I,
invoke
the
command
and
I
would
say
the
kuwaiti
or
event.
Api
is
there's
like
four
concepts.
They
are
easy
to
do.
Okay,
they're
not
complicated
to
use
per
se.
It
just
means
that.
A
G
It's
because
we
deem
some
API
love
level
yeah.
We
shouldn't
poocho
stability
yeah.
What
I
was
saying
I
if
I
might
make
feedback
from
this
overview,
which
was
great,
was
I,
think
we
should
focus
a
lot
on
the
opinionated
built-in
easy
to
use
API
right
now.
The
future
seems
to
be
like
you
know,
it's
super
flexible.
It's
designed
for
very
powerful
tools,
like
our
CLI
I.
Think
somebody
who
just
writes
a
very
simple
console
up
and
wants
three
parameters
would
be
better
I
mean
who
would
prefer
to
have
something
like
the
dragon
fruit?
B
B
I
do
tend
to
think
that
grabbing
some
hiring
people
from
this
building
to
look
at
the
API
level
and
see
whether
they
can
figure
it
out
would
be
useful.
I've
already
looked,
there's
a
rename
of
something
that
I'm
going
to
suggest
to
John
after
this,
so
it's
been
a
ton
of
things
have
come
out
of
this.
That's
extremely
helpful,
but
I
think
giving
it
to
users
from
the
agency.
That
brings
us
people
right
now.
B
That's
probably
not
the
most
useful
thing
until
we
do
have
a
better
idea
of
the
high
level
of
opinion
they
make
you
guys
and-
and
it's
it's
consistent
with
what
we
hear
away
from
the
community.
Dragonfruit
has
all
sorts
of
good
feedback,
and
people
that
are
using
it
command
lines
have
had
a
very
good
feedback.
We
have
we've
got
200,000
downloads
of
January
4th
I.
B
Do
not
understand
how
that
happened,
to
be
honest,
because
we
had
300,000
on
the
old
version
and
we
changed
the
name
and
we
have
200,000
since
we
changed
the
name
on
my
father.
So
when
people
are
using
it
and
they're
not
giving
us
a
lot
of
feedback,
accept
it
so
much
the
people
look
during
food,
so
everyone's
want
to
treat.
If
somebody
goes.
Oh.