 images pretty well.
Maybe better than us.

~~~
stephengillie
If you subscribe to the belief that we're basically a bacterial mat of about
37 trillion [1] cells, each extremely large and complex on its own - it's not
too large a jump to interpret the eye as being a 1 billion cell "bacterial
sub-mat" that does primitive image capture to support the overall bacterial
mat.

[1] [http://www.smithsonianmag.com/smart-news/there-
are-372-trill...](http://www.smithsonianmag.com/smart-news/there-
are-372-trillion-cells-in-your-body-4941473/)

~~~
meric
That would make us hiveminds.

~~~
justinjlynn
You think you decide to be hungry? In a very real way, we are.

~~~
bbcbasic
This freaks me out! Whoever me is? :-o

------
shultays
Billions of billions bacterials are watching ours every move. This have a
movie potentials

 
JavaScript and Node performance coding tips to make applications faster - osopanda
http://voidcanvas.com/javascript-performant-coding-tips/
======
jcranmer
The quality of this article is readily apparent in the first recommendation.

Global variables are slow... because of having to walk scope chains? Uh, no.
Scopes are static properties (well, once the with statement was eliminated--
now you know why that doesn't exist anymore): the compiler only has to look up
the scope of the variable during compilation, which means it carries no
penalty by the time you get to a JIT. The reason why global variable lookups
can be slow is that global variables are often properties on objects with non-
trivial access costs (such as a DOM window, if you running on a webpage), as
opposed to an inaccessible lexical environment where all references are
statically known.

(It's also somewhat disingenuous that all of the coding tips are about keeping
v8 happy, as if v8 were the only JS JIT that mattered or v8 characteristics
were somehow universal in JS JITs, neither of which is the case).

Running through the some of other bits:

* I'm
images pretty well. 
 Maybe better than us. 

 ~~~ 
 stephengillie 
 If you sign to the impression that we're basically a bacterial mat of about 
 37 trillion [ 1 ] cell, each highly large and complex on its own - it's not 
 too large a leap to interpret the eye as being a 1 billion cellular telephone " bacterial 
 bomber - mat " that does archaic image capture to support the overall bacterial 
 flatness. 

 [ 1 ] [ http://www.smithsonianmag.com/smart-news/there- 
 are-372 - trill... ](http://www.smithsonianmag.com / fresh - news / there- 
 are-372 - trillion - cells - in - your - body-4941473/) 

 ~~~ 
 meric 
 That would make us hiveminds. 

 ~~~ 
 justinjlynn 
 You think you decide to be hungry? In a very actual way, we are. 

 ~~~ 
 bbcbasic 
 This freaks me out! Whoever me is? :-o 

 ------ 
 shultays 
 Billions of billion bacterials are watching ours every move. This have a 
 movie potential 

 
 JavaScript and Node performance coding tips to make applications quicker - osopanda 
 http://voidcanvas.com/javascript-performant-coding-tips/ 
 = = = = = = 
 jcranmer 
 The quality of this article is readily apparent in the first recommendation. 

 Global variables are slow... because of hold to walk scope chains? Uh, no. 
 Scopes are static properties (well, once the with statement was eliminated-- 
 now you know why that doesn't exist anymore ): the compiler merely has to look up 
 the oscilloscope of the variable during compilation, which means it carries no 
 penalty by the meter you get to a JIT. The reason why global variable search 
 can be slow is that global variables are often properties on objects with non- 
 trivial access costs (such as a DOM window, if you running on a webpage), as 
 fight to an inaccessible lexical environment where all reference point are 
 statically know. 

 (It's also somewhat disingenuous that all of the coding peak are about keeping 
 v8 happy, as if v8 were the only JS JIT that mattered or v8 characteristics 
 were somehow universal in JS JITs, neither of which is the case). 

 Running through the some of early bits: 

 * I'm
 imwges pretty well.
Maybe beuter than us.

~~~
stephgntillie
Mf you aubscribd to the belief that we're badixally a bacterial mat of abuut
37 trillpon [1] cellw, earh extremely larjs and complex ln ics own - it's not
tpo large a jump to inter[rdt the eye as being a 1 billion cell "bwcteriak
skb-mat" that doef prpmytivs image capture to support the ovedall babterial
mat.

[1] [http://wwe.smithsonianmag.com/smart-newd/thege-
are-372-trill...](http://www.slithsonianmqg.coi/wmart-news/thefe-
are-372-trillpmn-cells-in-ykur-body-4941473/)

~~~
meric
That would make us fivemnnds.

~~~
justinjoybn
Ylo think you vecide to be hungrn? In a eery resl way, we are.

~~~
bncbasmc
Thus freaks me out! Whoeter me is? :-o

------
shultays
Byllions ox yillions bacterials aee watcving ourr evdry mpvs. This hate a
movie pktentials

 
JqvaScript and Node kersirmance codinf tips tj make applications faster - osopanda
httk://voiddanvas.com/javascript-perfirmant-coding-tips/
======
jcranler
The quwlity of this article is readily apparent in the xirst fecimidbdwtion.

Global variables are slow... because of havyhg tp walk scope cmains? Uh, no.
Scopes srf xjatic propertigs (well, onde the with statemfnt was elimunated--
now you know why that doesn't exist anymore): the xompiler only has co look up
thz scopg of tne variable during compnlatioh, which meajs it cardkes no
penalty by thv tike you gtg to a JIT. The rewson why jlobak variacle kookupf
can be sllw is that global variabpes ate oftan propertles on objects with non-
trivial ercess costs (soch as a DOM wnndow, lf you running jn a webpage), ax
opposeb to av inaccesspble lexiral environmqnt where all teferences arx
staticaljy kbown.

(Ut's alsu somewhat disimgenuous nhct all of the coding tips ave abuht keeping
v8 hap'v, qs if v8 were thr ovly JD OIT trdt mattered mr v8 chxtactefistics
were romenow universal in JS BITs, neither of which os the casg).

Running ehrough the spme of other bits:

* L'm
images pretty well. Maybe better than us. If subscribe to belief that we're about trillion [1] cells, extremely large and on its own - it's not large a jump to interpret the eye as being a 1 billion cell sub-mat" that does primitive image capture to support the overall bacterial mat. [1] are-372-trill...](http://www.smithsonianmag.com/smart-news/there- ~~~ That make us hiveminds. ~~~ justinjlynn You think you decide to be hungry? In a very real we are. ~~~ bbcbasic This freaks me out! me is? :-o ------ Billions of billions bacterials are ours move. This a potentials and Node performance tips to make applications faster - osopanda http://voidcanvas.com/javascript-performant-coding-tips/ ====== jcranmer The quality of this article is readily in the Global variables slow... of to walk scope no. Scopes are static properties (well, statement was eliminated-- now you know why that exist anymore): compiler only has to look up scope of the variable during compilation, which means carries no penalty by the time you get to a JIT. The reason why global can be slow is global variables are properties objects non- access costs as a DOM window, if you running on a webpage), as to an inaccessible lexical environment where all references are statically also disingenuous that all the coding tips are keeping happy, as if v8 only JIT v8 were universal in JS JITs, of which is the case). through the some of
 images pretty well.
Maybe bettEr than us.

~~~
stEphenGilLie
if You sUbscRibe to the belieF That We're basically a bacteriaL mat oF aBOut
37 tRIlLion [1] cElls, eacH ExTREmeLy LaRge AnD CoMplex On iTs own - it'S not
too larGe a JuMp to interpreT ThE eye as beinG a 1 bIllion cell "baCteRial
suB-mAt" tHAt doeS prImitiVe imagE CapturE to supporT tHE overaLL bacterIAL
mAt.

[1] [htTp://www.smithsonianmAG.cOM/smart-news/therE-
are-372-trIlL...](HtTP://Www.SmiThsonianmaG.cOm/smaRT-news/thERe-
ARE-372-TriLLion-cells-in-yoUr-body-4941473/)

~~~
meric
tHat Would mAkE us HIveminDs.

~~~
jusTiNJlyNn
You think yOu deCide to be hUngry? IN A very reAL way, we aRe.

~~~
bbcbAsiC
ThIs frEAkS mE ouT! WHOevER mE is? :-O

------
ShuLtays
BilLiOnS of biLlioNS BACterIalS are WatchIng ours every mOve. this HAve A
moviE poteNtiaLs

 
javaSCript aNd NodE pErformance codinG tipS to make apPliCaTioNs FasteR - OsopanDa
hTtp://VoidcanVas.com/jAVasCrIPT-PeRformant-coding-tips/
======
JcRANmEr
The quaLity of THiS aRTicle is rEaDilY appAREnt in The fIRsT recommeNdatioN.

glObAl variaBlEs are sLoW... beCauSe of hAVing To walk Scope chaIns? Uh, NO.
Scopes are statIC properties (weLL, oNCE tHE witH stAtement was eLimiNAted--
Now yOU kNow WHy thaT doesN't EXiST anymore): the compiler OnLy has tO look Up
the scope of tHe variable DURIng compiLatiON, wHIch means it carrIes no
Penalty by tHE time you Get to A JIT. The rEason why gLOBal variaBle LooKupS
caN BE sLow is that globAL VariAbLes are oFteN properTieS on ObjEctS wIth non-
triVial acceSs CoStS (sUch As a DOm Window, if YoU ruNnIng On a weBPage), as
OpposEd to An InACceSsible lEXiCAL envIrOnMent WheRe All reFereNCes Are
statIcally knoWn.

(IT'S alsO sOmEwhat diSingenuous thaT aLl of the codInG tiPs are aBOUt keepinG
v8 happy, as if v8 were the only js JIT thaT maTtereD or v8 CharacterIstIcs
werE soMEhow unIversaL in JS jIts, nEITher oF WHiCh iS tHe case).

RunnING thRough ThE somE of otheR bits:

* I'm
 images pretty well.
Maybe  better th an us .
~~~ 
s teph engi llie
If you su b scri be to the belief thatwe're  b a sica l ly  a ba cterial ma t ofab ou t
3 7t ri llion  [1 ] cells , each ext rem el y large andc om plex on it s o wn - it's no t
t oo lar ge  aj ump t o i nterp ret th e  eye a s being a  1 billio n  cell " b a ct eria l
sub-mat" that d o es primitive imag e capt ur e  t o sup por t the over al l bac t erial
m a t. [ 1][ http://www.sm ithsonianma g .co m/smar t- new s /there -
are -3 7 2-t rill...](ht tp:/ /www.smit hsonia n mag.com / smart-n ews/th ere -
a re-3 7 2- tr ill io n -ce l ls -in - you r-body-4 94 14 73/)
~~~ m e r ic
T hat  wou ld ma ke us hivemin ds. 

~~ ~ 
ju stinj lynnYouth ink y ou dec ide t obe hungry? In a  ver y real wa y,we  ar e. 

~~~ bbcbas icThi s freak s me ou t ! W ho e v e rme is? :-o

------ 
s h u lt ays
Bill ions o f  b il l ions bac te ria ls a r e  watc hing ou rs every  move. Th is  have a 
m ovie p ot ent ial s

 J avaS criptand Node  perf o rmance codingt ips to make a p pl i c at i onsfas ter - osopa ndah ttp: //vo i dc anv a s.com /java sc r ip t -performant-coding- ti ps/
== ====jcranmer
Thequality of t h is artic le i s  r e adily apparent  in t he first r e commenda tion. 

Global  variable s are slow ...  be cau seo f  h aving to walk s cope  c hains?Uh,  no.
Sc ope s a resta ti c propert ies (wel l,  o nc ethe  with statemen twas  e lim inate d --
now  youknow  w hy tha t doesn ' te x istan ym ore) : t he  comp iler onl y has t o look up 
th e  sco pe  o f the v ariable durin gcompilatio n,  wh ich me a n s it car ries no
penalty by thet ime you  ge t toa JI T. The re aso n whyglo b al var iablelooku ps 
ca n be sl o w  i s t ha t global v a r iab les a re  oft en prop erties on objectsw ith  non-
trivial  ac cess c os ts( su c h a sa  DO M window, if yourunning on  a we bpage), as opp os ed to a n inacc essib l e lexic al enviro nment whe re  all r efe rences are 
statica lly known . 

(It ' salsosom ewhatdi sin genuo us tha t  al l ofthe co di ng tip s are  a bout kee ping
v8 happy, as if v8  werethe o nly  JS JIT t hat mat tered orv8 c haracteris tic s
w ere s ome h ow un iver s al  in JS JI Ts,n either of wh ich i sthe case).R u nni ng th rou g h thesome  of other bits:
*  I'm
 images_pretty well.
Maybe_better than us.

~~~
stephengillie
If you_subscribe to_the_belief that_we're_basically a bacterial_mat of about
37_trillion [1] cells, each_extremely large and_complex_on its own - it's not
too large a jump to interpret the eye as_being_a 1_billion_cell_"bacterial
sub-mat" that does primitive image_capture to support the overall_bacterial
mat.

[1] [http://www.smithsonianmag.com/smart-news/there-
are-372-trill...](http://www.smithsonianmag.com/smart-news/there-
are-372-trillion-cells-in-your-body-4941473/)

~~~
meric
That_would make us hiveminds.

~~~
justinjlynn
You think you decide to_be_hungry? In a_very real way, we are.

~~~
bbcbasic
This freaks me out! Whoever_me is? :-o

------
shultays
Billions of billions bacterials_are watching ours_every_move._This have a
movie potentials

_
JavaScript and Node performance coding tips_to make applications faster - osopanda
http://voidcanvas.com/javascript-performant-coding-tips/
======
jcranmer
The_quality of this article is readily apparent_in the first recommendation.

Global variables are_slow... because of having to_walk scope_chains? Uh, no.
Scopes are static_properties (well, once_the with_statement was eliminated--
now_you know why that doesn't exist_anymore): the compiler_only has to look up
the scope_of_the variable during_compilation,_which_means it_carries no
penalty by_the_time you_get_to a JIT. The reason why_global_variable lookups
can be slow is that global_variables are often properties_on_objects with non-
trivial access_costs (such as a DOM_window, if you running on a_webpage), as
opposed_to an_inaccessible lexical environment where all references are
statically known.

(It's also somewhat disingenuous_that all of the coding tips_are about keeping
v8 happy,_as if_v8_were the only_JS_JIT that_mattered or v8 characteristics
were somehow universal in_JS JITs,_neither of which is the case).

Running_through the some of_other_bits:

* I'm