系統設計者的話：學英文根本不用背，你講中文，你有在背中文嗎？學英文也是一樣的道理，那是自然而然就會的東西，用背的方式最後肯定都是不行的。 更多...

最好的學習就是有英文的父母，不斷的跟你說話、耐心的教導你，時間長了，你也就慢慢就融入其中了。

但是我們沒有英文父母怎麼辦？看影片學英文就學的起來嗎？學不起來。

我們從小到大，也看過了不少英文電影，至少也看過1、200部也跑不掉，但是為什麼看了這麼多的英文電影，英文還是很爛呢？

主要的原因是我們沒有從基礎性的強化學習。舉個例子，西方的幼兒出生時，他至少聽了各種大人講英文至少聽了2年，才慢慢開始說英文、與大人互動。

而且都是一字一句慢慢的說、慢慢的教、漸進式的、慢慢的、越來越習慣、越來越聽的懂、越來越會說的過程。

那麼我們看的影片、電影過程中，都是大人成熟型的講話速度、方式、語調，我們怎麼可能跟的上？

一旦跟不上，思想中就會產生覺的好難哦、我不行種種念頭，那麼產生了這種潛在式的排斥心理作用，那麼你就更難學的會了。


所以我們必須打好基礎、深厚的基礎，萬丈高樓平地起，唯有打下深厚的基礎，後面你走的路才會越來越順。

程式界裏有句話，程式債欠的越多，最後就只能放棄。學英文也是一樣，英文單字債欠的越多，你就直接上來文法、句型、語調，最後也只能放棄。

基於上述的思維，我打造了這套系統，從最基礎的單字學習起，不斷的強化、加深你對這個單字的聽力，透過各式各樣的影片、各式各樣的人、各種不同的場景。

就只是為了訓練一個單字的聽力，無數的人跟你講同一個單字，講個20遍、50篇、100遍(且不重覆)，我就不信學不起來。


這套系統做出來後，我自己在使用的過程中，確實真的能聽出來他們講的這個單字，而且他們講的速度再快也能聽的出來。

能聽的出來，就知道他講的大概意思；能夠知道他講的大概意思，就能夠用幾個簡單的單字回應；能夠回應，也就能夠對話；當能夠對話，就能夠再修正文法、句型、語調。


我的目地就是希望自己至少能聽的懂人家在說什麼，用英文跟人家對話，大家共同努力、學習。若有其它想法或對這套系統設計的建議，也可以與我聯絡：ichich2013@gmail.com

Trash Talk (Android Dev Summit '18)
觀看次數：403
sunglasses
didn't
actually
help
nor
did
had
certain
recommendations
there
so
for
dalvik
was
optimized
for
size
it
was
like
äôt
didn't
have
plates
to
stash
the
the
optimizations
were
not
optimal
allocations
collections
unbelievably
heap
fragmentation
was
a
problem
so
expensive
because
you're
allocating
them
unions
they
don't
yeah
ok
well
it's
the
allocations
and
collections
are
much
amazingly
faster
and
simpler
than
they
used
to
be
so
the
new
recommendations
art
is
concurrent
there's
stuff
deterministic
data
to
show
you
so
and
different
implications
so
if
we're
in
registers
dalvik
was
a
register
based
it's
kind
of
allocated
at
compile
time
the
registers
it'll
basically
find
a
higher-level
languages
like
java
and
kotlin
if
you're
writing
c++
code
then
you've
allocated
and
then
if
you
don't
non
deterministic
system
you
are
collections
tends
to
be
tedious
tends
to
be
very
error-prone
and
so
higher-level
take
for
the
system
to
automatically
dalva
because
we'll
see
its
fragmenting
garbage
dalvik
was
the
runtime
we
are
using
until
android
kitkat
that's
in
white
has
been
allocated
and
typically
local
variables
threads
static
variables
they're
just
the
roots
of
all
second
phase
is
concurrent
your
app
is
phase
is
concurrent
allocations
could
be
see
a
log
on
kitkat
doing
adb
logcat
you
typically
happens
when
you're
allocating
heaps
fragmentation
works
so
in
the
demo
everything
we've
allocated
and
free
okay
the
fragmented
heap
size
is
now
200
meg's
meg's
we've
got
200
we've
got
two
we
couldn't
find
2
meg's
contiguous
and
optimizations
it
no
longer
had
the
fundamentals
that
they've
been
improving
ahead
of
time
compilations
who
are
the
time
we're
not
constantly
getting
java
dot
util
dot
concurrent
that
that's
algorithm
then
people
name
the
algorithm
algorithm
behind
the
malloc
function
C
or
c++
this
is
the
algorithm
we're
using
so
dalvik
was
relying
on
that
allocations
are
grouped
together
to
reduce
fragmentation
we
online
large
and
overall
allocations
with
ross
let's
take
a
look
at
how
allocations
of
achlys
twelve
kilobytes
yes
and
that
100
milliseconds
may
run
that's
going
to
attention
so
you're
we're
compacting
the
show
that
same
defragmentation
a
crash
releases
until
we're
able
to
do
it
in
same
fragmentation
demo
that
we
saw
two
places
was
about
10
milliseconds
but
even
when
it
was
only
10
milliseconds
of
passes
last
for
100
200
milliseconds
allocations
that
are
reachable
in
your
10
milliseconds
in
there
we
only
spend
about
3
milliseconds
now
so
at
most
your
during
an
animation
or
scrolling
you
short-lived
we
won't
have
to
go
through
fragmentation
but
one
of
the
huge
a
faster
runtime
you
know
that's
the
ahead
of
time
compilation
here
it
is
optimizations
called
the
concurrent
heap
compaction
defragmentation
in
the
foreground
you've
not
resizing
the
heap
as
often
all
the
threads
to
do
these
allocations
one
of
these
buckets
it
allocates
in
get
defragmented
there's
a
heuristic
than
70
or
75
percent
utilization
and
called
thread-local
bump
allocator
this
just
move
a
pointer
we
don't
need
to
we're
now
18
times
faster
than
dalvik
t1
you've
got
the
free
pointer
we've
emptied
it
out
we've
zeroed
it
out
we're
the
pointer
the
pointer
tells
us
where
trade-offs
here
like
we
believe
it's
faster
than
educating
them
in
collecting
you're
creating
or
reusing
in
red
it's
locator
synchronize
pools
of
objects
are
graphs
cross
but
this
was
in
a
benchmark
and
maximizing
the
bandwidth
so
the
pool
approach
because
a
it's
error-prone
recommendations
now
creating
garbage
is
I
like
to
be
a
counterexample
flags
everywhere
to
optimize
every
overheads
and
we're
going
to
look
at
the
we're
gonna
test
Auto
boxing's
so
we
milliseconds
and
we're
causing
a
lot
of
collect
but
we're
never
triggering
that
that
jank
inducing
gc
for
alloc
in
this
in
this
one
you're
allocating
bitmaps
bitmap
you
take
in
1213
milliseconds
each
time
and
you're
constantly
triggering
these
gc
for
alex
because
you
here
run
the
animation
do
the
bitmap
here's
the
bitmap
test
very
simple
it's
using
fancy
physically
based
rendering
checkerboard
with
spheres
that's
right
and
I
ported
it
to
android
and
I
won't
primitives
they're
not
the
the
the
operator
overloading
in
catalan
we
are
multiplying
constants
we're
doing
division
additions
emulator
we're
emulating
the
same
we're
going
to
start
rendering
an
animation
with
a
try
tracer
and
at
the
all
rendering
1
tiles
takes
about
100
to
500
milliseconds
and
on
K
it
takes
40
to
computations
and
you
can
see
we're
constantly
stopping
all
the
threads
were
though
we're
doing
concurrent
garbage
collection
i'm
allocating
so
many
milliseconds
in
wall
time
that
our
originally
I
was
spawning
more
threads
about
30
to
40%
cpu
utilization
so
we're
the
benchmark
itself
but
the
algorithm
your
benchmarking
once
it's
inside
your
cpu
the
gold
cores
we
have
big
cores
and
course
every
core
has
an
l1
cache
that's
about
64
kilobyte
every
cores
an
l2
cache
so
256
kilobyte
cache
and
then
there's
an
l-3
cache
that's
shared
by
cpus
going
to
go
look
in
the
l1
cache
go
up
the
chain
so
accessing
the
l1
takes
only
a
few
nanoseconds
accessing
allocates
a
list
of
arrays
of
floats
four
floats
so
it's
16
bytes
like
in
RAM
all
the
arrays
are
neatly
RAM
and
i'm
using
a
width
of
64
bytes
i'll
run
some
computation
it
doesn't
our
caches
it's
in
RAM
it's
not
in
the
but
one
optimizations
that
cpus
have
is
they're
going
to
fetch
64
bytes
at
a
our
computation
now
in
my
test
app
i've
modified
the
initialization
of
the
around
or
you're
fragmentation
the
app
we're
running
the
same
algorithm
it's
variants
of
the
algorithm
where
again
the
algorithm
takes
about
I
think
150
milliseconds
on
a
pixel
3
so
that's
the
same
exact
computations
but
we'll
do
it
allocations
even
more
so
that
we
can't
you're
right
benchmarks
and
that's
very
benchmarking
the
the
cpu
access
better
they're
an
art
overtime
by
ladies
and

相關影片

加Line好友 每日8AM 推播1單字

加入好友

其他人正在學習的單字

1. same
2024-05-01 20:41
2. died
2024-05-01 20:41
3. field
2024-05-01 20:41
4. herald
2024-05-01 20:41
5. drama
2024-05-01 20:41
6. relatively
2024-05-01 20:41
7. weird
2024-05-01 20:41
8. find
2024-05-01 20:41
9. give
2024-05-01 20:41
10. covered
2024-05-01 20:41
11. become
2024-05-01 20:41
12. dope
2024-05-01 20:40
13. probably
2024-05-01 20:40
14. tv
2024-05-01 20:40
15. meet
2024-05-01 20:40

本月觀看影片單字排行榜

本月查閱單字排行榜

本月聆聽單字排行榜