►
Description
Talk by Shane Carr (starts at 11:20, with some intros from the organizers first)
Across the world, people are coming online with smartphones, smart watches, and other small, low-resource devices. The technology industry needs an internationalization solution for these environments that scales to dozens of programming languages and thousands of human languages.
Enter ICU4X. Built from the ground up to be lightweight, portable, and secure, ICU4X learns from decades of experience to bring localized date formatting, number formatting, collation, text segmentation, and more to devices that, until now, did not have a suitable solution.
Shane Carr, chair of the ICU4X subcommittee at the Unicode Consortium, will introduce ICU4X and discuss a range of topics on how to write a fast, modular Rust library.
https://www.meetup.com/rust-zurich/events/289518586/
-- Chapters --
00:00 Rust Zürisee and Introduction by Stefan Schindler
04:44 Rust at Google by Martin Geisler
11:20 Next Generation i18n with Rust Using ICU4X by Shane Carr
39:39 Questions
C
B
Let
me
give
you
a
little
bit
of
History,
so
we
started
out
as
a
sub
Meetup
of
the
Mozilla
Meetup
in
zurichandrian
and
then
over
time.
We
noticed
that
there
was
a
lot
of
rust
content
where
you
wanted
to
do,
and
Mozilla
wanted
to
go
in
a
different
time.
This
was
also
when
their
home
kit
alternative
started.
B
B
So
the
main
struggle
in
the
beginning
was
what
is
rust.
Why
should
we
use
it?
How
can
I
do
this,
and
that
use
case
and
over
time
that
changed
into
look
at
this
neat
solution
and
look
at
this
little
story
that
I
found
and
the
project
became
less
of
this?
Was
the
monolith
I
had
to
build
to
solve
some
minor
problem
towards?
Oh
now,
I
can
use
this
and
that
library
and
just
build
something
out
of
components
so
to
reflect
that
I
would
like
you
or
anyone.
B
B
D
B
We
are
currently
looking
at
the
7th
of
February.
Where
we
have
two
talks.
One
will
be
my
master
thesis
and
one
with
some
something
else.
Unless
we
find
another
cool
talk
for
February,
then
I
will
just
move
mine
to
March
and
March
is
currently
the
idea
that
we
have
a
big
one
and
a
couple
small
ones
and
April.
B
B
A
Thank
you
so
much
for
coming
everybody.
It's
amazing,
to
see
this
room
being
filled,
I,
think
to
capacity
awesome
turnout
thanks
a
lot
for
coming
and
welcome
to
Google
I
hope
everybody
got
their
batches
now.
So,
apart
from
that
little
complicated
start
now,
we
can
actually
get
to
the
to
the
good
stuff
I'm
just
here
to
introduce
you
briefly
to
so.
A
Google
tries
to
you
know,
use
and
support
rust
in
a
few
different
ways
and
first
of
all,
Google
is
part
of
the
Ross
foundation.
So
Google
tried
to
support
the
you
know.
Long-Term
development
of
the
language
make
sure
it
has
the
resources
and
yeah
infrastructure
to
do
that
in
the
long
term,
but
then
also
something
like
that.
I
don't
see
come
up
very
often,
but
is
that
Android
is
using
rust.
A
So
Android
is
at
its
core
a
Linux
distribution
that
is
shaped
so
that
you
can
put
it
on
a
laptop
that
looks
like
a
cell
phone,
like
your
cell
phones,
is
running
a
Linux
distribution
basically,
and
that
distribution
has
a
whole
lot
of
demons.
A
whole
lot
of
software
running
below
the
application
layer
and
that
platform
is
using
rust
and
that's
been
going
on
since
2021.
A
A
It
has
have
a
few
beautiful
abilities
and
one
of
the
tools
that
we
do,
that
we
use
for
that
is
rust.
So
we're
trying
to
get
rid
of
memory
unsafe
languages
like
C,
plus
C
and
C,
plus,
plus,
and
replace
them
with
rust,
where
we
see
that
they
are
security,
vulnerabilities
and
there's
a
whole
bunch
of
things
in
Android
today
that
is
using
rust.
So
soon
is
the
build
system
for
Android.
It's
this
big
thing
that
can
build
all
of
Android
and
that
has
been
updated
to
support.
A
Roster
knows
how
to
support,
build
Ross,
binaries
and
libraries
and
tests
and
fussing
and
there's
a
whole
lot
of
build
rules,
and
as
part
of
that
and
there's
a
link
here
to
a
blog
post.
That
was
recently
put
out
maybe
two
months
ago,
that
the
latest
versions
of
Android
will
have
DNS
over
HTTP
3
written
in
Rust,
so
that
it
gives
you
DNS
lookups
that
are
authenticated,
and
you
know
that
has
all
of
the
normal
GLS
Security
on
top
of
them
and
then
there's
some
other
components.
So
there's
something
called
keystore2.
A
That's
cryptographic,
Keys,
there's
something
called
Auto
right
band,
I'm
involved
in
writing
the
or
helping
the
Bluetooth
people,
the
Bluetooth
team,
rewrite
part
of
the
Bluetooth
stack
in
Rust
as
well.
To
make
that
thing
more
stable,
more
secure
and
so
on
and
there's
a
station
framework
as
well,
where
Android
is
inside
your
phone,
their
virtual
machines
running
and
they
are
using
rust
code
to
make
that
safe
and
secure
yeah.
Now
this
is
from
a
blog
post.
A
A
It
is
the
blue
thing
here
is
rust,
then
this
is
the
other,
and
then
we
have
cut
them
down
here.
So
this
part
of
the
pie
chart
is
the
memory
safe
languages,
and
it's
something
we're
very
happy
about,
because
it
means
that
we
hope
to
have
few
of
our
liabilities
being
found
in
the
next
months
and
fewer
pressures
and
all
that
stuff.
A
E
A
This
is
probably
been
red
in
some
sense,
but
the
new
ones
are
going
down
over
the
years
where
they
have
different
Android
releases,
and
we
include
less
and
less
memory
on
Save
code
and
the
Red
Pass
here
and
then
the
memory
saved
vulnerabilities
have
gone
down
proportionately,
and
this
kind
of
track
record
is
very
interesting
for
us,
because
it's
this
indicates
to
us
that
this
investment
into
rust
actually
makes
our
phone
safer,
and
this
is
why
Google
wants
to
have
more
Rusty
in
Android
yeah
questions
about
this.
Before
we
start
the
talk.
A
If
not,
then
this
is
a
program
for
today.
So
introduction
took
some
amount
of
time
now
we're
going
to
have
a
talk
by
Shane
they're,
going
to
have
a
break
they're
going
to
have
a
talk
by
the
niche,
and
then
we
have
time
for
socializing
until
I.
Don't
know
if
anybody
will
come
and
send
us
home,
but
we
have
some
time
at
the
end
of
that.
C
C
Okay,
hello,
everyone.
Thank
you
all
for
for
coming.
It's
a
full
house.
I
want
to
give
thanks
again
to
Martin's,
safe
on
and
especially
Eunice
for
organizing
this
event
and
making
it
happen.
Okay,
so
across
the
world,
people
are
coming
online
with
smartphones,
smart
watches
and
other
small
low
resource
devices.
The
technology
industry
needs
an
internationalization
solution
for
these
environments,
that
scales
to
dozens
of
programming,
languages
and
thousands
of
human
languages,
and
that's
what
I'm
going
to
talk
about
today.
C
D
C
C
Then
I'm,
going
to
be
talking
about
ic4x
I'm,
going
to
be
focusing
on
our
handling
of
data
management,
how
we
made
it
modular
other
things
we
learned
from
building
a
rust
library
and
then
give
some
closing
thoughts
at
the
end,
so
first
internationalization,
so
internationalization
is
commonly
abbreviated
as
I-18n,
which
is
I,
followed
by
18
letters
followed
by
n,
now
a
lot
of
people
when
they
think
about
internationalization.
They
think
about.
Oh
it's
about
how
do
you
build
an
app
that
scales
across
across
markets
and
across
languages?
C
And
that's
definitely
a
big
part
of
it?
Ihn
is
also
more
than
globalization
when
I
give
this.
When
I
gave
this
talk
in
the
in
the
United
States.
A
lot
of
people
are
surprised
that
a
lot
of
people
speak
languages
other
than
the
national
language
at
home.
I
know
in
Switzerland
that's
fairly
common,
but
like
it's
it's
that
this
is
all
all
around
the
world.
This
happens
a
lot.
So
it's
also
more
than
translation.
This
here
is
a
light.
C
Switch
in
Japan
is
that
on
or
off
I'm,
not
exactly
sure.
Ihn
is
also
a
very
deep
problem.
Every
language,
region
and
culture
has
its
own
unique
challenges
and
what
works
for
one
Locale
may
not
work
for
another.
That's
why
we
have
to
build
i8n
solutions
that
are
focused
on
identifying
and
then
solving
all
of
the
broad
set
of
problems,
so
the
the
transition
from
the
field
of
internationalizations.
C
What
I'm
going
to
be
telling
you
about
tonight
is
the
evolving
needs
for
international
software,
so
there's
more
users
and
more
languages
than
ever
before,
who
are
using
smaller
devices,
with
an
increased
focus
on
client-side
and
Edge
computing,
and
that's
where
I
see
Forex
enters
the
picture.
So
I
see
you
for
x.
What
is
the
project?
How
did
it
come
about
and
what
are
the
goals?
So,
if
I
had
to
summarize
in
just
one
statement,
ICU
for
X
is
a
modular
internationalization
library
in
Rust.
What
does
this
mean?
C
C
There's
people
also
on
my
team
at
Google
who
helped
to
maintain
lib
ICU.
So
that's
the
inspiration
for
ic4x
internationalization,
I,
just
told
you
what
internationalization
is
more
concretely.
What
we're
talking
about
are
things
like?
How
do
you
format
dates
times
and
numbers
across
regions
and
languages?
How
do
you
do
the
correct
grammatical
selection,
for
example,
plurals,
plural
cases
you
have
to
do.
Unicode
text,
processing
properties,
segmentation,
Etc
to
process,
Unicode
text
correctly
time
zones,
non-gregorian
calendars,
and
the
list
goes
on.
C
Modular
means
that
we've
one
of
our
most
important
goals
is
modularity.
Many
applications
perform
internationalization
using
ICU,
but
ICU
is
not
built
for
focus
is
not
focused
on
building
for
small
Code
and
low
resource
environments.
So
with
IC
for
x,
a
very
core
design
goal
has
been
how
we
can
design
the
library
so
that
you
only
include
what
you
use
a
plugable
data.
I'm
going
to
be
talking
about
more
later
is
a
big
part
of
that
and
it's
definitely
usable
on
embedded
systems.
C
The
4X
part
is
an
indication
of
how
ICU
for
X
is
designed
to
not
only
be
used
in
one
language,
one
programming
language
but
being
be
used
across
many
programming
languages.
We
have
our
tool
called
Diplomat
that
we
built
for
this
Robert
and
standing
in
the
back
of
the
room
has
been
a
very
big
big
part
of
that,
as
well
as
Manish,
who
will
be
talking
after
myself.
C
We
currently
support
C,
plus
plus
C
and
typescript
apis,
we're
working
on
more
like
Dart
and
Java
Etc,
and
this
allows
IC
for
X
to
be
used
in
many
programming
languages
not
just
rest,
but
we
also
built
in
built
in
Rust,
because,
as
Martin
explained
before
me,
it's
safe
by
default,
which
has
a
lot
of
advantages.
We
can
do
blazing
fast,
zero
copy
deserialization,
which
the
talk
after
mine
from
a
niche
will
go
into
much
more
detail
on,
and
it
again
is
appropriate
for
ffi
and
using
from
use
from
other
programming
languages.
C
Okay,
so
who
are
we
that
we
that
built
ic4x
so
we
are
in
we
icfrx
is
not
just
a
Google
project.
We
are
under
the
Unicode
Consortium
partnered,
with
other
open
source
internationalization
projects
like
ICU
in
order
to
build
an
industry
standard
Library
we're
currently
a
collaboration
between
Google
and
Mozilla
and
Amazon,
and
we're
being
developed
in
the
open,
and
we
welcome
all
contributors.
You
can
go
read
all
of
our
code
on
on
GitHub,
so
this
here
is
a
quick
demo
of
ic4x
in
action.
C
This
is
ic4x
compiled
to
webassembly
I'm
clicking
through
different
screens,
showing
some
different
things
here.
But
some
things
I'll
point
out
are
that
this
is
all
running
locally.
There's
no
calls
to
the
server
happening
here
at
all.
This
is
all
in
webassembly
locally.
In
my
browser,
so
on
the
first
tab
here
is
fixed
is
decimal.
Formatting
I
can
enter
a
number
I.
Can
this
is
in
the
English?
Locale
can
switch
it
to
the
Bengali
locale.
C
C
Cool,
so
I
see
Forex
project
status
right
now
we're
in
2022..
We
started
the
project
in
2020
and
we've
been
working
on
it
very
hard
for
two
years
and
we
have
our
it4x1.0
release
that
we
released
a
couple
months
ago
in
September.
So
this
is
all
ready
to
use.
You
don't
have
to
wait
anymore
yeah
and
what
we're
going.
What
we're
working
on
now,
we'll
continue
to
do
for
the
next
year
and
Beyond
is
to
you
know,
is
to
help
integrate
with
more
clients,
add
additional
features
and
and
so
forth.
C
C
So
this
is
one
of
my
favorite
charts.
It's
a
little
confusing
when
you
first
see
it,
but
this
is
a
chart
of
on
the
x-axis.
You
have
a
locales,
that's
language
and
language
region
Pairs
and
on
the
y-axis
you
have
the
amount,
the
coverage,
the
amount
of
data,
basically
that
are
in
those
locales,
so
the
coverage
of
the
total
space
of
things
that
could
possibly
be
specced
out
in
that
language
and
then
on
the
third
axis.
C
The
three
the
third
degree
axis,
if
you
can
sort
of
imagine
this
being
in
three
degrees,
is
the
cldr
release
number
so
cldr
is
the
common
Locale
data
Repository,
which
basically
encodes
data
for
how
you
do
date,
formatting
and
how
you
do
segmentation
for
all
these
different
languages.
So
you
can
see
that
in
every
cldr
release
the
amount
of
data
just
keeps
going
up,
it
doesn't
go
down,
keeps
growing.
In
fact,
it
grows
quadratically
because
you
have
because
cldr
adds
features
and
it
also
adds
languages.
C
C
We
need
complex
code
to
process
the
the
data
that
we
get
from
cldr,
and
all
of
these
reasons
are
why
ICU
for
X
is
an
important
is
a
very
important
piece
in
order
to
serve
this
need.
Okay,
so
we
take
a
multi-pronged
approach
to
dealing
with
Locale
data
and
making
it
fast
and
efficient.
The
first
is:
we
have
no
memory
allocations
if
you
can
believe
it
once
you
have
your
your
data
file,
either
loaded
from
disk
or
shipped
with
your
executable.
C
We
don't
have
to
do
anything
fancy
to
read
from
it.
We
just
read
from
the
binary
data
directly.
A
second
thing
is
that
we
have
stable
files.
This
is
one
of
the
biggest
pain
points
for
people
trying
to
use
lib
ICU
is
that
if
you
have
multiple
programs
that
all
need
to
use
ICU,
they
cannot
share
the
same
data
files,
because
every
ICU
version
needs
its
own
data
file,
but
with
IC
for
x,
We've
designed
it
in
such
a
way
that
it
we
can
share
data
files
across
across
versions.
C
C
You
know
the
top,
the
top
10
or
20
languages,
and
that's
a
problem,
especially
as
you
know,
we
just
want
to
scale
software
around
the
world
and
we
want
to
make
a
software
accessible
to
everyone.
That's
very
limiting,
so
the
dynamic
loading
of
data
is
a
really
big
part
of
how
we
can
scale
to
hundreds
of
languages.
Static
slicing
is
is
pretty
pretty
fun.
C
This
means
that
when
you
build
your
application
linking
IC
for
X,
we
have
tools
and
even
automatically
in
some
cases
you
don't
have
to
ship
all
the
data
that
you
need.
You
only
the
more
data
than
you
need.
You
only
have
to
ship
exactly
the
data
that
you
need,
which
is
something
that
ICU
foresee,
has
not
not
been
able
to
do
directly
and
last.
Another
thing:
that's
that
comes
up
a
lot
is
live
refresh.
C
C
C
So
one
component
of
this
is
by
making
smaller
crates
ISU
for
X
in
instead
of
just
being
one
large
library
with
all
the
code.
In
it
we
have
many
smaller
pieces,
and
this
makes
it
more
explicit
where
those
dependencies
are
and
where
they
live.
We
have
smaller
functions.
This
is
a
very
big
part
of
the
big
big
part
of
it
when
you
call
a
function
in
your
code,
so
it's
all
about
the
call
side
from
your
application
into
ic4x.
C
What
is
that
API
surface
that
you're
that
you're
calling
through
we
focus
on
making
those
those
functions
such
that
they
do
not
have
a
lot
of
extra
branches
of
code?
And
this
is
what
makes
tree
shaking
work
very
efficiently,
meaning
that
you
can
avoid
large
conditional
code
paths
and
be
suitable
for
dead
code
elimination.
C
A
third,
a
little
interesting
thing
that
we
found
when
working
on
code
size
is
that
we
found
a
lot
of
code.
Size
came
from
result,
types,
error,
types
that
have
a
lot
of
extra
information
stored
inside
of
them
and
whenever
you
do
that,
you
have
to
also
ship
the
code
to
construct
and
destruct
those
error
types.
C
So,
by
making
the
error
types
copy,
we
can
eliminate
a
lot
of
a
lot
of
bloat
and
code
size.
You
can
see.
We
are
still
able
to
give
you
the
fully
detailed
error
message
by
having
a
compile
time
flag,
but
then,
in
like
the
release
mode,
we
just
have
copy
error
types
and
we
use
traits
wisely
traits
are
bad
because
our
I
mean
Trader.
Trade
objects
are
great,
but
they're,
not
so
great
for
for
code
size
because
they
don't
allow
inlining
of
code.
C
It
often
needs
to
use
the
Heap
more
often
because
you
can't
have
trait
objects
stack
allocated.
You
have
to
put
them
somewhere
and
V
tables
in
general,
increase
code
size
and
are
slow,
so
we
use
them
when
we
need
to.
But
you
know
we
try
to
use.
You
know
static
types
as
much
as
possible.
That
being
said,
there
are
cases
where
static
types
actually
increase
code,
size
relative
to
trait
objects.
So
it's
all
a
balance.
It's
all
a
balance,
there's
not
always
a
one-size-fits-all
solution.
C
The
way
that
we
deal
with
part
of
that
problem
is,
we
can
use
a
generic
static,
static
Types
on
the
API
layer,
but
then
a
call
down
into
a
single,
dedicated
low
level
function
in
order
to
get
the
benefits
of
traits
without
having
the
code
size
cost
so
static.
Analysis
for
data
slicing
I've
alluded
to
this
before
the
way
we
do
this
is
we
annotate
functions
with
their
data
requirements
so
that
when
you
call
into
a
function,
we
can
identify
what
data
the
function
requires.
C
Every
function
that
you
use
has
an
explicit
data
provider
argument
and
then
we
can
run
dce.
This
here
is
a
little
code
sample
from
IC
for
x.
There's
a
lot
of
code
here,
but
the
most
important
part
is
that
you
call
that
you
invoke
this
function.
You
give
it
a
data
provider.
The
data
provider
satisfies
these
bounds.
These
three
bounds,
and
these
three
are
the
basically
pieces
of
data
that
you
need
we
have
over.
C
You
know
we
have
over
a
thousand
different
pieces
of
data
in
our
full
data
file,
including
locales,
including
locales,
and
including
the
data
keys,
I,
think
there's
about
300
data
keys.
So,
in
this
case,
we
only
need
three
of
them
in
order
to
create
this
time.
Formatter.
This
thing
I
can
format
in
an
hour
and
minutes
second
display.
We
only
need
these
three
and
we
only
need
to
link
those
three
I'm
going
to
keep
moving
on.
C
We
use
postcard
as
our
way
for
storing
data
in
a
binary
form
postcard
as
a
deserialization
crates
written
by
James
munz,
with
small
code
size
and
perf
as
its
goals.
This
allows
us
to
do
the
dynamically
loaded
data
which
allows
us
to,
for
example,
load
from
a
server
or
from
the
environments
from
the
operating
system
and
postcard
allows
us
to
put
it
in
a
way
that's
suitable
for
that
interchange.
C
Deserialization
is
normally
expensive,
but
with
postcard
we
can
do
it
all
in
a
zero
copy
fashion
and
again
we'll
be
if
you
want
to
learn
more
about
how
this
works,
how
we're
actually
able
to
do
that?
Stick
around
for
manisha's
talk
after
my
balancing
performance,
so
a
big
part
of
ic4x
is
you
know
again.
We
want
to
make
small
code,
but
we
also
want
to
have
good
performance
and
low
memory
usage.
Often
these
things
go
together
for,
for
example,
enabling
zero
copy
deserialization
has
all
of
these
benefits.
C
It
reduces
memory
and
code
size
and
it
increases
performance,
which
is
great,
there's
also
other
cases
where
it
doesn't
always
work
out.
That
way,
for
you
know
a
very
easy
example
to
grok,
for
that
could
be
a
binary
source
which
is
Hash
table
like
a
binary.
It's
like,
if
you
have
an
array
of
items
and
you
want
to
be
able
to
index
into
them
and
look
them
up
quickly.
C
It's
very
small
data
and
small
code
to
use
binary
search,
but
it's
not
as
fast
and
using
a
hash
table
is,
you
know,
a
bit
more
code
and
data,
but
it's
a
lot
faster.
So
that's
just
a
very
simple
example
to
illustrate
an
IC
fracture,
try
to
take
a
holistic
view
if
there's
something
that
has
a
big
win
in
one
category
and
a
little
bit
less
of
regressions
in
the
other
mobile
tickets.
So
we
try
to
balance
all
of
the
requirements.
C
We
use
a
data
structure
to
store
Unicode
character,
properties
that
has
very
small
code
and
data
and
has
fairly
fast
lookup,
but
not
as
fast
as,
for
example,
there's
over
a
hundred
thousand
characters
in
Unicode
the
fastest
way
to
do
it
would
be
to
store.
You
know
one
byte
per
thousand
ten
hundred
thousand
characters
in
this
index
into
the
array,
but
that's
very
much
more
data
than
you
need,
so
instead
we
can
compress
that
down.
C
We
lose
just
a
little
bit
on
performance,
but
we
have
huge
wins
on
codes
on
on
data
size
and
code
size,
so
I'm
going
to
back
up
what
I
said
now
with
some
numbers,
because
you
don't
believe
anyone
who
doesn't
show
you
numbers
in
in
in
in
this
one.
So
this
here
is
an
example
of
date,
time
formatting
I
compared
ICU
72,
which
is
the
you
know,
current
stable
release
of
ICU
to
IC
for
x1.0,
and
this
is
a
performance.
C
These
are
performance
numbers
for
a
small
micro
Benchmark
that
we
ran
I,
see
for
c
takes
a
little
over.
What's
that
400
thousands
nanoseconds
in
order
to
to
run
our
example,
and
we
broke
that
down
into
what's
actually
happening
here
so
The
Constructor
for
the
daytime
formatter
object
is,
is
the
red
bar
and
that's
basically
the
cost
in
order
to
load
the
data,
that's
needed
and
then
parse
and
process
that
data
and
then
the
the
yellow
part
is
what's
actually
running
in
in
the
type
Loop.
C
We
can
also
see
that
on
the
IC
for
X
columns,
the
baked,
which
is
on
the
far
right,
doesn't
have
any
cost
on
the
on
the
there's,
an
extra
Blue
Bar.
It
doesn't
have
any
cost
on
that,
because
the
baked
data
is
an
additional
way
that
that
we
are
able
to
store
data
that
doesn't
even
require
any
deserialization
at
all,
but
I'll.
C
Let
Manish
explain
more
about
that
and
then
the
the
two
columns
in
the
middle
are
when
we
have
postcard
data,
so
postcard
encouraged
just
a
little
bit
of
cost,
but
it's
still,
you
know
mini
School
compared
to
what
ic4c
requires.
In
addition,
these
are
code,
size,
measurements,
so
IC
for
C
is
the
blue
bar
on
top
and
I.
See
for
X
is
the
Red
Bar
on
the
bottom.
C
This
is
a
code
size
for
a
program
that
prints
this
number
one
million
and
seven
in
Bangla,
digits
and
yeah
I,
see
for
X.
You
know
is
bills
and
optimized
to
be
able
to
have
a
smaller
code
footprint,
and
you
know
you
can
see
that
it
works
quite
quite
well
here
now.
You
know
you
might
be
asking
well.
Is
this
really
a
fair
comparison
with
with
ic4c
IC
for
X
to
to
be
fair?
C
I
made
a
first
version
of
this
graph
in
October
and
then
I'm
like
this
is
not
a
fair
comparison.
I
actually
went
into
IC
for
C
and,
like
edited
the
code,
to
try
to
make
it
as
modular
as
I
could
for
simple
number
formatting
and
then
I
updated
the
graph
today
before
I
gave
this
talk
and
I
got
the
the
blue
bar
down
by
about
20,
but
not
more
than
that,
so
maybe
there's
still
more
low-hanging
fruit,
but
you
know
I
think
this
is
very.
You
know.
C
Illustrative
of
you
know
a
point
that
you
know
when
we
first
started
working
on
ic4x
I
had
to
make
to
my
management
at
Google,
which
is
like.
Why
should
we
start
to
serve
these
clients
who
need
small
code
like?
Why
are
we
start
starting
a
new
library
for
them?
And
it's
it's
because
of
this
is
because,
like
when
you
start
a
new
library
from
scratch,
that's
designed
for
modularity
and
small
code
size.
You
can,
you
know,
get
you
know
very,
very
good
results
versus.
C
If
you
you
know
hack
on
ic4c,
which
is
you
know,
it's
a
great
Library,
it's
not
designed
for
code
size.
So
what
are
some
learnings
trying
to
build
a
library
in
the
rust
ecosystem?
One
is
no
stood,
we
use.
So
it's
because
ic4x
wants
to
run
on.
You
know,
embedded
devices
on
Internet
of
Things
devices.
We
the
whole
Library,
believe
it
or
not,
is
no
stood
compatible,
meaning
we
don't
use
any
standard,
Library
functionality.
C
The
way
that
we're
able
to
achieve
this
is
by
abstracting
the
data
storage
as
much
as
possible,
for
example,
the
files,
for
example,
the
data
provider.
You
can
store
your
data
on
the
file
system
that
requires
a
standard
Library.
Obviously,
in
order
to
read
from
the
file
system,
but
if
you're
not
using
the
file
system,
you
don't
need
STD
for
that.
C
Another
part
of
you
know:
STD
enables
us
to
support
embedded
devices.
No
STD
also
is
great
for
webassembly
and
portability.
Wasm
stands
for
webassembly
in
case
you
haven't
seen
that
acronym
before,
because
when
you
can
build
IC
for
X
there's
fewer
dependencies,
you
need
to
link
which
makes
it
much
easier
to
build
for
those
environments.
C
Now
one
thing
that
I
sometimes
get
asked
is
we
use
the
Alec
module
in
ic
for
X,
which
some
people
will
say.
Well,
that's
not
pure
no
STD.
My
response
there
is.
We
have
thought
about
this.
A
lot
and
the
the
current
clients
that
we
have
of
IC
for
X
are
okay
with
having
an
Outlook
module.
If
you
are
a
client
who
needs
IC
for
X
without
Outlook,
please
open
an
issue
and
open
a
discussion,
be
you
know
we
have.
C
We
have
a
path
forward
in
order
to
get
to
that
world
as
well.
Just
just
let
us
know
another
thing
that
I
hear
a
lot
when
people
talk
about
ic4x
is
that?
Well,
you
have
you
know
when
I
look
at
at
a
cargo
tree
for
IC
for
X
I,
see
like
100
hundreds
of
results,
200
almost
200
lines
from
the
ICU
metatrade,
that's
a
lot
of
dependencies.
Why
do
you
have
so
many
dependencies
and
I
just
want
to
reiterate
that
we
don't
actually
have
that
many
dependencies?
C
Another
thing
about
building
a
library
in
rest
is
to
try
to
be
friendly.
Try
not
to
panic
in
ic
for
X
we
have
no
implicit
panics.
We
use
clippy
to
enforce
this.
For
us,
clippy
has
a
number
of
checks
that
you
can
enable
that
can
help
to
make
your
code
Panic
free,
and
we
also
use
data-driven
algorithms.
C
So,
in
order
to
in
order
to
handle
this
problem,
we
have
we
we
validate
the
data
when
it
comes
in
only
when
it's
cheap,
but
if
it's
not,
then
we
use
other
mechanisms
like
warnings
and
debug
assertions
and
best
efforts
to
handle
invalid
data
by
handling
errors,
gracefully
whenever
possible
and
yeah.
This
has
been
a
big
part
of
our
design
and
we've,
you
know
been
able
to
achieve
it.
So
that's
great
okay,
so
last
slide.
C
Key
takeaways
are
that
for
people
in
this
room
watching
and
people
on
the
live
stream
later
internationalization
consists
of
a
lot
of
subtle,
data-driven
algorithms,
which
is
why
you
need
IC
for
X
to
solve
all
of
your
i8n
needs.
It
solves
them
in
Rust
and
Beyond,
and
it's
also
possible
and
we've
demonstrated
how
you
can
build
a
large
library
in
Rust
that
is
no
stood,
dozens
of
panic
and
Still
Remains
suitable
for
slicing
and
other
compiler
optimizations.
C
C
You
can
find
us
on
GitHub
Etc
and
you
know
I'd
love
to
talk
more
to
you
we've.
You
know
we
have
the
GitHub
discussions
that
we
use
that
a
lot
of
clients
who
are
like
thinking
about
adopting
IC
for
X
post
questions
on
the
GitHub
discussions
tab,
that's
a
great
way
to
get
in
contact
with
with
the
team
and,
yes,
I'm
sure
you're
tired
of
hearing
me
talk
non-stop
for
the
last
like
30
minutes
or
so.
So.
C
That's
a
good
question
yeah,
so
that's
a
thing
to
illustrate
the
internationalization
is
an
architecture.
Internationalization
is
something
that
you
need
to
think
about
when
you're
building
your
app
all
the
way
from
you
know,
basically
Ground
Zero
and
the
Japanese
light
switches
are
are
two
illustrate,
the
the
that
point.
I
don't
know.
If
there's
currently
an
ICU
for
X
API
about
light
switches,
maybe
there
will
be
in
the
future,
and
so
that's
why
you
need
to
sort
of
think
about
building
it
in
at
the
core
level.
C
A
big
part
of
IC
for
X
is
that
the
functionality
that's
supported
is
based
on.
You
know
what
clients
have
needed
and
have
demonstrated
that
they
needed
for
you,
know,
client-side
applications
and
you
know,
there's
a
whole
Space
of
functionality
that
we
could
add
and
maybe
will
to
Ico
for
X
at
some
point
in
time.
E
D
C
A
good
yeah,
it's
it's,
it's
a
good
question.
There's
you
know
others.
Other
people
on
my
team
have
been
working
on
on
IC
for
X.
You
know,
I
talk
about,
like
you
know,
does,
does
Russ
have
a
big
learning
curve,
and
this
is
a
debatable
question.
Like
you
know,
I
I've
I've
seen
data
recently.
Actually,
that's
like
that
says.
C
C
It's
not
clear
whether
or
not
that's
greater
in
Rust
than
it
is
from
other
languages.
In
fact,
I've
seen
data
that
says
it's
really
not
so
that
that's
worked
well.
I'd
say
that
you
know
one
of
the
biggest
pain
points
has
been
like
all
soluble
problems
like
you.
Try
trying
to
interrupt
with
C,
plus
plus
I
think
is
something
you'll
hear
a
lot
like
rust
and
C
plus
kind
of
talk
to
each
other,
but
not
completely,
and
how
do
you
make
them
talk
better
with
each
other.
C
I
know,
there's
a
whole
lot
of
work
in
this
area,
especially
at
Google.
This
is
something
that
Google
and
is
investing
a
lot
in
right
now
is,
is
in
this
this
space
of
rust,
C
plus
plus
interop,
we've
managed
to
make
it
work.
That's
why
we
have
Diplomat,
and
hopefully,
like
you
know
now
that
there's
it's.
This
is
no
longer
like
you.
C
You
don't
have
to
be
a
Trailblazer
anymore
if
you're
trying
to
do
rest,
C,
plus
plus
interop,
because
there
are
a
lot
of
good
Solutions
and
you
know,
we've
done
a
lot
of
that
work
as
well,
but
yeah
overall,
I'm
really
happy
with
with
Russ,
and
really
glad
that
we
that
we
chose
that
when
we
were
looking
at
the
projects
early
on,
we
were
looking
at.
You
know
many
different
programming
languages
to
use.
We
were
looking
at
C,
plus,
plus
C,
plus
plus
20.
C
We
were
looking
at
starting
in
something
like
Java
to
do
this.
We
were
looking
at
the
programming
languages
and
you
know
at
the
time
rest
was
a
little
bit
of
of
taking
a
bet
that
like
well.
If
like,
are
we
going
to
go
all
in
on
Rust
and
bet
on
it,
and
we
ended
up
doing
that
and
I
think
it's
worked
out
really
well
for
us.
C
Yeah,
I'll
repeat
the
question.
The
question
is:
I
was
saying
that
Ico
for
X
has
data-driven
algorithms.
What
does
data-driven
algorithms
really
mean?
Does
it
mean
they
have
a
lot
of
machine
learning?
Models
can
be
more
specific
there
and
what
I
mean
by
data
driven
algorithms?
Is
that,
for
example,
if
you
need
to
do
a
if
you
need
to
format
a
number
or
a
date,
the
exact
the
exact
formula
for
how
you
do.
That
is
not
something
that
you're
writing
code.
C
So
you
know
the
the
source
of
the
data
could
be
machine,
learning
algorithms.
We
use
machine
learning,
for
example
in
text
segmentation,
where
we're
actually
we're
able
to
get
smaller,
faster,
better
models
than
if
we
do
it
manually
for
things
like
date,
formatting
and
number
Rules
and
Things.
Those
are
pieces
that
are
largely
you
know,
come
from.
You
know.
Locale
experts
will
create
those
so
they're,
not
all
like
trains
like
machine
learning.
Some
of
them
come
from
experts.
Some
of
them
are
trained
for
machine
learning
But.
C
Ultimately,
at
the
end
of
the
day,
it's
the
same
problem.
You
know
when
you
write
a
machine
learning
algorithm
and
when
you
write
your
convolutional
neural
network.
Ultimately,
it's
just
code
that
processes
data.
It
doesn't
know
anything
about
what
it's
doing
it's
just
sort
of
a
pipeline,
and
that's
that's
how
I
see
it?
It's
all
about
the
pipeline
of
how
you
take
data,
how
you
push
it
through
some
algorithms
and
get
something
useful
on
the
other
end
and
that's
ultimately
what
ic4x
is
and
what
many
parts
of
software
are
really
all
about.
D
C
C
You
know
one
thing
that
I
was
that
I've
been
very
clear
about
is
that
icfrex
does
not
seek
to
replace
or
displace
ICU
foresee,
as
the
general
purpose
internationalization
Library
I
see
for
X
is
designed
for
specific
use
cases
there
may
be
some
users
of
icu4c
who
look
at
ic4x's,
Value,
propositions
and
think
well.
I
see
for
X
is
a
really
good
alternative
and
that
that's
great
I,
don't
I,
don't
expect
that
they'll
be
necessarily
applicable
to
everyone.
C
For
example,
ic4c
has
a
lot
of
has
a
much
larger
feature
coverage
I
see
for
X's.
You
know
unlikely
to
ever
reach
the
full
set
of
features
that
are
available
in
ic4c.
That's
a
really
good
example!
So,
yeah
now
to
answer
your
question
about
how
like
how
do
they
actually
talk
to
each
other?
Do
I
see
for
C
and
ic4x
actually
talk
to
each
other.
The
answer
is:
that's
something
that
I
wanted
to
look
into
more
in
2023.
C
Are
there
ways
that
we
can
actually
share
logic
between
ic3c
and
ic4x
right
now,
they're
completely
separate
projects,
they
they
don't
talk
to
each
other,
except
they
accept
a
little
bit
during
data
Generation,
but
the
actual
runtime
libraries
don't
talk
to
each
other
at
all.
I
would
like
to
change
that
a
little
bit.
For
example,
we
currently
use
a
machine
learning
lstm
models
for
our
text.
C
Segmentation
I
would
like
to
see
a
world
where
we
don't
have
to
write
those
twice
in
C,
plus
plus
and
in
rest,
I'd
like
to
see
a
world
where
some
of
the
more
complicated
algorithms,
like
calendrical
calculations,
non-gregorian
calendars.
We
can
write
once
and
use
them
everywhere.
That
would
be
great
if
we
can
get
you
to
that
world.
I
think
that
this
is
going
to
be
an
evolving
process.
C
D
C
This
or
it
was
not
a
thing:
okay,
yeah,
I'll,
repeat
the
question.
I
forgot
to
repeat
the
previous
one:
I'll
try
to
remember
to
repeat
the
questions.
The
question
was:
we
said
that
for
things
like
aesthetic
data
slicing
and
other
things,
we
need
to
rely
on
the
output
of
the
compiler.
In
order
to
you
know
perform
that
type
of
optimization.
Would
it
be?
C
Would
it
be
beneficial
for
us
to
do
more
of
that
at
that
Source
like
within
the
store,
so
we
can
actually
set
up
analyze
the
code
without
having
to
actually
compile
it?
Is
that
summarize
pretty
well
cool?
Are
we
it'll,
be
nice?
It'll
be
great.
It
would
be
nice
to
think
about
that.
One
thing
is
that
a
lot
of
cases
in
a
lot
of
cases,
the
like
we
have
to
analyze
pretty
much
the
whole
tree
of
icy
Forex
in
order
to
really
get
the
full
picture.
C
There's
cases
where,
for
example,
there's
you
might
need
to
load
a
particular
thing
and
that's
only
valid
in
certain
locales,
but
not
others,
and
in
order
to
see
the
full
picture,
we
need
to
basically
analyze
the
whole
of
the
whole
tree
of
code,
so
it
kind
of
makes
sense
to
actually
let
the
compiler
do
this
because,
like
llvm,
a
link
time
optimization
is
is
fantastic.
It
does
an
absolutely
fantastic
job
at
solving
this
problem.
It
could
be
something
that
we
could
do,
maybe
at
source
time.
I.
C
B
B
B
C
Oh
yeah,
the
question
was:
can
I
elaborate
a
little
bit
on
copy
error
messages?
Yeah?
So
you
know
when
you
have
a
function,
signature
and
your
function,
Returns
the
results,
it's
great
that
you
know,
I,
think.
The
way
that
rust
handles
errors
is
is
really
is
really
good.
It
makes
error,
handling
explicit.
You
don't
have
to
worry
about.
You
know,
try
catch
with
exceptions
and
I
think
that
model
is
really
great.
C
So,
in
order
to
strike
that
balance,
basically
in
debug
mode,
we
a
log
with
log,
warned
the
the
log
crate,
the
full
error
message
and
in
release
mode.
You
can
choose
to
disable
that
feature,
and
you
don't
get
that
the
the
you
can
optimize
from
the
smaller
code.
That's
one
thing
that
I
guess:
I
should
also
point
out
since
I
don't
know,
maybe
some
people
are
considering
playing
around
with
ic4x.
C
A
I
wondered
about
something
when
I
saw
these
data
providers,
where
you
had
this
bound
with
the
D
that
had
three
different
marker
traits
right
or
three
three
different
markers,
so
I
can
imagine
like.
If
you
try
to
use
that
data
provider
wrong,
then
you
get
a
compile
layer
right.
You
try
to
get
something
from
it
that
the
data
provider
doesn't
have.
And
then
you
add
this
extra
marker
and
you
expand
your
function,
signature
and
then
you
compile
in
more
code
and
that's
fine.
So
then,
what
if
you
stop
using
that
yeah?
So
in.
C
But
this
requires
that
you
basically
have
a
very,
very
good
test
Suite,
because
there's
going
to
be
some
Locale
that
you
didn't
think
about
that
requires
Roman
numerals
in
date
formats,
for
example-
and
you
didn't
include
date
formatting,
you
didn't
include
Roman
numerals
in
order
and
then
you
someone,
you
hits
that
Locale
loads,
your
app
with
that
Locale
in
the
crash
and
yeah.
So
the
ic4x
signatures,
basically
like
you
know,
are
comprehensive
because.
C
Yeah,
that's
a
good
question,
so
we
we
there's
a
page
on
our
Wiki
on
our
GitHub,
that
that
explains.
That
explains
how
this
works.
Okay,
the
shortest
the
short
answer
is
you
know,
while
we're
developing,
we
do
add
and
remove
things
from
that
signature.
It
also
means
that
the
signature,
when
we
add
and
remove
the
data
I'll
just
skip
back
to
that
slide.
It's
back
here
somewhere.
C
All
the
way
back,
where
is
it,
did
I
go
back
too
far?
Maybe
I
went
back
too
far.
I
think
I
went
back
too
far.
Sorry
this
one
yeah,
so
you
notice
that
and
I
think
this
is
maybe
something
that's
a
little
confusing
when
you're
first
using
I
see
for
X,
it's
called
try
new
with
length
unstable,
that's
a
really
weird
function
name.
Why
did
we
call
it
that
so
try
new
is
a
Constructor.
C
That's
what
Russ
calls
Constructors
that
return
results
with
length
means
that
this
Constructor
takes
one
argument:
in
addition
to
the
data
provider
Locale,
it
takes
a
length
and
unstable
means
that
this
list
of
bounds,
these
data
provider
bounds,
are
subject
to
change
over
time,
because
you
know
we
continue
to
evolve
our
codes,
so
you
can
add
and
remove
data
provider
bounds
from
this
function,
so
the
function
is
unstable.
We
do
have
stable
versions
of
these
functions
and
you
can
read
more
about
how
we
make
that
work
and
there's
a
whole.
C
D
C
It's
it's
it's
time
within
the
length
namespace.
This
is
also
a
discussion
that,
like
this,
is
one
of
the
bike
shed
discussions
that
we
had
many
times
when,
like
among
IC
fraction,
you're
developing
it's
like
well,
it's
really
time
length.
Should
we
call
it
it's
an
enum
time
is
an
enumeration.
It's
an
enum
that
has
like
five
options
in
it.
It
should
be
called
time
length,
but
instead
it's
actually
length
colon
called
it's.
It's
an
enum
called
time
in
a
namespace
called
length,
and
you
know
we
went.
C
We
went
back
and
forth
a
lot
being
like
well,
should
we
repeat
the
name
of
the
namespace
just
so
that
when
you
put
in
your
code
it
says
time
length
and
yeah
we
ended
up.
This
is
we
we
ended
up
repeating
the
namespace
in
some
places,
but
then
for
the
for
these
low-level
enums.
We
decided
to
leave
it
that
way.
So,
oh
yeah,
that
that
is
a
bit
misleading
and
on
this
slide,
I
think
yeah
I've
been
up
here.
I
I
think
I've
I've
fully
filled
up
my
time
box.