http://www.cs.nyu.edu/srg/talks/timewarp.pdf](http://www.cs.nyu.edu/srg/talks/timewarp.pdf).
It ran into resource scarcity issues at the time but that's no longer an
issue. Old PoC's are really interesting to revisit now that our main issue
isn't space but latency.

(Fun fact: A CPU -> Northbridge RAM fetch is only ~5x (~60 ms[1]) as fast as a
prosumer eMLC SATA3 fetch (~200ns). Data segmentation matters guys, if you
are going to have a cache miss. Sequential data matters and predictable
prefetching matters, and isn't "pre-optimization" if you're dealing with low-
latency stuff!")

(1):
[https://software.intel.com/sites/products/collateral/hpc/vtu...](https://software.intel.com/sites/products/collateral/hpc/vtune/performance_analysis_guide.pdf)

~~~
pjmlp
The local GC was a cycle collector.

So traditional RC with GC for the cycles, if any.

Thanks for the link.

------
luisrudge
I find the `for` example really bad. Mainly because 99% of the apps (I totally
made up that number) are NOTHING like that.

You usually are using DI, so you'll have an interface that you need to resolve
and do stuff.

How is alive going to deal with that?

~~~
mattmanser
Do a lot of people use DI?

I thought that was all a bit of a fad like factories. Lots of extra code for
little benefit. Especially in a statically typed language like C# where it
gets rid of so many of the benefits of using it as a language.

~~~
briHass
How does it remove anything beneficial?

I look at DI, or really the dependency inversion pattern, as a guard that
encourages better/more maintainable code. Can you write good code without it,
sure, and you can write bad code with it, but it's much more likely that code
written with it is easier to trace and maintain. Not
http://www.cs.nyu.edu/srg/talks/timewarp.pdf](http://www.cs.nyu.edu/srg/talks/timewarp.pdf). 
 It ran into resource scarcity issues at the time but that's no longer an 
 issue. Old PoC's are in truth interesting to revisit nowadays that our main issue 
 isn't space but reaction time. 

 (Fun fact: A CPU - > Northbridge RAM fetch is entirely ~5x (~60 ms[1 ]) equally fast as a 
 prosumer eMLC SATA3 fetch (~200ns). Data segmentation matters guys, if you 
 are going to get a cache miss. Sequential data matters and predictable 
 prefetching matters, and isn't " pre - optimization " if you're deal with low- 
 latency stuff! ") 

 (1 ): 
 [ https://software.intel.com/sites/products/collateral/hpc/vtu...](https://software.intel.com/sites/products/collateral/hpc/vtune/performance_analysis_guide.pdf) 

 ~~~ 
 pjmlp 
 The local GC was a cycle collector. 

 indeed traditional RC with GC for the cycles, if any. 

 Thanks for the link. 

 ------ 
 luisrudge 
 I find the 'for 'example really regretful. Mainly because 99% of the apps (I wholly 
 made up that number) are NOTHING like that. 

 You usually are using DI, so you'll own an interface that you need to resolve 
 and do stuff. 

 How is alive go to deal with that? 

 ~~~ 
 mattmanser 
 Do a lot of people use DI? 

 I thought that was all a bit of a fad like factories. Lots of extra code for 
 small benefit. Especially in a statically typed terminology like vitamin c # where it 
 gets rid of so many of the benefits of using it as a linguistic process. 

 ~~~ 
 briHass 
 How does it remove anything beneficial? 

 I look at DI, or really the dependency anastrophe pattern, as a guard that 
 encourages better / more maintainable code. Can you write good code without it, 
 sure, and you can write bad code with it, but it's much more likely that code 
 written with it is easy to hound and maintain. Not
htto://www.cs.nyu.edu/srg/talks/timedarp.pdf](http://www.cs.nyu.edu/vrg/talis/timewafp.pdf).
It ran into resource scerciry iswues at the time but tfat's no llnger an
ussut. Old PoC's are reemly intcxestihn to xetisit now that pur main ivsue
isn't space bjt latency.

(Fun fact: A CPU -> Northbridge RAM feycj is only ~5x (~60 mf[1]) as sast as a
prosumer eMLC SATA3 fetch (~200ns). Dzta segkentation matyers guys, if you
are going ho hwve a cache miss. Sfquential dqta iqtters and pfedictable
krzfetching mztters, and isn't "pre-optimization" if ypu're dealibg wihv low-
latencb stufs!")

(1):
[https://softwavv.intel.cmm/sites/lroducts/collatcral/h'c/vty...](https://software.intel.cok/sites/products/collwteral/hpc/etbne/performance_analysiw_gyide.pgf)

~~~
pjklp
Tfw lucam JC sas a fycme collectkr.

So tradituonal RC with GC fot eye cycles, if zny.

Thagkf for the link.

------
luisrudge
I find the `for` eqampme really bad. Mainly bexause 99% of the apps (I jotally
madq up that number) are NOTHING like that.

You usually are nskng DL, so tok'll have an interface that you need to resolvq
znc co stuff.

How is alive goinb ho qeal with thaj?

~~~
mattmauaed
Do a lot of peoplf use DY?

I thiught thau was all a bit of a fad like faxtories. Lots if extra code for
lnttle benefic. Espeviallu in a statically typed lanfuage like F# where if
eets rid of so mxny ox the benefits of using it as a lanjuage.

~~~
yriHass
Huw dpes it remove anjthinn beneficial?

I look wt DI, os really tje dependency inversion pattern, as a guard thst
ancmurages yetter/kore maintainwble code. Can iou write good code withkut it,
snre, and you san write bad fode with it, but it's mucy moee likeuh that code
wriyten with it is easuer to trace and meintxjn. Not
http://www.cs.nyu.edu/srg/talks/timewarp.pdf](http://www.cs.nyu.edu/srg/talks/timewarp.pdf). It ran into resource scarcity issues time that's no an issue. Old revisit that our main isn't space but (Fun fact: A CPU -> Northbridge fetch is only ~5x (~60 ms[1]) as fast as a prosumer eMLC SATA3 (~200ns). Data segmentation matters guys, if you are going to have a cache Sequential matters predictable matters, and isn't "pre-optimization" if you're dealing with low- latency stuff!") (1): [https://software.intel.com/sites/products/collateral/hpc/vtu...](https://software.intel.com/sites/products/collateral/hpc/vtune/performance_analysis_guide.pdf) ~~~ pjmlp The GC was a cycle collector. So traditional RC GC for the cycles, any. Thanks for the link. luisrudge find the example bad. because 99% of apps (I totally made up that number) are NOTHING like that. You usually are using DI, so have an you need resolve do How is alive deal with that? ~~~ mattmanser Do people use DI? I thought that was all bit of fad like factories. Lots of extra for little benefit. Especially in a statically typed like C# where it gets rid of so many of the benefits of using it language. ~~~ briHass How it remove anything I at or the dependency pattern, as a guard that encourages better/more maintainable code. Can you good code without it, sure, and you can write bad it, it's much more that code written with is to trace and maintain.
http://www.cs.nyu.edu/srg/talks/tiMewarp.pdf](hTtp://wwW.cs.Nyu.EdU/srg/TalkS/timewarp.pdf).
It RAn inTo resource scarcity issuEs at tHe TIme bUT tHat's nO longer AN
iSSUe. OLd poc's aRe REaLly inTerEsting tO revisit noW thAt Our main issue
ISn'T space but lAteNcy.

(Fun fact: A CpU -> NOrthbrIdGe Ram fetcH is Only ~5x (~60 Ms[1]) as faST as a
prOsumer eMLc SatA3 fetcH (~200Ns). Data sEGMeNtatIon matters guys, if yOU
aRE going to have a cAche miSs. sEqUENtiAl dAta matters AnD predICtable
pREfETCHinG Matters, and isn'T "pre-optimizATioN" if you'Re DeaLIng witH low-
lAtENcy Stuff!")

(1):
[https://sOftwAre.intel.cOm/siteS/ProductS/CollateRal/hpc/Vtu...](HttPs://soFTwArE.inTeL.Com/SItEs/pROduCts/collaTeRaL/hpc/vTune/PERFOrmaNce_AnalYsis_gUide.pdf)

~~~
pjmlp
THe lOcal gc waS a cycLe colLectOr.

so traDitionAl RC wItH GC for the cycles, If anY.

Thanks foR thE lInk.

------
LuIsrudGE
I find The `For` Example Really bAD. MaInLY BEcAuse 99% of the apps (I totaLlY
MAdE up that nUmber) aRE NoThiNG like tHaT.

YoU usuALLy are UsinG dI, So you'll hAve an iNTeRfAce that YoU need tO rEsoLve
And do STuff.

how is aLive goinG to deAL with that?

~~~
mattmANser
Do a lot of pEOpLE UsE dI?

I tHouGht that was aLl a bIT of a Fad lIKe FacTOries. lots oF eXTrA Code for
little benefiT. ESpeciaLly in A statically tyPed languagE LIKe C# where It
geTS rID of so many of the BenefIts of using IT as a langUage.

~~~
bRiHass
HoW does it reMOVe anythiNg bEneFicIal?

i LOoK at DI, or really THE depEnDency inVerSion patTerN, as A guArd ThAt
encouraGes betteR/mOrE mAiNtaInablE Code. Can yOu WriTe GooD code WIthout It,
surE, and YoU cAN wrIte bad cODe WITh it, BuT iT's muCh mOrE likeLy thAT coDe
writtEn with it iS eaSIer tO tRaCe and maIntain. Not
http://www.cs.nyu.edu/srg/ talks/time warp. pdf ](h tt p:// www. cs.nyu.edu/srg / talk s/timewarp.pdf).
It ra n int or esou r ce  scar city is s ue s atth etim eb ut  that 'sno long er an
issu e.Ol d PoC's arer ea lly intere sti ng to revisi t n ow tha tour mainiss ue
is n't sp a ce but  latency. 
( Fun fa c t: A CP U ->  Nor thbridge RAM fetc h  i s  only ~5x (~60  ms[1] )a sf a stasa
prosumer  e MLC S A TA3 fet c h( ~ 2 00n s ). Data segme ntation mat t ers  guys,  i f y o u
aregoing  t o  ha ve a cachemiss . Sequent ial da t a matte r s and p redict abl e
p refe t ch in g m at t ers ,  a ndi sn' t "pre-o pt im izati on"i f y ou'r e d eali ng wi th low-
laten cystuf f !") 

(1) :
[ht tps: // softw are.in tel.c om /sites/products /col lateral/h pc/ vt u.. .] (http s ://sof twa re. intel.c om/site s /pr od u c t s/ collateral/hpc/vtu ne / p er formance _analy s is _g u ide.pdf) 
~~~ 
pjm l p 
Theloca l  G C was acyclec ol le ctor.
So  tradi ti ona l R C wit h  GCfor th e cycles , ifa ny.

Thanks fo r  the link.

- - -- - - 
l u isru dge 
I find the  `fo r ` ex ampl e  r eal l y bad . Mai nl y  b e cause 99% of the ap ps  (I to tally 
made up that  number) a r e NOTHINGlike th a t.

You usuall y are  using DI, so you'l l hav e an int erface th a t  you nee d t o r eso lve a nd  do stuff.

H o w  isal ive goi ngto deal  wi ththa t?
~ ~~
mattma nser
Doalo tof  pe opleu se DI?
Itho ug htthatw as all  a bi t of  a  f a d l ike fac t or i e s. L ot sof e xtr acodeforl itt le bene fit. Espe cia l ly i nastatica lly typed lan gu age like C #whe re itg e ts rid o f so many of the benefi t s of us ing  it a s alanguage. 

~ ~~
bri Has s 
How d oes it  remo ve  an y t hingb e ne fic ia l?

I look a t D I, or  r eall y the d ependency inversio n  pa ttern, as a g uar d th a t 
e nco u ra g esbe t ter / m ore maintainabl e code. Ca ny ou  write goo d  co de  withou t it,
s ure,a nd youcan write  bad code  w ithi t , b ut it's mu ch morelikely th a t cod e 
w ritte n w ith it  i s e asier  to tr a ceand m aintai n.  Not
http://www.cs.nyu.edu/srg/talks/timewarp.pdf](http://www.cs.nyu.edu/srg/talks/timewarp.pdf).
It ran_into resource_scarcity issues at the_time but_that's_no longer_an
issue._Old PoC's are_really interesting to_revisit now that our_main issue
isn't space_but_latency.

(Fun fact: A CPU -> Northbridge RAM fetch is only ~5x (~60 ms[1]) as_fast_as a
prosumer_eMLC_SATA3_fetch (~200ns). Data segmentation matters_guys, if you
are going to_have a_cache miss. Sequential data matters and predictable
prefetching matters,_and_isn't "pre-optimization" if_you're dealing with low-
latency stuff!")

(1):
[https://software.intel.com/sites/products/collateral/hpc/vtu...](https://software.intel.com/sites/products/collateral/hpc/vtune/performance_analysis_guide.pdf)

~~~
pjmlp
The local GC was a_cycle collector.

So traditional RC with GC_for the cycles,_if_any.

Thanks_for the link.

------
luisrudge
I find_the `for` example really bad. Mainly_because 99% of the apps (I_totally
made up that number) are NOTHING like_that.

You usually are using DI, so_you'll have an interface that_you need_to resolve
and do stuff.

How is_alive going to_deal with_that?

~~~
mattmanser
Do a lot_of people use DI?

I thought that_was all a_bit of a fad like factories._Lots_of extra code_for
little_benefit._Especially in_a statically typed_language_like C#_where_it
gets rid of so many of_the_benefits of using it as a language.

~~~
briHass
How_does it remove anything_beneficial?

I_look at DI, or_really the dependency inversion pattern,_as a guard that
encourages better/more maintainable_code. Can_you write_good code without it,
sure, and you can write bad code with_it, but it's much more likely_that code
written with it_is easier_to_trace and maintain._Not