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

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

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

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

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

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

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

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


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

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

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

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


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

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


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

Android Suspenders (Android Dev Summit '18)
觀看次數：412
android
suspenders
today
we're
going
to
out
there
androids
exposes
a
single
ui
16
millisecond
time
limit
the
vast
that
you
have
just
over
16
milliseconds
so
90
hertz
means
you
have
12
milliseconds
120
hertz
means
you
have
8
millisecond
refresh
boundaries
this
is
there's
executors
which
most
java
to
use
on
its
own
loaders
loaders
now
deprecated
so
there's
not
a
whole
there's
listenable
future
which
has
unless
you're
working
on
min
sdk
24
you
can't
use
completable
future
either
and
pretty
simple
computationally
you're
not
megabyte
to
2
megabytes
of
RAM
every
an
imperative
line-by-line
into
it
it's
now
about
50%
carotenes
50%
free
libraries
from
the
kotlin
curtin's
to
interact
with
arcs
java
so
if
you're
there's
jar
file
store
from
maven
about
700
centi
four
kilobytes
so
that's
actually
shrinks
down
six-pack
ting
and
high
that's
like
5
percent
if
you're
64
optimization
turned
on
here
or
proguard
soon
as
you
turn
on
optimization
and
the
proguard
rules
you're
coming
down
to
hundred
kilobytes
and
again
you're
met
this
rule
it's
not
currently
bundled
co-routines
in
your
app
so
let's
go
creating
api's
suspend
functions
can
about
that
so
here's
a
suspending
method
async
builder
we
can
do
this
so
we're
using
the
async
builder
it
brings
a
cur
run
kind
of
independently
and
then
we
submitting
a
task
submitting
something
to
an
android
handler
for
example
when
about
the
basics
of
running
co-routines
automatically
we
needed
to
be
able
to
repository
and
our
co-routine
resumes
nice
clean
sequential
ordering
of
let's
go
ahead
and
demystify
how
some
of
wouldn't
just
call
cancel
straightaway
one
that's
currently
running
and
if
it
co-routine
scope
is
an
interface
that
a
lifecycle
so
fragments
activities
view
you're
launching
a
carotene
on
X
so
i'm
components
so
far
you
know
the
lifecycle
co-routine
scope
has
a
co-routine
co-routine
some
of
the
stuff
we're
gonna
and
similarly
correcting
scopes
provide
like
what
kind
of
fred
paul
dispatcher
and
now
it's
just
a
simple
instantiation
it
a
default
dispatcher
we're
gonna
talk
the
main
thread
android
manfred
in
this
async
builder
at
this
point
we
have
a
ones
to
child
proteins
so
once
they're
suspended
that's
similar
carotene
scope
gives
us
and
that
childcare
routines
carotene
so
if
the
parent
coatings
have
android
architecture
components
we
added
a
listener
at
least
the
functionality
carotenes
to
the
an
actual
lifecycle
that
will
means
that
co-routine
if
it's
with
ethan
at
100x
so
it's
not
nice
to
will
automatically
add
it
for
you
cancelled
if
it's
cancelled
while
it's
callback
just
hasn't
been
invoked
yet
it'll
throw
a
cancellation
exception
or
we
didn't
have
to
add
any
new
concepts
cancellation
explicitly
in
a
couple
of
see
if
your
codeine
is
currently
active
cancelled
when
you're
trying
to
suspend
to
be
cancelled
but
if
you're
in
a
tight
inner
computation
exceptions
are
handled
with
co-routines
kotlin
exco
routines
development
leading
uncaught
exception
at
runtime
just
like
there's
a
gotcha
here
and
that's
that
handled
the
deferred
object
that
it
co-routines
decomposition
we
can
use
supervisor
run
on
fred's
he
still
uses
fred
paul
that
she
gets
dispatched
on
now
let's
dispatcher
stop
default
that's
a
default
dispatcher
that's
kind
of
given
for
you
xstrata
so
what
is
a
protein
dispatcher
schedules
or
carotenes
to
run
on
a
fred
paul
at
four
which
isn't
so
great
computational
type
dispatcher
but
it's
the
default
there's
also
dispatcher
to
blah
it
uses
a
minimum
64
parallelism
about
the
io
dispatcher
is
that
it
she's
using
the
default
dispatcher
and
i/o
dispatcher
so
we're
gonna
do
some
somehow
there's
a
computational
task
now
dispatcher
there
is
no
actual
fred
on
the
ui
main
fred
conovan
who
wants
onto
reactivity
so
how
many
blog
posts
and
that's
why
most
iris
java
is
uses
chains
and
reactivity
but
I
think
from
the
ag
presentment
cases
it's
just
a
switcher
fred
and
that's
because
the
API
exist
on
eric's
java
are
at
scala
and
are
it's
groovy
they
don't
actually
maybe
incompressible
they
do
exactly
replacing
callbacks
they
also
replace
example
so
we
have
a
retrofit
interface
xjv
is
you
do
this
chaining
so
you'd
and
here
we
can
use
the
i/o
scheduler
use
it
as
like
a
suspending
deferred
so
of
slowly
migrating
towards
carotenes
using
carotenes
so
it's
quite
a
handy
that
retrofit
call
just
a
suspending
weight
and
it's
just
a
normal
suspending
know
it's
normal
carotene
and
that
providers
we
have
like
wi-fi
and
GPS
and
doing
is
converting
a
callback
api
into
a
suspending
function
that's
pretty
much
allows
you
to
setup
your
callback
so
I
you're
given
a
continuation
to
later
is
calls
accountable
so
actually
that's
suspend
cancelable
carotene
so
cousins
funada
it's
just
a
straight-up
location
cancellable
co-routine
builder
and
and
then
we're
going
to
a
continuation
that's
a
kind
of
callback
e
typing
and
back
to
the
suspended
coyote
in
the
backup
resumes
services
API
that
we've
been
cancelled
with
a
callback
which
is
infocomm
compare
rx
java
and
co-routines
quite
a
try
and
emulate
this
using
co-routines
using
a
callback
that's
invoked
multiple
disposed
we
get
this
composable
control
a
ton
of
functionality
to
build
things
suspending
functions
so
let's
again
suspending
functions
don't
return
until
cancelable
we
just
don't
return
until
we're
done
our
observable
completion
in
the
case
we're
creating
the
location
callback
holding
this
suspending
mutex
and
this
so
it'll
happen
on
cancellation
and
then
try-catch
and
that's
all
of
our
error
these
suspending
primitives
so
let's

相關影片

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

加入好友

其他人正在學習的單字

1. um
2024-05-06 16:43
2. order
2024-05-06 16:43
3. flinch
2024-05-06 16:43
4. blouse
2024-05-06 16:43
5. remember
2024-05-06 16:42
6. true
2024-05-06 16:42
7. sleeve
2024-05-06 16:42
8. drier
2024-05-06 16:42
9. amateur
2024-05-06 16:42
10. needed
2024-05-06 16:42
11. therapy
2024-05-06 16:42
12. surprise
2024-05-06 16:42
13. zoom
2024-05-06 16:42
14. thing
2024-05-06 16:42
15. fjord
2024-05-06 16:42

本月觀看影片單字排行榜

本月查閱單字排行榜

本月聆聽單字排行榜