►
From YouTube: Eclipse Theia and Che, explained and explored!
Description
You heard about Eclipse Theia and Eclipse Che, but did not find the time to learn more about those projects? You are interested in web-based tools, but do not know where to start? Then this talk is for you!
Eclipse Theia and Eclipse Che are two innovative projects to build web-based tools. In combination,you could consider them to be the next generation of the Eclipse tool platform or “Eclipse in the browser”. However, compared to previous Eclipse versions, getting started requires more knowledge. So far there is no simple download page, no executable to just launch a product and no wizard to create your first plugin.
In this talk, we provide an introduction to Eclipse Theia and Eclipse Che assuming zero previous experience. We show what those technologies can do for you and how they fit with each other. We demonstrate how to launch them, show the features they provide out of the box and how to get started as a user. Furthermore, we discuss the available options to adapt, extend and customize the frameworks to your own needs. Finally, we conclude with a technological overview, including the relation to Visual Studio Code and discuss potential deployment scenarios.
Speaker:
Jonas Helming
A
A
A
A
So
my
detail
goal
is
to
answer
the
question:
what
is
it,
what
are
the
core
features?
How
can
you
use
it?
I
will
show
some
demonstrations.
How
can
you
extend
it,
although
I
will
not
provide
too
much
technical
details
and
how
and
that's
an
interesting
question:
how
do
those
technologies
relate
to
each
other?
So
I
would
ask
a
relate
to
Thea
or
a
theory
later
vyas
code
and
what
are
the
connections,
so
my
hope
is-
and
my
goal
for
today-
is
that
you,
if
you
leave
the
talk,
you
have
a
better
understanding.
A
Okay,
how
to
use
those
technologies
are
the
interesting
for
you,
and
maybe
that
helps
you
to
select
among
the
other
talks
tomorrow
and
and
the
day
after
which
particular
framework
interests
you.
So
this
is
really
meant
as
a
beginner
talks
for
Thea
and
shape.
I
will
start
with
fear.
So
what
is
actually
accepts?
Thea
a
project
via
is
a
platform
for
building
web
based
tools
and
I
des
it's
very
similar
to
the
original
purpose
of
the
Eclipse
platform.
A
So
eclipse
has
been
invented
as
a
platform
for
building
tools
and
it's
exactly
the
same
purpose
for
web
based
tools.
So
the
idea
is
to
that
you
can
use
Thea
to
create
your
own
tools
or
extensions
based
on
that
now
there
is
already
a
name
confusion
there,
because
you
could
also
search
for
the
Thea
to
download
the
Thea
IDE.
There
are
some
products
available
based
on
fear,
but
you
can
actually
not
really
use
fear
itself.
A
I
mean
here's
a
platform
and
what
you
actually
use
our
products
based
on
fear,
although,
as
for
Eclipse
before
I
mean
eclipse
the
name
there,
there
were
double
meanings.
Eclipse
was
the
platform,
but
the
IDE
was
also
called
Eclipse,
although
the
formal
name
was,
for
example,
Eclipse
to
ADT
the
development
rules,
but
everybody
said
Eclipse,
and
the
same
is
true
for
Thea
now.
What
are
the
core
features
of
such
a
platform?
It's
also
very
similar
to
the
desktop
version.
A
First
feature
is
a
basic
work
frame.
It
provides
you
with
a
frame
where
you
can
place
views
like,
for
example,
a
file
explorer
a
terminal,
a
code
editor,
you
can
drag
them
around.
You
can
create
window
layouts,
you
have
a
menu.
You
have
commands
all
this
basic
frame,
exactly
what
Eclipse
provides
on
the
desktop.
Second
feature
is
also
similar
to
eclipse
a
modular
extension
mechanism
and
the
reason
why
this
is
so
important
is
it
allows
you
to
two
things.
A
One
is,
you
can
reuse
a
lot
of
existing
stuff,
so
there
are
already
a
lot
of
extensions
for
you
to
we
use
and-
and
you
can
add
your
own
extensions
on
top
of
that-
and
you
can
mix
those
two
groups
like
your
own
stuff
with
existing
stuff
like
you
are
used
to
in
Eclipse,
and
then
you
can
combine
those
two
to
a
product
which
then
fulfills
all
the
requirements
you
need.
This
is
only
possible
if
you
have
a
modular
extension
mechanism
and
the
desktop
world
for
Eclipse.
A
It
was
OSGi
via
has
its
own
modular
extension
mechanism.
Actually,
two
of
them
I
will
go
more
into
detail
about
that,
and
the
third
I've
already
covered
that
a
bit
there
are
common
tool,
features
already
implemented
for
you
and
the
platform
provides
them
again
similar
to
Eclipse.
So,
for
example,
if
you
want
to
build
a
tool
for
your
custom
language-
and
you
want
to
provide
it
to
your
customers,
you
also
want
get
support.
Now,
if
you
don't
use
a
platform,
you
have
to
implement
that
yourself.
A
If
you
use
here,
there's
already
an
extension
providing
good
support
and
you
can
reuse
that
same
is
for
a
debug
view
for
a
code,
editor
and
so
on.
So
the
benefit
of
having
common
features
available
in
combination
with
this
model.
Arity
allows
you
to
reuse
a
lot
of
stuff
and
therefore
lower
the
cost
to
develop
a
custom
tool.
Basically-
and
that's
the
purpose
of
such
a
plot,
now
simple
question:
how
to
launch
the
earth,
so
there
is
no
download.
A
You
cannot
just
download
an
executable
to
launch
the
I
mean
it's
a
tool
which
is
targeted
at
to
run
in
the
web.
You
can
actually
deploy
it
in
two
different
ways.
You
can
either
bundle
a
product
based
on
fear
with
electron
and
run
it
as
a
desktop
app
and
the
second
deployment
type.
Is
you
deployed
in
the
cloud
and
then
access
it
wire
browser,
that's
one
of
the
core
strengths
of
fear
that
you
can
do
both.
But
if
you
want
to
try
out
here
like
how
do
you
launch
it?
A
Here
is
a
platform
again,
there's
no
product
called
Theia
and
it's
a
collection
of
existing
extensions.
That's
the
the
name
of
a
module
in
fear
and
technically
those
extensions
are
no
packages.
So,
if
you're
familiar
with
note,
that's
kind
of
a
bundle
in
the
node.js
world
now
to
launch
here.
What
you
need
to
do
is
you
want
to
configure
your
own
product
based
on
here?
It's
basically
create
an
own
package,
jason
and
add
all
the
extensions
you
want
to
start.
You
can
use
a
predefined
product
if
you
don't
want
to
do
that.
A
A
Now
how
to
use
fear
I
would
like
to
give
a
quick
demo
we
have
in
last
stock.
We
have
seen
a
very,
very
much
customized
version
of
fear,
but
they
didn't
show
that
the
basic
features
I
really
want
to
show
the
basic
features
that
you
get
a
feeling
on.
How
fear
looks
like
today
and
how
to
use
it.
I
could
do
a
easily
a
10
hours.
Demonstration
of
all
the
features
I
have
to
focus
on
some.
A
What
I
want
to
show
is
the
basics:
I
want
to
show
a
command
which
is
really
very
present
in
fear,
and
if
you
know
vias
code
you're
familiar
with
that
that's
commands.
That
is
the
idea
is
that
you
have
a
quick
access
to
frequently
used
actions
instead
of
using
the
mouse.
You
can
just
type
them
in
and
there's
auto
completion
pretty
much
like
envious
code.
A
I
want
to
show
the
terminal,
because
Thea
has
a
terminal
integrated
which
allows
you
to
access
any
command
line,
interface
tool
that
you
you
would
like
to
use,
and
the
three
features
I
want
to
show
is
that
the
get
workflow
as
an
example
I
would
like
to
show
the
language
support
in
Java,
and
that
would
quickly
demonstrate
the
debugger,
because
I
think
those
are
the
three
most
prominent
features
that
show
a
pretty
good
spectrum
of
what
is
available
in
Thea.
So
let
me
start
here:
I
have
to
sit
down
there,
so
let
me
go
down.
A
What
I
would
do
for
the
demo
is.
I
will
start
here
locally
on
my
machine.
Of
course
you
could
also
do
deploy
that
on
the
server
or
in
shape,
but
I
I
would
just
do
that
locally.
Now,
if
he
is
running
as
you
might
see,
it
starts
really
fast.
Now,
let's
go
here
and
let's
browse
to
an
empty
workspace,
and
it's
just
reloaded
as
so.
You
see
that
the
color
has
changed,
because
the
the
ID
was
pre
loaded
and
now
it
knows
it's
online
again.
A
A
Better
okay,
maybe
like
this-
this
is
fine.
Okay,
so
now
I
can
open
the
file.
I
can
type
something
in
here
now
that
too
so
the
UI
is,
if
you're
used
to
an
IDE,
it's
pretty
much
what
you
expect.
So
there
are
menus.
You
can
switch
between
the
different
views
here,
for
example,
this
is
the
Explorer.
This
is
the
commit
view.
This
is
the
history.
Currently,
there
is
no
history.
A
Okay,
there
is
an
option
to
initialize
the
repository
and
I
just
press
ENTER,
and
then
my
repository
is
initialized.
The
thing
is,
a
lot
of
stuff
is
available
in
new
UI.
Much
more
is
available
by
our
commands
and
if
you
are
still
missing
a
feature,
you
can
still
execute
it
down
here,
because
that
provides
access
to
to
the
underlying
machine.
So,
for
example,
here
I
can
do
an
list
and
I
see.
Okay,
that's
just
readme
file
is
there.
So
let's
do
a
commit.
A
First
commit
and
I
press
control
enter
Oh
Ivan
staged
something
so
I
can
either
stage
here
manually
or
I
can
again
use
a
command
stage
all
so,
if
I
have
everything
if
I
want
to
commit
everything
and
then
I
press
control
enter
and
then
now
I
have
my
first
commit
and
what
I
want
to
show,
because
that's
also
an
interesting
feature.
Let
me
do
some
changes
here
and
do
another
commit
like
this,
and
let
me
stage
that
again,
if
I
all
sorry,
that's
I
didn't
want
that
like
this.
A
If
I
change
here
before
I
actually
committed
I
can
also
compare
that
so
Thea
supports
a
compare
view
and
for
that
I.
Just
double
click
here
and
I
see
the
nice
visualization
of
the
changes.
So
all
those
basic
features
that
you
actually
expect
from
a
UI
are
already
there.
I
can
look
at
the
history
here
so,
for
example,
here's
my
commit
I
can
look
at
the
changes
and
I
can
compare
them
again.
So
all
this
basic
stuff,
ok,
let's
switch
to
language
support
so
currently
I
only
have
a
readme
file.
A
So
let
me
create
a
Java
project
now.
This
is
a
very
good
example,
like
the
the
basic
version
of
Thea
doesn't
have
a
UI
to
create
a
Java
project.
I
would
need
to
do
that
manually,
and
but
what
comes
in
very
handy
here
is
that
I
have
access
to
the
underlying
terminal
and
it's
a
very
good
paradigm
of
fear.
It
doesn't
try
to.
It
doesn't
tries
to
reinvent
the
wheel.
There
is
actually
good
tooling
out
there
to
create
a
Java
project,
for
example
maven.
A
So,
instead
of
recreating
everything
from
scratch,
I
can
basically
just
use
maven
to
create
my
Java
project.
So
let
me
do
that.
I
access
now
the
terminal
down
here
and
let
me
copy
the
command,
because
it
was
too
long
to
memorize
that,
like
this
and
now
I
just
call
maven
to
create
an
archetype
Java
project.
A
It
generates
that
on
the
underlying
machine.
Hopefully
that
doesn't
takes
long.
It
asks
me
for
some
parameters.
So
that's
my
group,
my
artifact
version
just
like
this,
and
now
it
generates
the
Java
project
you
can
see
down
here.
Maven
is
running
and
down
here
the
Explorer
shows
me
the
result,
which
is
now
a
full
Java
project.
I
can
open
that
and
now
I
can,
for
example,
open
the
app
dot
Java,
and
now
we
dive
into
code
editing.
A
A
You
see
that
if
I
call
it
here,
it'll
automatically
suggest
me
that
so
is
it
also
understands
my
code
and
now
I
can
also
trigger
a
refractor
in
here,
so
I
can
call
refactor
and
then,
for
example,
I
can
fix
this
typo
No.
Somehow
I
left
this
mode
anyway.
I
will
not
fix
that
now,
but
usually
that
works
so
that
you
that
you
can
rename
stuff.
So
it
is
a
clever
code
editor.
It
really
really
fuse
well,
the
third
thing
and
of
course,
I
could
run
my
java
app
now
here.
A
The
third
thing
I
would
like
to
demo,
because
that's
a
recent
addition
and
we're
also
very
powerful
thing-
is
the
debug
view
that's
implemented,
while
the
debug
adapter
protocol,
and
for
that
I
will
switch
to
another
workspace
that
I've
open.
This
workspace
actually
shows
the
sources
of
fear
itself.
So
it's
the
workspace.
A
So
this
is
the
source
code
of
fear
and
it
is
actually
possible
to
develop
extensions
or
even
fear
itself
using
fear,
so
you
can
bootstrap
it
and
what
I've
done
here
I've
set
a
breakpoint
in
the
commit
method,
and
now
what
I
can
do
is
I
can
launch
I
can
launch
here
in
the
debug
mode
and
open
that
in
another
browser
window,
so
that's
running
on
another
port,
so
this
is
now
the
sphere
on
the
development
and,
let's
just
trigger
a
commit
here.
Oh
I
have
to
add
some
changes.
A
Just
like
this.
Now
you
see
nothing
should
happen.
Why
does
something
happen?
I
know
it
is
actually
here
so
now
the
debugger
stands
here:
I
can
look
at
the
variables
I
can
look
at
the
closures.
Everything
and
I
can
even
step
through,
as
you
see
here
so
I
could
now
debug
the
commit
directly
in
my
tid
and
I
think
this
is
really
really
powerful.
A
A
Now
we've
shown
all
those
features.
So
let's
sum
that
up
a
bit,
what
are
the
key
features
of
Eclipse
fear,
and
maybe
we
already
compare
that
a
bit
to
vias
code,
so
the
first
key
feature
it's
based
on
modern
web
technology,
typescript,
HTML
CSS.
You
can
see
that
your
eye
looks
very
nice.
You
consume,
you
can
change
the
theme
so
and
if
you,
if
your
developers
like
to
use
html5,
typescript
and
so
on,
that's
really
an
advantage.
This
is
the
same
as
vias
code,
so
the
UI
technology
is
basically
the
same.
A
It
integrates
LSP
and
the
Minako
editor
the
Minako
editor.
This
is
the
code
editor
in
the
middle,
where
I
showed
you
the
order,
completion,
syntax,
highlighting
and
so
on.
That's
also
exactly
the
same
technology
used
in
BS
code.
Now,
let's
talk
a
little
bit
about
the
unique
features
of
here.
Fear
has
been
developed
from
from
hard
to
run
online
and
offline.
So
I've
shown
you
I
mean
the
I
started
the
server
on
my
machine
and
access
and
open
it
in
the
browser,
but
that's
actually
the
remote
case.
A
So
you
could
start
the
server
on
some
remote
machine
and
then
use
it
in
the
browser.
But,
alternatively,
you
can
also
deploy
a
Thea
app
by
electron
as
a
desktop
app
that
users
can
download
and
run
locally
vs
code
at
the
moment
is
targeted
at
the
desktop
case,
so
it
runs
in
electron,
although
it's
very
likely
that-
or
it's
almost
sure
that
this
will
not
hold
I
mean
this
code
is
obviously
going
to
the
cloud.
There
are
some
announcements
pointing
in
this
direction.
A
A
A
lot
of
the
the
actions
can
be
done
on
the
command
line
and
wire
commands,
and
therefore
the
code
base
of
fear
is
actually
surprisingly
small,
but
in
turn
well
well
maintained
via,
is
when
a
neutral
associate
at
the
Eclipse
Foundation
and
a
lot
of
different
companies
contribute
to
that.
So
that's
where
we're
promising
this
code
is
open
source,
but
you
could
argue
it's
pretty
much
like
controlled
by
Microsoft,
still
that
you
can
consider
that
to
be
good
or
bad.
Yes,
definitely
more
diverse
and
finally,
and
that's
also
difference
to
use
code.
A
Thea
is
very
extensible
because
it
has
been
built
for
that
purpose.
To
be
the
basis
of
a
custom
platform
for
from
the
beginning
in
Thea,
actually,
everything
is
an
extension,
so
all
the
parts
of
the
application
like,
for
example,
the
existing
kids
support,
the
code
editor
the
terminal
all
the
menus.
A
They
are
already
implemented,
as
extension,
so
there
is
no
difference
between
anything
that
is
part
of
the
platform
and
something
that
you
would
add
every
every
extension
place
by
the
same
rules,
and
that
means
it's
very
easy
to
completely
extend
Thea
and
also
replace
existing
behavior.
The
machine
isn't
used,
for
that
is
dependency
injection,
which
is
really
flexible.
A
So
if
you
want
to
build
a
wide
label
product
where
you
really,
which
really
looks
completely
custom,
like
like
the
thing
that
we
we
have
seen
before
in
the
talk
before
this
would
be
difficult
in
vias
code,
because
it
has
a
limited
API
for
for
the
extension
use
case.
While
here
has
really
this
powerful
extension
machine
as
talking
about
extensions,
there
are
actually
two
mechanisms
to
extend
Thea
one
is,
and
that's
what
I
already
mentioned
the
extension
mechanism.
A
In
fact,
every
eclipse,
Thea
application
or
product
consists
of
a
number
of
extension,
just
like
an
OC
I.
A
platoon
is
a
number
of
panels.
This
is
exactly
the
same
fourth
year
and
you
can
slice
and
dice
them
as
you
like,
so
you
can
use.
We
use
existing
ones
like
two
of
them
on
this
slide
and
you
can
add
your
own
extensions
to
create
a
product
with
the
features
you
like
and
all
those
extensions
communicate
using
dependency
injection.
So
in
case
you
didn't
join
the
talk
before.
A
Okay
and
let
me
go
here
and
open
another
workspace,
so
what
I'm
about
to
show
you
is
a
product
that
has
that
is
based
on
Thea,
but
that
has
been
heavily
customised
to
actually
look
completely
different,
that
what
it
was
then
than
Thea
itself.
So
it
adds
a
lot
of
new
features.
So
let
me
switch
the
workspace
here
and
go
in
here
just
like
this.
A
Couldn't
it's
more
like
in
engineering
tools
where
you
can
enter
date
or
another
example
of
a
customization
would
be
diagram
editor,
as
you
can
see
here
where
you
can
do,
for
example,
an
activity
diagram
and
all
this
has
been
implemented
using
extensions
custom,
extensions
that
have
been
plucked
and
together
with
existing
Thea
extensions
to
a
new
product.
So
this
is
one
mechanism.
There
is
a
second
one
called
a
Thea
plugin.
A
The
reason
why
this
was
actually
invented
is
extensions,
have
been
there
from
the
beginning
and
the
whole
architecture
of
fear
is
actually
based
on
those
extensions
and
initially
it
was
also
possible
to
deploy
them
by
a
runtime.
However,
extension
have
one
disadvantage,
and
that
is
the.
If
you
implement
something
in
an
extension,
you
have
access
to
everything
in
fear.
You
can
customize
everything,
but
you
can
also
harm
the
stability
of
the
application.
A
Now,
if
you
create
your
own
product
and
you
have
everything
under
control,
this
is
actually
a
good
thing,
because
you
know
exactly
what
you
do
now.
If
you
think
more
about
something
like
vias
code,
where
you
have
a
base
product
and
you
want
to
allow
users
to
provide
plugins,
you
can
install
into
a
product
and
into
an
existing
product,
and
this
is
actually
dangerous,
because
if
you
give
all
the
users
complete
freedom,
they
they
will
make
the
IDE
slow
or
in
stable
or
whatever,
and
also
extensions.
It's.
A
It
was
not
easy
to
deploy
them
while
ROM
time,
let's
phrase
it
like
that
now
to
solve
this
problem,
the
Fiat
team
actually
invented
a
second
mechanism
of
extension
and
that's
called
the
plugin,
and
the
idea
is
there's
one
plugin
in
fear.
Oh
sorry,
one
extension
that
you
can
install
called
the
the
plugin
extension
and
this
provides
a
dedicated
API
that
can
be
used
by
plugins.
Now
this
API
is
restricted.
Is
it's
much
smaller
and
also
plugins
run
in
a
separate
process,
so
they
cannot
harm
the
stability
intern.
A
This
API
is
a
little
bit
simpler
to
use
because
you
can
look
at
the
API
and
you
see
okay.
This
is
what
I'm
expected
to
do
with
my
plugin.
It
covers
the
most
common
use
case,
so
it's
easier,
less
powerful,
but
but
basically
easier.
If
your
use
case
is
covered
wide,
that
API
now
before
Thea
actually
created
its
own
new
plugin
API,
they
did
something
very
clever,
and
that
is
they
looked
at
vias
code,
because
vias
code
has
exactly
this
approach.
A
The
Thea
plug-in
API
is
compatible
with
the
vs
code
one,
and
that
means
you
can
write
a
plugin
which
runs
in
Thea,
but
also
in
vias
code,
and
you
can
use
you
can
reuse,
vias
code
plugins
in
Thea
too,
and
that
actually
works
today
with
some
limitations.
I
will
mention
in
a
second,
but
that
opens
up
the
huge
ecosystem
of
use
code
plugins
to
be
used
in
Thea.
A
Now
about
that.
So
Thea
provides
almost
the
same
API
as
vs
code.
Almost
the
same
means
it's
not
fully
completed
yet
so
some
parts,
the
API
of
risk,
are
not
yet
there,
but
you
can.
Actually,
if
you
want
to
use
a
your
favorite
vias
code
extension
in
Thea,
you
can
in
you,
can
install
it
and
test
that
about
the
installation.
A
Well,
technically,
it's
actually
possible
to
install
something
from
the
vs
code
marketplace
into
fear
just
by
typing
in
the
IDE
ID
of
that
that's
disallowed
by
the
terms
of
use
of
the
Microsoft
marketplace.
So
don't
do
that.
What
you
can
do
instead
is
go
to
the
original
source
of
that
plugin,
and
hopefully
you
find
download
there
on
the
github
repository
and
then
you
can
download
and
install
it
into
Thea.
Ok!
A
So
enough
about
here,
let's
switch
to
qi.
If
you
look
on
the
clock,
you
might
notice
that
we
talked
a
lot
now
about
Thea
and
we
will
only
have
five
minutes
for
qi
reason,
for
that
is
she
solves
at
least
as
much
features
for
you
in
an
online
scenario,
but
for
a
developer.
Typically,
all
this
stuff
runs
in
the
background.
So,
there's
not
so
much
to
demo,
while
Thea
provides
all
the
features
that
you
use
as
a
developer.
Like
code
gets
all
this
stuff,
she
is
basically
an
enabler.
A
So
what
does
she
do
if
we
think
about
how
to
deploy
Thea
in
an
remote
scenario?
We
we
want
to
run
it
on
the
server,
but
the
the
interesting
question
is
the
terminal
down
there
in
in
here.
Where
does
this
point
to
so
what
happens
if
I
trigger,
let's
say
a
compilation
or
a
maven
command
or
this
language
server?
A
Where
do
those
things
run
in
so
we
need
some
online
runtime
or
container,
where
the
development
tools
that
the
the
user
uses
wire
the
browser
actually
run
in,
and
if
you
imagine,
you
only
not
only
have
one
developer
but
10
or
100
or
1000
or
10,000.
We
need
some
server
solution
which
is
capable
of
managing
those
runtimes,
and
this
is
exactly
what
she
does
so
che
is
a
workspace
server,
so
we
call
those
runtimes
on
the
server
workspaces.
A
They
contain
the
sources,
but
also
the
tools
that
you
can
work
with
those
and
it
allows
to
manage
those
runtime
and
works
based
on
the
server.
That
means
users
can
log
in.
They
can
create
workspaces.
They
can
share
them
with
colleagues,
they
can.
You
can
assign
resources
to
developers,
you
can
you
have
control
on
how
many
resources
developers
use
and
so
on
so
and
those
workspaces
are
managed
as
containers,
and
she
actually
does
that
with
by
using
kubernetes.
You
can
share
them.
A
Yes,
I've
mentioned
all
that,
and
the
connection
is
very
simple:
Shay
uses
fear
as
the
default
IDE.
You
can
actually
also
use
other
ideas
in
shape.
For
example,
there
is
an
online
version
of
the
classic
Eclipse
IDE.
If
you
haven't
seen
that
I
recommend
to
have
a
look,
it's
pretty
cool,
so
you
can
actually
use
the
classic
Eclipse
IDE
in
in
the
browser.
But
Thea
is
the
default
IDE.
So
that's
what
you
get
if
you
don't
change
that
and
what
she
also
does
it
provide
some
pre-configured
products
based
on
on
here.
A
So
if
you
use
qi,
you
don't
have
to
configure
your
own
here
product
based
on
all
the
extensions
you
just
get,
something
which
is
is
working
and
which
contains
some
additional
extensions
and
plugins
that
are
focused
on
that.
I
actually
provided
by
the
eclipse,
cheating.
Ok,
so
let's
have
a
quick
look
at
that.
A
So
this
is
now
online.
Hopefully,
let
me
see
yeah.
Let
me
start
that,
okay,
so
this
is
how
she
looks
like
this
is
actually
running
online.
On
OpenShift
here,
I
see
a
list
of
my
workspaces,
I
just
launched
one
that
I
can
demo
it
in
a
second,
but
I
can
also
just
create
a
new
one.
So,
let's
click
there.
What
you
see
here
is
what
they
call
a
stack.
A
stack
is
a
pre-configured
or
is
a
configuration.
A
How
my
run
time
will
look
like
it's
basically,
the
selection
of
tools
that
I
want
to
install
into
my
online
runtime
and
they
do
a
good
job
in
providing
defaults.
So,
for
example,
if
I
want
to
develop
Java
with
maven
I
can
click
this
stack
and
it
contains
what
you
typically
need
like
it
contains
Java,
maven
and
and
some
some
additional
tools
down
here,
I
can
select
if
I
want
to
an
existing
project
to
check
out
if
I
select,
for
example,
an
example
project.
She
will
start
my
workspace
and
automatically
check
this
out.
A
So
I
can
basically
just
by
create
click,
clicking,
create
and
open
launch
my
workspace
and
then
how,
having
already
having
some
example
code,
the
stacks
are
configurable,
so
there
is
a
number
of
pre
defined
stacks
here.
You
can
consider
this
to
be
like
virtual
machines
that
you
can
actually
use
online
for
for
your
development.
A
So,
for
example,
we
have
no
js'
down
here,
Java
different
C++
development,
whatever
you
like
now,
let's
look
at
how
this
or
let's
have
a
look
on
how
this
looks
like
so
you
see
this
sounds
looks
familiar
because
that's
Eclipse
G
again,
so
she
is
now
running
online
within
sorry.
Tia
is
running
online
in
cha-am.
You
can
see
this
view
is
new
because
that's
actually
added
by
G
as
an
extension,
but
if
I
close
this-
and
this
I
have
now
again
a
planing
clipped
here
that
I
can
use
for
development
within
G.
A
A
Ways
how
to
extend
Chi
so
whenever
you
extend
Chi
like
you
can,
whatever
you
can
do
with
fear,
can
also
affect
Chi,
because
if
you
run
fear
and
Chi
and
start
to
extend
the
the
via
IDE,
that
will
also
affect
what
you
get.
If
you
open
your
workspace,
but
particular,
or
only
for
Chi,
you
can
customize
the
stacks
that
I've
shown
you
meaning
the
pre-configured
runtimes
that
developers
can
use.
A
You
can
customize,
so
called
Chi
plugins
chi
plugins
are
a
special
thing
that
is
combining
via
plugins
meaning
features
that
are
added
to
your
IDE,
but
those
Chi
plugins
can
also
add
features
to
the
underlying
runtime.
So,
for
example,
if
you
have
a
theologian
which
provides
may
even
support
in
the
UI,
but
it
requires
may
even
to
be
installed
on
the
runtime,
you
can
bundle
those
two
things
into
one
chi
Thea
plug-in:
that's
how
they
call
it,
and
then
you
can
click
that
in
need
in
the
Chi
IDE.
A
To
add
that
to
your
online
workspace,
and
you
can
add
your
own
custom
editor.
So,
instead
of
using
Thea,
you
could
also
use
another
web
IDE
and
they
provide
a
few
out-of-the-box.
You
can
have
a
look
at
that.
If
you
go
to
the
workspace
configuration
you
can
actually
select
among
several
editors
and
with
that.
Let
me
come
to
the
conclusion.
So
eclipse
Thea
and
Eclipse
Chase,
so
Eclipse
Thea
is
the
IDE
framework,
a
platform
to
build
web
based
IDE
that
can
run
on
the
desktop
Y,
electron
or
online.
A
While
Chi
is
a
framework
to
manage
your
developer
runtimes
online,
it
uses
Thea
as
a
default
IDE.
So
it's
basically
a
possibility
to
provide
containers
for
here
to
run
in,
but
also
provides
other
editors,
but
at
the
end
those
projects
are
closely
connected
to
3-tier
vs
vs
code.
Here
we
uses
a
lot
of
comparing
from
vias
coat,
especially
the
Minocqua
editor.
The
usability
of
Bo's
is
very
similar.
A
Currently
Thea
has
the
online
use
case
as
an
advantage,
but
that
might
not
be
the
case
for
ever.
Here
is
more
extensible
because
it
has
this
extension
mechanism
and
it
it
is
hosted
at
the
Eclipse
Foundation
C
extensions
versus
Thea
plugins
vs.
chase
here.
Plugins,
via
extensions,
are
the
powerful
mechanism
where
you
can
do
everything,
but
you
cannot
install
doing
runtime
and
you
basically,
you
don't
want
to
give
any
anybody
the
capability
to
extend
your
product
with
that,
because
they
can
harm
stability.
Plugins
can
be
deployed
during
runtime.
A
They
have
a
limited
API,
but
they
are
running
in
a
known
process.
This
API
is
similar
to
the
vias
code,
one
so
you
can
reuse,
visco,
plugins
in
Thea
and
the
other
way
around.
With
some
limitations.
We
need
to
test
that
and
the
chase
Thea
plugin
is
the
combination
of
a
Thea
plugin
with
the
underlying
runtime
dependencies
that
are
deployed
on
the
container.
Why
a
sidecar
now
additional
technologies
you
might
be
interested
in
in
this
context,
or
the
G
LSP
for
diagrams
Sprott
e
underlying
technology
of
CSP
again
for
diagrams
or
MF
cloud.
A
All
of
those
have
been
presented
in
the
last
talk
and
with
that
I
would
like
to
come
to
an
end.
I
hope
that
this
overview
was
useful
to
you
to
just
see.
Ok,
this
is
how
the
tool
looks
like
this
is
what
I
can
do?
Is
it
interesting
for
me
or
not?
Maybe
tomorrow,
maybe
in
one
month
and
maybe
in
one
year,
I'm
happy
to
take
any
questions
now
in
a
second.
If,
if
you
don't
have
a
question
now-
or
maybe
your
question
comes
later,
please
also
feel
free
to
get
in
contact
with
me.