►
From YouTube: UCF TAC Meeting 2021 10 28
Description
UCF TAC Meeting 2021 10 28
To learn more about critical open source JavaScript projects like Appium, Dojo, jQuery, Node.js, and webpack, and 27 more checkout The OpenJS Foundation: https://openjsf.org/
A
A
A
A
All
right,
let's
begin
to
this
month's
UCF
tech
meeting,
we
have
a
light
agenda.
A
A
So
on
the
project
transfer
site
for
the
remaining
best
GL
Frameworks,
we
had
a
pretty
full
for
conversation
last
two
weeks
ago
with
the
new
OS
officer
from
Uber.
She
is
being
pointed
out
to
the
UCF
board
she's,
calling
to
restart
the
process
of
the
remaining
with
sgo.
Should
you
need
to
familiar
herself
with
its
current
was
what
has
been
left
off
from
Bryce
here,
but
she's
she's,
very
encouraging
and
in
terms
of
helping
us
to
get
the
Frameworks
open
sourced
into
the
UCF
organization?
A
So
let's
go
to
here,
and
we
will
give
you
guys
updates
once
we
hope
hear
back
from
her
later.
C
Yes,
so
we
are
so
we
recently
released
the
xjla
8.6,
we're
pretty
deep
into
the
you
know,
textual
V8
psycho,
and
they
will
likely
be
some
more
minor
releases,
but
the
work
is
also
ongoing
on
the
the
next.
The
next
major
version
and
the
the
main
thing
that's
going
to
drive.
That's
going
to
create
breaking
changes
is
web
GPU
and
obviously
the
work
starts
in
Lu
maggiers,
say
today,
webgl2
framework,
a
way
to
work
with.
C
You
know
fairly
closely
to
the
GPU
fairly
closely
to
the
webgl
to
API,
and
now
we
need
to
you
know,
change
Luma
GL,
so
that
we
can
also
support
you
know
in
addition
to
webgl,
we
can
also
support
web
GPU.
So
the
idea
is
that
we
will
support
both
yeah
I'll,
probably
come
back
to
that
a
little
bit
later
in
next
slide.
B
C
So
and
I
think
the
we'll
see
if
we
actually
launch
web
GPU
in
the
first
version
of
of
B9
or
it's
more,
a
question
of
enabling
going
through
the
API
and
making
adjustments
to
the
API
so
that
we
can
plug
in
a
web
GPU
and
then
there's
a
number
of
other
things.
Also
that's
happening,
there's
a
lot
of
change
in
the
in
the
JavaScript.
You
know
ecosystem.
We
have
this
new
ecmascript
modules,
where
you
can.
C
If
you
build
your
package,
your
modules
in
a
different
way,
you
can
actually
dynamically
import
them,
so
you
can
do
something
like
a
way
to
import,
which
means
that
you
don't
have
to
bundle
code.
You
can
you
can
dynamically
load
things?
You
can
load
loaders
from
loaders
to
your
layer
modules
and
so
on
dynamically,
when
the
application
needs
them,
rather
than
bundle
everything
up
front
and
that's
definitely
something
we
want
to
support
and
also
there's
much
more
modern
build
tooling
is
built,
is
up
to
100
times
faster
than
webpack.
C
With
is
also
something
that's,
you
know
used
also
much
faster
tool,
for
you
know,
setting
up
examples,
and
so
on
so
most
likely
we'll
do
something
in
that
area.
C
D
Yeah,
so
do
you
want
to
do
the
your
web,
GPU
stuff
and
then
come
back?
Yeah
I
think.
C
It's
best
to
continue
so
so
what's
happening
with
web
GPU,
so
it's
been
development
for
about
four
years
and
we
actually
over
a
year
ago
we
did
a
the
actual
native
experiment
where
we
did
a
C
plus
plus
a
version
of
the
xgl
that
worked
on
on
web
GPU,
but
it's
becoming
it
has
been
available
under
a
flag
in
Chrome
for
a
while
and
I
believe
it's
now
available
in
origin
trials.
C
So
if
you
it's
not,
if
you
register,
if
you
get
your
url
registered
with
chrome,
you
can
you
can
enable
it
they're
still
doing
final
Security
reviews
on
it,
and
my
understanding
is
that
it's
expected
to
they're
expected
to
remove
the
restrictions
in
Chrome,
v99
and
I.
Don't
have
the
exact
date,
and
my
guess
is
that
this
will
be
in
q1
of
next
year
and
it
would
of
course
be
wonderful
to
have
Day
Zero
support
for
web
GPU
and
xgl
there's
a
lot
of
experimental
code
in
branches.
C
But
there's
you
know
a
bunch
of
work
both
getting
that
getting.
You
know,
rfcs
discussions,
reviews
and
then
these
breaking
changes
in
the
apis
has
to
be.
You
know
layers-
and
you
know
various
types
of
shaders
and
so
on-
have
to
be
updated
because
there's
substantial
amounts
of
work,
there's
quite
a
bit
of
changes
needed
in
the
Luma
GL
API,
but
the
changes
to
the
xgl
should
be
quite
small,
so
we're
not
trying
to
make
it
we're
not
trying
to
kind
of
shoehorn
web
GPU
into
the
webgl
model.
C
That
would
be
too
constraining.
So
we
can't
make
it
completely
non-breaking,
but
but
of
course,
we're
carefully
considering.
How
can
we
minimize
the
breakage
and
the
kind
of
annoyance
for
applications
if.
A
C
Yes,
so
you
know
so
web
do
so
so
gpus
are
evolving
and
the
candle
Shader
programming
model
is,
is
evolving
and
has
been
evolving
over
the
years
and
openg
and
webgl
is
based
on
opengl,
which
is
25
almost
30
year
old,
procedural,
API
and-
and
you
know
it's
gotten
to
a
point
where
it's
no
longer
there's
so
many
inefficiencies
and
so
much
of
an
impedance
mismatch
between
the
opengl
API
and
the
new.
C
The
way
that
gpus
work
today
and
GPU
drivers
work
today
that
there
was
a
need
for
a
new
API,
and
this
is
not.
This
has
happened.
So
you
know
indirect
in
the
Microsoft
World
you've
moved
to
DirectX
12.
Apple
has
created
the
metal
API,
the
rest
of
the
communities
welcome,
and
so
those
are
all
three
examples
of
Next
Generation
apis.
They
all
have
exactly
the
same
ID
as
exposed.
The
new
GPU
models
you
can
think
of
you
know.
C
Webgl
is
a
wet
blanket
that
sits
on
top
of
the
GPU
and
and
Hikes
a
lot
of
the
capabilities.
One
thing
that
you
know
there's
many
things
that
come
from
from
web
GPU,
but
you
know
you
can
now
you
can
create
proper
compute
shaders
and
those
computers
can
have
work
groups
and
they
can
do
non-local
access
and
have
storage
buffers
and
so
there's
completely
new
capability
on
on
compute,
but
the
entire
API
is
also
designed
in
a
way
that
it's
you
know,
the
objects
are
much
more
static.
C
You
create
the
different
things
like
textures
and
buffers
and,
and
you
know,
shaders
and
and
their
remote
you're,
creating
immutable
objects,
and
so
there's
a
lot
less
validation
and
eventually
these
objects,
the
GPU
objects,
will
actually
you
can
actually
transfer
them
between
threads
because
they're
immutable,
that's
not
in
the
first
version
of
of
web
GPU,
but
it's
it's
kind
of
prepared
for
that.
C
So
you
could
really
create
multi-threaded,
GPU
applications
and
it's
just
a
variety
of
small
improvements
across
more
data
types
in
shaders
and
more
more
capabilities
so
and
a
lot
less
overhead.
The
appearance
designed
so
that
this,
this
very
constant
parameter,
validation
that
happens
is
was
removed.
D
I
think
I
was
wondering
about
you
know
if
so
right
now
like
when
we
work
on
extensions
for
deck
GL
and
we're
adding
new
attributes
to
the
shaders,
we
we
hit
a
limit
of
I,
think
16
attributes
or
something
like
that.
Do
you
know
if
web
GPU
kind
of
unlocks
additional
enhancements
on
that
Vector,
where
you
know
we
can
do
better
extensions
and
add
more
attributes
to
our
shaders
and
and
so.
C
That
is
so
that's
so
the
size
of
the
you
know
attribute
bank
is
a
it's
a
characteristic
of
the
GPU,
and
what
these
apis
do
is
that
they
tend
to
sit.
They
Define
a
minimum
minimum
limit
and
that
definition
of
that
minimum
limit
is
set
in
a
way
so
that
it
would
cover
all
reasonable
devices
and,
as
far
as
I
know,
that
has
not
been
raised.
D
C
In
web
GPU
so
I
mean
if
the
GPU
has
more
at
you
know
a
bigger
attribute,
Bank
you
should
be
able
to
access
it,
and
the
same
is
true
in
in
in
it
should
be,
should
be
true
in
webgl
right,
but
you
know
I
think.
C
Basically,
if
you
look
at
the
the
conclusion
is
likely
that
if
you
look
at
the
cross-section
of
the
gpus
that
you
would
access
on
on
the
devices
that
you
know,
there's
still
a
lot
of
gpus
out
there
that
we
want
to
address
that
only
have
16
attributes
in
there.
D
C
C
You
know
it's
it's
a
big
Four
Element
vectors
of
floats
right,
and
so
you
really
have
each
attribute
is
16
bytes
right,
four
by
four
floats,
and
so
you
can
pack
like
booleans
and
other
things
into
bytes
and
bits,
and
so,
if
you're
willing
to
mess
up
your
Shader
code,
you
can
usually
get
quite
a
lot
of
stuff
into
in
into
you
know.
C
If
you're
not
into
leaving
them,
then
you're
leaving
a
lot
of
the
of
the
what
is
called
the
vertex
array,
Bank
unused
right.
So
so
yeah
I
mean
it's
a
it's.
Unfortunately,
that's
not
a
problem.
The
short
answer,
unfortunately,
yes,
not
so
by
webdp,
okay,.
C
Yeah
I'm
doing
a
lot
of
this
work
right
now
and
I.
Don't
have
a
lot
of
help,
so
I
can't
and
I
also
have
other
day
work
to
attend
to
so
obviously
I
I
feel
it
will
be
hard.
You
know,
I
mean
it's
very
important
for
a
framework
like
the
xgl
to
be
to
be
part
of
this
Evolution
I
think
it'll
be
I,
think
it's
quite
important
that
we
that
we
get
web
GPU
in
there
and
if
anyone
is
interested
in
collaborating
participating,
helping
out
that'd
be
great.
D
Do
you
know
if
web
GPU
enables
like
future
VR
or
you
know
other
enhancements?
Do
you
know
if
trying
to
understand
kind
of
the
future
of
web
GPU
like
where
is
it
going,
and
where
do
you
see
that
going
into
does
it
unlock
additional.
C
Yes,
I
think
they
you,
you
will
see,
I
mean
we're
seeing
already
I
mean
if
you
you
can
to
get
a
sense
for
it.
You
can
look
at
something
like
welcome
and
just
like
you
know,
opengl,
you
can
see
that
you
know
opengl
grew
over
the
years
with
extensions
and
then
they
made
new
major
releases
and
they
Incorporated
some
of
those
just
extensions
into
the.
A
C
The
extensions
are
driven
by
by
developments
on
the
GPU,
so
one
big
thing
that's
happening
is,
for
instance,
Hardware
rage,
racing
and
Balkan
already
has
extension,
for
you
know
accessing
Hardware,
Ray
tracing,
and
so
it's
reasonable
to
to
assume
that
at
some
point
we're
going
to
get
extensions
in
web
web
GPU
that
will
allow
you
to
access
Hardware,
Ray
tracing.
You
know
we
don't
have
support
for
64-bit
computations
on
shaders,
but
you
know
most
likely
that
will
come
as
an
extension
to
to
web
GPU.
C
D
A
Yeah,
that's
something
that
you
know.
I
was
just
gonna
ask
because
as
we're
slowly
moving
a
lot
of
the
data
transformation
and
statistics
into
gpu-based
calculation-
and
they
are
definitely
still
limitations.
Currently,
at
least
when
we're
trying
to
look
at
you
know
what
kind
of
Statistics
you
can
do
anything
with
sorting
it's
a
it's
a
now
starter,
but
I
would
like
to
know
if
there
will
be
more
native
support
and
then
some
of
the
limitation
can
be
unblocked
by
web
GPU.
C
If
you
can
draw
this
big
circle
of
all
the
algorithms
you
can
Implement
in
a
CPU
and
then
like
you,
can
implement
the
subset
of
those
algorithms
on
a
GPU
you
know,
and
if
you're
all
you
have
is
the
webgl,
you
know
glsl,
you
know
webgl2
model,
you
can
only
Implement
a
very
small
set
of
those
algorithms
and
with
these
GPU
shaders
you
have
a
bit
more
capability
and
you
can
Implement
look
a
slightly
bigger
set
of
so
you
know,
I
mean
there's
no
reason
for
us
not
to
to
yeah
and
there's
a
lot
of
interesting.
C
You
know
I
mean
there's
so
many
details
we
can.
We
can
come
back
and
and
provide
more.
C
Yeah
I
mean
this
is
just
saying
that,
but
basically
you
know
we're
we're
making
the.
A
C
C
We
try
to
provide
a
common
API
for
for
working
with
both
webgl
and
web
GPU,
but
it
would
probably
look
more
than
like
web
GPU
than
than
webgl,
so
the
current
human
GL
API
is
very
webglish
intentionally,
but
web
GPU
apis
is
more
modern
and
so
they're
a
good
parts
of
that
API
that
we
probably
want
to
incorporate.
D
Hey
so
yeah
Hubble
gl's,
like
a
video
rendering
Library,
that's
probably
one
of
the
most
recent
additions
to
to
you,
know
the
visgl
and
the
different
Geo
libraries
that
we
have
and
so
release
I
just
released
a
1.3
version
which
really
focuses
on
kind
of
the
stability
and
the
inner
workings
of
the
library
which
have
some
really
nice
external
benefit.
D
You
know
feature
benefits
that
I
listed
here
that
I
wanted
to
just
quickly
go
over
one
of
the
one
of
the
largest
kind
of
out
of
the
gate
features
that
people
want
and
expect
from
a
JavaScript
library
is
that
it
works
with
more
than
just
react
and
previously
for
a
variety
of
reasons.
D
It
was
very
much
tight,
Hubble
gl's,
rendering
engine
was
very
much
tied
to
reacts
rendering
engine,
but
now
it
supports
pure
JS,
and
also
we
released
that
Standalone
bundle
where
you
can
just
inject
Hubble
GL
into
the
global
window.
Namespace
like
like
the
deck
GL
light
and
Luma
GL
light
bundles.
We
have,
and
so
those
also
have
new
examples
that
you
can
check
out
if
you
want
to
see
how
they
work.
D
But
now,
from
now
on,
we'll
be
supporting
react,
purejs
and
the
Standalone
bundles
in
LGL,
so
that
you
can
use
that
code
in
any
framework
any
or
no
framework
at
all.
D
Another
really
interesting
feature
was
the
ability
to
load
a
ton
of
data
in
between
capturing
video
frames
or
image
frames
in
Hubble
GL.
That's
now
something
that
that
Hubble
GL
will
wait
for
it'll,
wait
for
decgiel,
asynchronous
data
to
load
and
also
base
map
data
to
load.
D
So
if
you
move
the
camera
very
quickly
and
it
needs
to
load
a
new
satellite
imagery
or
something
it
will
wait
to
for
that
data
to
load
before
it
actually
takes
the
screenshot
of
the
of
the
frame
and
that
can
be
expanded
further,
since
it's
an
exposed
flag
to
other
asynchronous
data
that
that
people
using
the
library
might
have
and
be
loading
in
unrelated
to
base
maps
and
unrelated
to
deck
GLS
built
in
async,
but
they
might
be
using
their
own
external
async.
D
And
so
you
know
you
could
imagine
you
can
imagine
wanting
to
do
a
Time
series.
Video
of
you
know
years
worth
of
data
where
each
couple
of
frames
is
actually
like
a
gigabyte
or
more.
D
You
know
worth
of
of
data
in
that
frame,
and
you
would
basically
load
in
all
that
data
capture
the
frames
you
need
with
that
data
and
then
unload
that
data
and
load
in
the
next
one,
and
that
could
all
be
now
driven
internally
by
this
by
this
waiting
feature,
and
so
there's
there's
some
really
interesting
applications
of
of
this
Beyond,
just
the
kind
of
intuitive
ones
where
you
might
have
tile
data
that
you
need
loaded,
there's
there's
much
more
than
that
too.
D
That
can
be
done
so
I'm
excited
to
see
what
people
do
with
that.
Also
animations
can
now
be
updated
during
runtime.
That's
one
of
those
internal
refactors
that
that
led
to
this.
So
now
you
know
previously,
the
idea
was
most
animations
would
be
defined
statically
when
the
page
loads,
and
then
there
wasn't
very
great
support
for
allowing
the
user
to
modify
every
aspect
of
the
animation.
Certain
aspects
are
very
easy
to
modify,
but
other
aspects
were
very
difficult
and
there
wasn't
a
very
consistent
way
of
doing
it.
D
So
now
it's
very
consistent
and
you
can
actually
layer
on
mult
like,
for
instance,
like
you,
you
can
layer
on
multiple
animation
instances,
which
means
maybe
you're
using
a
combination
of
libraries
and
things
that
you
want
to
be
managed
by
the
animation.
So
let's
say
you
could
simultaneously
use
a
deck
GL
instance
on
its
own,
with
the
kepler-gl
instance
on
its
own
or
maybe
you're,
just
trying
to
animate
a
HTML
element
on
its
own,
like
let's
say
a
video
player,
and
you
want
to
like
play
or
pause
or
move
that
video
tag.
D
You
know
HTML
tag
to
like
a
particular
frame
and
capture
it
that
all
those
different
elements
can
now
be
loaded
into
this
new
animation
manager.
That's
been
released
and
you
can
update
what
these
animation
definitions
are
before
you
hit
render,
but
like
during
kind
of
like
you
want
in,
like
a
user
interface
kind
of
when
you're
setting
up
an
animation
or
render
so
it's
pretty
interesting.
D
You
could
always
render
a
video
and
it
would
download
to
your
computer,
but
now
you
have
the
option
of
instead
getting
the
blob
or
the
you
know,
the
array
buffer
or
of
the
the
video
assets
or
the
GIF
or
the
zip
file
that
contains
like
image
frames
and
packing
That
Into
You
Know
in
embedding
it
into
your
website
immediately
after
render
it,
and
that
can
be
very
great
if
you
have
a
lot
of
data,
that's
rendering
that
doesn't
preview
well,
because
your
GPU
can't
keep
up
with
it,
but
you
want
to
kind
of
iterate
on
your
rendering
before
actually
downloading
it,
because
you
end
up
otherwise,
you
end
up
with
hundreds
of
things
downloaded
to
your
computer
that
are
kind
of
like
drafts
or
junk,
and
you
know
you
know
you
just
kind
of
what
you
really
want.
D
A
I
have
a
question
here
so
for
the
embedded
version,
so
at
least
previously
at
our
experience
of
using
it.
Is
that
if
you
have
way
too
many
frames
like,
if
you
make
it
like
more
than
10
seconds
of
a
video
and
then
usually
what
happens
is
that
you
browser
just
run
out
of
memory
to
save
all
the
frames
that
you
generated
and
then
just
crashes?
A
Would
that
be
well?
That
still
happens
if
it's
embedded.
D
A
D
Yeah
I
was
gonna.
I
was
gonna.
Add
that
a
very
similar
thing
you
know
the
what
I
personally
do
to
never
run
out
of
memory
on
my
browser
is
to
lower
the
frames
per
second
and
to
lower
the
resolution
during
during
kind
of
these,
these
for
longer
renderings
or
for
preview,
renderings
and
I
think
documentation.
Improvements
can
go
a
long
way
on
helping
people
learn
that
that
is
the
kind
of
the
technique
to
use.
D
But
what
would
be
ideal
is
if
someone
was
set,
you
know
set
up
the
rendering
settings
in
such
a
way
that
was
likely
going
to
to
overload
their
browser,
and
we
could
detect
that
ahead
of
time
and
warn
them
hey
wait.
You
don't
want
to
do
that.
D
That
would
be
ideal,
but
I
don't
actually
know
at
the
moment
for
all
the
different
file
formats
like
where
that
threshold
is
on
the
settings
like
we
could
throw
some
warnings,
maybe
on
settings
that
would
very
likely
destroy
any
computer
but
the
yeah.
So
that's
kind
of
that's
a
good
idea,
though,
on
on
being
able
to
lower
the
resolution
of
of
of
previews
and
I
didn't
list
it
here.
D
So
it's
so
you
there's
already
that
there's
already
a
demo
in
the
in
the
world
view
folder,
that's
in
1.3
of
where
you
can
basically
just
toggle
between
resolutions
at
runtime
and
it
works
perfectly,
but
we'll
be
bringing
that
into
the
library
in
1.4
and
using
it
in
in
more
components
once
that's
ready
and
then
yeah,
I
guess
the
last
thing
I'll
last
two
bits
are
about
just
the
animation
classes:
there's
new
animation
classes
for
ductile
and
Kepler
GL
animation.
D
So
you
can
keyframe
any
deck,
GL
layer
now
or
the
map
view
state
in
one
class,
where
you
define
the
layers
that
you're
going
to
be
animating,
the
keyframes
that
will
animate
those
layers
and
then
keep
yourself
animate.
The
map
same
thing
goes
for
Kepler
GL
filters,
layers,
trip,
timestamps
and
map
state.
So,
there's
a
consistency
now
on
on
how
to
define
library
or
framework
Integrations.
D
So
you
know
if,
if
there's
some
other
library
that
someone
wants
to
create
an
animation
class,
for
they
can
do
that
following
this
model
and
then
there's
react
components.
So
the
kepler-gl
export
has
been
like
polished
quite
a
bit
and
then
there's
a
render
player
component.
That
was
added
which
is
kind
of
what
you
can
use.
If
you
want
to
embed
embed
the
the
renders
and
not
write
that
component
yourself,
I
just
wrote
that
in
that-
and
so
you
don't
have
to.
A
D
Yeah,
maybe
it'd
be
more
accurate
to
say
visconfig,
since
it's
the
visconfig
that
can
be.
A
D
Keyframed,
so
that
that's
what
that
is
yeah
anything
that's
invis
config,
so.
A
A
Thank
you.
This
is,
this
is
great
I
think
we
should
also
plan
to
upgrade
to
the
complexity
next
spring
for
us
for
unfolded,
so
we
can
getting
some
of
the
improvements
on
there
too.
D
A
And
I
think
as
we
talk
about
we
will,
it
will
be
nice
for
the
keyframes
a
couple
of
filters
later
times.
Then
we
have
SIMPLE
uis
a
lot
of
people
to
edit
the
keyframes
I'm
sure.
Right
now
you
were
just
you
know,
adding
using
the
manually
coding,
the
keyframes
for
user.
It
would
be
nice
to
have
some
kind
of
UI.
D
Like
now,
you
can
update
the
animations
at
runtime,
but
there's
no
good
UI
examples
out
there
of
how
you
do
that
right
now.
So
that
would
be.
You
know,
kind
of
the
next,
the
next
step
for
the
library
to
to
start
to
to
explain
like
how
you
go
about
doing
those
kinds
of
things.
A
Okay,
great
thank
you
for
the
update,
I.
Think
that
just
conclude
our
meeting
today
for
the
next
meeting,
it's
going
to
be
somewhere
near
Thanksgiving
I
think
it's
gonna
be
the
Thursday
before
wait.
No,
actually
it's
going
to
be
on
Thanksgiving,
because
we
are
oh
we're
at
on
the
Thursday.
So.
A
Right
so
we
we
will
I'm
inclined
to
cancel
the
next
meeting
or
move
it
to
our
to
this
Thursday
after
Thanksgiving,
as
anyone
have
any
idea
or
suggestions
on
what
should
we
do,
I
think
I
just
appear
me
and
Christian.
D
Moving,
it
would
be
good,
I,
mean
I,
think
having
the
monthly
Cadence
is
good
if
we
want
to
move
to
after
Thanksgiving.
That's.
A
D
A
People
around
to
see
great
yeah,
because
the
for,
after.
A
B
A
A
All
right
so,
let's
I'm
gonna
move
the
meeting
to
for
the
essays
for
the
Thanksgiving
one
I'm
going
to
move
to
the
next
Thursday
after
that
and
we'll
talk
about
Christmas
when
it
comes.