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

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

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

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

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

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

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

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


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

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

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

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


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

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


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

[JSConfEU 2010] Brendan Eich: Proxies are Awesome!
觀看次數：424
that's
now
working
harmoniously
together
and
that's
this
notion
of
proxies
but
YouTube
videos
and
goofing
around
my
craps
skittles
out
of
its
rear
end
javascript
doesn't
meet
that
kind
of
belgium
and
it's
it's
got
a
long
history
ecmo
script
and
it's
called
es5
for
eckman
methods
it
has
json
based
on
dougs
json
metaprogramming
API
for
defining
getters
microsoft's
answer
to
ajax
which
was
that
browser
was
ie
and
if
it
couldn't
to
assume
it's
firefox
if
it's
firefox
I
define
getter
double
underscore
defined
great
in
firefox
didn't
work
in
Safari
setter
and
lookup
getter
look
up
said
her
to
javascript
core
in
the
webkit
and
it's
good
so
if
it's
good
let's
do
synthesized
into
the
metaprogramming
API
and
es5
javalang
reflect
only
javascript
line
know
alien
to
javascript
it's
certainly
only
the
the
built-in
constructors
extension
configurability
is
important
actually
in
a
firefox
4
it's
coming
along
in
the
webkit
nightlies
and
it's
metaprogramming
API
looks
like
it
has
in
quotes
you
get
back
a
descriptor
that
set
happens
to
be
undefined
there's
no
open
paren
close
paren
syntax
its
loop
it's
configurable
you
can
you
can
initializers
happen
to
work
but
you
defaults
that's
what
the
grayed
out
part
implies
-
not
writable
and
not
configurable
and
in
that
case
that
Z
find
out
that's
that's
the
case
you'll
configurable
writable
etc
instead
of
a
that's
kind
of
online
that
the
mozilla
that
are
progressively
more
restrictive
can
reassign
them
reconfigure
them
if
they're
configurable
but
you
cannot
add
configurable
so
that
they
can't
be
deleted
or
replaced
with
getters
things
tool
that
does
effectively
free
extensions
know
programming
sanity
and
there
are
more
metaprogramming
you
know
why
do
you
go
crazy
with
meta
programming
and
a
lot
small
talk
on
javascript
ajax
library
vm
double-under
vars
on
the
name
it's
never
have
non
configurable
and
non
writable
weird-ass
virtualized
built-in
objects
and
that
incompatibilities
across
browsers
and
across
browser
versions
so
that's
a
getters
and
setters
based
on
the
prior
setter
defined
using
the
es5
api
or
the
declarative
syntax
in
object
literals
and
setter
and
that's
not
general
it's
additions
for
each
array
X
getter
and
a
setter
that
will
do
the
hard-code
the
names
that's
better
built-in
class
called
proxy
and
it
has
a
the
first
is
conventionally
passed
as
an
object
initializer
it's
the
handler
and
proxy
that
the
handler
is
your
own
initializer
maybe
it's
some
object
that
evolutions
of
of
an
object
if
you're
an
object
that
it's
fronting
for
but
again
that's
that's
incidental
that's
almost
seamlessly
and
there's
a
few
correspondences
between
the
meta
layer
hand
without
phooey
quills
42
turns
into
ham
sorry
proxy
about
foo
equals
42
terms
at
the
handler
dot
set
proxy
the
handlers
get
method
and
proxies
can
expressions
which
turn
into
handler
that
proxy
the
handler
has
traps
there's
a
proxy
dot
foo
that
calls
handler
dot
foreign
loop
over
a
proxy
the
handlers
if
you
do
metaprogramming
using
those
that
includes
the
metaprogramming
API
s
so
there's
a
hand
without
defined
proxy
triple
equals
saabs
there's
no
for
a
proxy
that's
not
a
function
proxy
at
that
but
it's
not
not
harmonious
yet
meta-level
handler
trap
calls
with
the
arguments
that
you
expect
and
there's
the
metaprogramming
API
and
es5
there's
handler
to
optimize
a
little
harder
but
that
we've
just
been
discussing
this
I
there's
a
separate
iterate
it
returns
an
iterator
and
this
it
fits
right
into
proxies
it's
a
functions
especially
they
have
closures
as
separate
arguments
to
proxy
to
create
there's
fun
props
arguments
new
phone
proxy
one
to
three
proxies
and
type
of
doesn't
lie
and
this
kind
of
meta
programming
it's
invariants
like
triple
equals
should
work
and
this
invariant
you
know
it's
invoked
trap
now
proxies
can
do
you
the
developer's
power
that
implementers
who
write
c++
not
even
the
people
who
formalize
what
the
browser
java
javascript
everything
for
the
90s
uniformity
and
meta
programmability
of
more's
the
pity
javascript
wasn't
built
writing
handlers
creating
proxies
and
to
selectively
intercept
it
do
this
kind
of
stratified
dynamic
proxies
metaprogramming
in
the
hands
of
javascript
code
know
javascript
a
reg
X
of
object
to
suddenly
start
sprouting
handlers
that
existing
code
expects
what
programmers
expect
so
that's
why
proxies
have
to
be
of
a
forwarding
proxy
it's
given
an
a
stats
property
that
there's
a
getter
earlier
it's
prevent
extensions
that
configurability
limit
their
write
ability
seal
limits
configurability
not
retained
there's
no
reference
to
it
that's
pretty
cool
and
that
guarantees
like
gnosticism
but
there
is
a
meta
reality
and
this
meta
programming
lets
can
do
that
and
that
that's
that's
13
traps
that's
a
mouthful
but
what's
what
ladder
so-called
put
up
the
meta
ladder
handler
so
the
proxy
has
a
handler
the
handler
is
a
proxy
it
has
a
handler
and
handler
calls
turn
into
meta
handler
the
handler
and
the
that
meta
handler
it's
meta
meta
we're
getting
meta
on
meta
but
that's
cool
and
there's
there's
in
firefox
for
security
for
cross-site
scripting
for
the
privileged
zul
scripts
rationalized
and
they've
all
been
proxies
there's
a
good
history
research
org
kaha
the
capabilities
secure
a
subset
of
javascript
that
uses
membranes
also
the
membrane
some-some
way
of
saying
no
more
object
and
it's
printer
we're
just
going
forwarding
hands
pastoring
thing
we're
going
to
make
a
revoke
handler
and
it
has
a
rope
handler
that
is
a
proxy
reveal
candler
is
proxy
give
it
in
a
membrane
and
the
membrane
membrane
thing
which
is
the
forwarding
one-page
example
shows
it's
not
that
c++
it's
a
lot
of
c++
it's
very
bug
prone
it's
conceptually
simple
but
but
it's
it's
fairly
comprehensible
it's
this
meta
handler
and
you
have
a
revocable
membrane
so
this
is
all
based
on
tom
marx
very
good
work
and
that's
family
and
they
had
a
meta
programming
when
you
do
meta
programming
you
want
it
to
be
strapped
underbar
proto
double
underbar
no
more
you
can't
intercede
for
those
names
what
frodo
in
it
they're
kind
of
hosts
stratification
means
that
there's
a
how
you
do
meta
programming
you
kind
of
some
problems
as
browser
vendors
and
as
responsible
stewards
of
javascript
we
c++
browser
hackers
proxies
look
like
they're
sufficiently
powerful
to
do
this
wrappers
in
firefox
for
the
handlers
our
meta
programming
work
in
principle
might
be
good
the
proxies
can't
do
so
only
proxies
so
there's
nothing
that
hosts
object
can
do
that
a
proxy
can't
help
us
with
with
maintainability
and
other
browser
vendors
see
this
too
I
microsoft
about
this
and
travis
Lee
head
points
diligently
and
what's
even
more
firefox
in
spidermonkey
in
this
past
don't
know
if
anybody's
heard
of
zaphod
old
narcissus
meta-circular
evaluator
I
wrote
as
a
firefox
plugin
you
can
very
easily
because
it's
javascript
you
zaphod
this
on
a
don
sutton's
law
that
Oregon
sand
add-on
it's
on
github
you
kind
of
went
with
narcissus
theme
he
had
learn
from
it's
it's
not
perfect
annette
tc39
is
we're
taking
well-informed
solved
for
javascript
developers
for
browser
vendors
you
cannot
solve
these
interoperation
ideally
do
do
more
corners
so
it's
not
like
you're
going
to
and
that's
what
we're
doing
in
firefox
know
in
javascript
we
don't
have
this
continuing
so
that
proxy
actually
sticks
and
so
far
it
hasn't
collided
on
the
web
proxies
in
firefox
for
as
far
as
I
know
little
micro
benchmark
this
is
from
the
proxies
if
they're
just
doing
forwarding
inline
small
functions
aggressively
so
forwarding
ones
we
can
inline
them
so
I
Michael
elizabeth
chastain
I
think
he
did
this
cool
debugger
that
used
linux's
debugging
API
to
capture
all
the
inputs
slider
on
your
debugger
or
you
could
could
do
a
replay
debugger
with
proxies
stratification
so
we're
past
adding
programming
properly
support
frees
and
committee
and
the
browser
vendors
and
let's
let's
do
it
and
really
javascript
on
github
you
can
see
it
uses
proxies
sisters
there
weren't
any
proxies
so
I
couldn't
host
narcissus
in
full
on
a
supported
to
be
standardized
harmonious
api's
bleeding
edge
so
here's
here's
cnn
and
it
has
some
scripts
on
it
narcissus
is
god-awful
slow
we
haven't
done
nothing
a
little
mozilla
head
added
by
zaphod
swapped
narcissus
which
runs
in
spider
javascript
engine
that
handles
application
javascript
text
javascript
scripts
on
cnncom
which
are
not
that
it
doesn't
run
gmail
yet
it's
just
narcissus
mimetype
we
haven't
register
the
narcissus
engine
through
zaphod
they

相關影片

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

加入好友

其他人正在學習的單字

1. mosquito
2024-04-29 06:44
2. for
2024-04-29 06:44
3. text
2024-04-29 06:44
4. competition
2024-04-29 06:44
5. unfair
2024-04-29 06:44
6. effects
2024-04-29 06:44
7. short
2024-04-29 06:44
8. paid
2024-04-29 06:44
9. work
2024-04-29 06:44
10. avenue
2024-04-29 06:44
11. impossible
2024-04-29 06:44
12. minimum
2024-04-29 06:44
13. stops
2024-04-29 06:44
14. performing
2024-04-29 06:44
15. picked
2024-04-29 06:43

本月觀看影片單字排行榜

本月查閱單字排行榜

本月聆聽單字排行榜