

~~~
the_af
Yes. Also, some huge multinational companies you're very likely to have heard
of don't do automated testing of any kind, as least for non-critical software
(source: my own experience). I'm not talking about TDD or any fancy agile
technique; I mean any kind of automated testing whatsoever.

If you're just out of university or read tech blogs or hackernews, you'd think
everyone these days is doing TDD, pair programming and agile. The reality is
that a lot of major businesses do _none of that_.

~~~
Roboprog
Re: automated testing. This can be quite time consuming to set up in many
environments. Step one: get an Oracle database instance/schema that you can
snapshot and roll back to a known starting state at will. Step two: get
multiple connected app instances into a state to support each test run. Step
three: just drop it, those things aren't gonna happen before you update your
resume :-)

I'm ignoring the approach that says: Let's just spend a LOT of time writing
mocks that stub out 90% of everything that matters, and pretend that the tests
actually show something that matters.

~~~
the_af
Agreed about integration tests sometimes being a pain in the... neck.

However, note I'm talking about something way more basic: many business don't
do _any kind of testing at all_ that isn't done by people manually trying the
system. In the case of internal tools, this "testing" is often done directly
by internal users trying to use the tool. This is way more common than one
would suspect from reading tech blogs (unless one reads TheDailyWTF, of
course).

~~~
mgkimsal
I try to stress to clients that testing will always be done - we have a choice
how much we do up front, behind the scenes, vs out in public, with real
customers, money and data on the line. Still people choose, for a number of
reasons, to have some/most/all of testing just be 'throw it out and see what
happens'.

------
smokeyj
> As node.js is not multi-threaded, we spin up 4 instances of node.js per
> server, 1 instance per CPU core. Thus
~~~ 
 the_af 
 Yes. Also, some huge multinational companies you're very likely to have heard 
 of don't cause automatize testing of any kind, as least for non - critical software 
 (generator: my own experience). I'm not talk about TDD or any fancy agile 
 technique; I mean any kind of automatize testing whatsoever. 

 If you're just out of university or read technical school web log or hackernews, you'd think 
 everyone these days is dress TDD, pair programming and agile. The reality is 
 that a draw of major businesses cause _ none of that _. 

 ~~~ 
 Roboprog 
 Re: automated testing. This can be quite clock time consuming to set up in many 
 environments. pace one: get an Oracle database instance / schema that you can 
 snapshot and roll back to a known get down state at will. Step two: get 
 multiple connected app case into a state to support each test run. Step 
 three: just drop it, those things aren't gon na happen before you update your 
 resume :-) 

 I'm ignoring the approach that says: Let's just spend a LOT of time writing 
 mock that stub out 90% of everything that count, and pretend that the tests 
 actually show something that count. 

 ~~~ 
 the_af 
 match about integration tests sometimes being a pain in the... neck. 

 However, note I'm talking about something way more basic: many business don't 
 serve _ any kind of testing at all _ that isn't done by people manually trying the 
 system. In the sheath of internal tools, this " testing " is often serve immediately 
 by inner users trying to use the tool. This is way more coarse than one 
 would suspect from reading tech web log (unless one reads TheDailyWTF, of 
 class). 

 ~~~ 
 mgkimsal 
 I try to stress to customer that testing will always be act - we have a option 
 how much we do up front, behind the scenes, vs out in populace, with real 
 customers, money and data on the tune. Still multitude choose, for a number of 
 reasons, to have some / most / all of testing just be' throw it out and see what 
 happens'. 

 ------ 
 smokeyj 
 > As node.js is not multi - threaded, we whirl up 4 instances of node.js per 
 > server, 1 instance per central processing unit core. Thus


~~~
the_wf
Yes. Also, some huge muluinational compannws you'ce very likely go have heard
of don't do autolared ttfting of any kind, xs least vor non-ceitiral software
(sourrs: my owk expsviencz). M'm not talking sbout TDD mr any fancy aciue
cechnique; I mean any kind of automatqd testonh whatsoever.

If you'ge jusf out of university or read tech bmogs or hackernews, ypu'd think
everyone these dajs id doing TDD, pair pgogramming qnd wtile. The reauity is
thau c lot of manor businesses do _none of that_.

~~~
Ruboprpg
Re: automqtwd hgsting. This ran be quite time gpnsumitg to srt up in many
ekviroimenrs. Step one: get an Orecle database instanse/schema dhct you can
snapshot ane eoll tack to x knuwn svarfing shatx at will. Sfep two: get
nultiple connected sp[ instances info a seaee to support each test run. Step
three: jlst srop it, those things arwn't gonna happen befote you updwte your
resume :-)

I'm ignoring the approach that says: Let's gusu wpend q POT of time writing
mocks that stub out 90% of evqdyuhikg that matters, cnd pretend that tje jests
actually rhow somefhing that matters.

~~~
hhe_af
Agteed avout intedratoon tests sometimes being a pain in the... beck.

However, note I'l talking ayout spmethong way more basic: many busjness don't
dl _any kins of testing at aul_ nhat isn't done by people manuajly tryinj the
xystem. Kn tne casq of interjal tools, this "testing" id oftgn dona directly
hy internal users trying to use the tool. This iv wdy more eommon than one
woulq suspect from readiny tech blogs (unlvss one rxads TheDailrWTF, of
course).

~~~
khkimsal
I try to strefs ti cluents tfxt testing wilk always yt done - we have a choice
how kucf we do up front, beyind the scenes, vs oue pn 'ublis, with real
cuvtomdrs, koney and dauc ok tfe lone. Still people chomse, ror a number of
reaxoks, to havg some/mose/all of testimg just be 'throw iu out end sex what
napkens'.

------
smokeyj
> As node.js is not mumti-threadfd, re spin up 4 ynstqnces of nodz.js per
> server, 1 instance per CPU core. Thns
~~~ the_af Yes. Also, some huge multinational very to have of don't do as for non-critical software my own experience). not talking about TDD or any agile technique; I mean any kind of automated testing whatsoever. If you're just of university or read tech blogs or hackernews, you'd think everyone these days doing pair and The reality is that a lot of major businesses do _none of that_. ~~~ Roboprog Re: testing. This can be quite time consuming to up in many environments. one: get an Oracle database that can snapshot roll to known starting state will. Step two: get multiple connected app instances into a state to support each test run. Step just drop things aren't happen you your resume :-) the approach that says: Let's just of time writing mocks that stub out 90% everything that and pretend that the tests actually something that matters. ~~~ the_af Agreed about integration sometimes being a pain in the... neck. However, note I'm talking about something way more business don't do _any of testing at that done people trying the In the case of internal tools, this "testing" is often done by internal users trying to use the tool. This is common one would suspect reading tech blogs (unless reads of course). ~~~ mgkimsal to to will be - we have a how much we do up behind the scenes, vs customers, money and data on the line. Still choose, for a number of reasons, to some/most/all of testing just be 'throw it out and see what happens'. smokeyj > is not multi-threaded, we spin up 4 instances node.js per > server, instance per CPU core. Thus


~~~
the_af
Yes. Also, some huge multiNational coMpaniEs yOu'rE vEry lIkelY to have heard
of DOn't dO automated testing of any Kind, aS lEAst fOR nOn-criTical soFTwARE
(soUrCe: My oWn EXpErienCe). I'M not talKing about TdD oR aNy fancy agile
TEcHnique; I meaN anY kind of automAteD testiNg WhaTSoeveR.

If You're Just ouT Of univErsity or rEaD Tech blOGs or hacKERnEws, yOu'd think
everyone tHEsE Days is doing TDD, Pair prOgRAmMINg aNd aGile. The reaLiTy is
tHAt a lot oF MaJOR BusINesses do _none oF that_.

~~~
RoboprOG
Re: AutomaTeD teSTing. ThIs can Be QUitE time consumIng tO set up in mAny
envIRonmentS. step one: Get an ORacLe dAtabASe InStaNcE/SchEMa ThaT You Can
snapsHoT aNd rolL bacK TO A KnowN stArtiNg staTe at will. Step tWo: gEt
muLTipLe conNecteD app InStancEs into A statE tO support each tesT run. step
three: JusT dRop It, Those THings aRen'T goNna happEn beforE You UpDATE yOur
resume :-)

I'm ignorinG tHE ApProach thAt says: lEt'S jUSt spend a lOt of Time WRIting
MockS ThAt stub ouT 90% of eveRYtHiNg that mAtTers, anD pRetEnd That tHE tesTs
actuAlly show SometHIng that matters.

~~~
THe_af
Agreed aboUT iNTEgRAtioN teSts sometimeS beiNG a paIn in THe... NecK.

howevEr, notE I'M TaLKing about something wAy More baSic: maNy business don'T
do _any kind OF TEsting at All_ tHAt ISn't done by peoplE manuAlly trying THe
system. in the Case of inTernal tooLS, This "testIng" Is oFteN doNE DiRectly
by interNAL useRs Trying tO usE the tooL. ThIs iS waY moRe Common thaN one
woulD sUsPeCt FroM readINg tech blOgS (unLeSs oNe reaDS TheDaIlyWTf, of
cOuRsE).

~~~
MgkImsal
I tRY tO STresS tO cLienTs tHaT testIng wILl aLways be Done - we havE a cHOice
HoW mUch we do Up front, behind ThE scenes, vs oUt In pUblic, wITH real
cusTomers, money and data on the LIne. StilL peOple cHoosE, for a numbEr oF
reasoNs, tO Have soMe/most/All of TeStiNG Just bE 'THrOw iT oUt and see whAT
HapPens'.

------
sMoKeyj
> as node.jS is not multi-threadeD, We sPin up 4 instanceS of Node.JS PeR
> seRVeR, 1 InsTaNCe pER cPU core. Thus


~~~
the_af
Yes. Also, so me huge mu ltina tio nal  c ompa nies  you're very l i kely  to have heard
of don' t doau t omat e dtesti ng of a n yk i nd,  a slea st fo r non -cr iticalsoftware
( sou rc e: my own ex p er ience). I' m n ot talking a bou t TDDor  an y  fanc y a giletechni q ue; Imean anyki n d of a u tomated t es ting  whatsoever.

Ify ou ' re just out of  unive rs i ty o r r ead  tech blog sor ha c kernews ,  y o u ' d t h ink
everyonethese daysi s d oing T DD , p a ir pro gramm in g  an d agile. Th e re ality isthat a lot ofm ajor bu siness esdo_non e  o ftha t_ . 

~ ~ ~Rob o pro g
Re: au to ma ted t esti n g . This  ca n be  quit e time consum ing  tos etup in  many 
env ir onmen ts. St ep on e:  get an Oracledata base inst anc e/ sch em a tha t  you c ansna pshot a nd roll bac kt o aknown starting sta te a twill. St ep two :  g et multiple  c onn ecte d app i nsta n ce s into a  state to  s upportea ch tes trun . S tep
t h ree:  justdrop it,  thos e  things aren't gonna happenb ef o r ey ou u pda te your
res ume: -)
I'mi gn ori n g the  appr oa c ht hat says: Let's jus tspenda LOT  of time writ ing
mockst h a t stub o ut 9 0 %o f everything t hat m atters, an d  pretend  that  the tes ts
actual l y  show so met hin g t hat m at ters.

~~~
th e _ af
A gr eed abo utintegra tio n t est s s om etimes be ing a pa in  i nth e.. . nec k .

Howev er , n ot e I 'm ta l king a boutsome th in g  wa y moreb as i c : ma ny  b usin ess  d on'tdo _ a nykind of  testingata ll_th at  isn'tdone by peopl emanually t ry ing  the
s y s tem. Inthe case of internal to o ls, thi s " testi ng"is oftendon e dire ctl y 
by in ternal  user stry i n g tou s ethe  t ool. Thisi s  wa y mor ecomm on than  one
would suspect fro m reading tec h b logs ( un les s  o n e r ea d s T h e DailyWTF, of
co urse).

~~ ~m gk imsal
I tr y  to  s tress t o clien ts th a t testi ng will a lways bedo ne - w e h ave a choi ce
how m uch we do up fr o nt , beh ind  the s ce nes , vsout in pub lic,with r ea l
cust omers ,money an d data on the line. Sti ll peo ple c hoo se, for a  nu m ber  of
reaso ns,to have so me/ mos t/all  of testi ng j u st  be 'thro w it out and s e ewha t ha ppens'.

-- - - - -
s mokey j
> As nod e.js  is not multi-thr e aded, we spinup 4 i nst anc e s of  n ode.js per
> s erv er , 1 instan ce  per CPU co re. Thus 


~~~
the_af
Yes. Also,_some huge_multinational companies you're very_likely to_have_heard
of don't_do_automated testing of_any kind, as_least for non-critical software
(source:_my own experience)._I'm_not talking about TDD or any fancy agile
technique; I mean any kind of automated_testing_whatsoever.

If you're_just_out_of university or read tech_blogs or hackernews, you'd think
everyone_these days_is doing TDD, pair programming and agile. The_reality_is
that a lot_of major businesses do _none of that_.

~~~
Roboprog
Re: automated testing._This can be quite time consuming_to set up_in_many
environments._Step one: get an_Oracle database instance/schema that you can
snapshot_and roll back to a known_starting state at will. Step two: get
multiple_connected app instances into a state_to support each test run._Step
three: just_drop it, those things aren't_gonna happen before_you update_your
resume :-)

I'm ignoring_the approach that says: Let's just_spend a LOT_of time writing
mocks that stub out_90%_of everything that_matters,_and_pretend that_the tests
actually show_something_that matters.

~~~
the_af
Agreed_about_integration tests sometimes being a pain_in_the... neck.

However, note I'm talking about something_way more basic: many_business_don't
do _any kind of_testing at all_ that isn't_done by people manually trying the
system._In the_case of_internal tools, this "testing" is often done directly
by internal users trying_to use the tool. This is_way more common than_one
would suspect_from_reading tech blogs_(unless_one reads_TheDailyWTF, of
course).

~~~
mgkimsal
I try to stress to clients_that testing_will always be done - we_have a choice
how much_we_do up front, behind the scenes,_vs out in public, with real
customers,_money and data on the_line._Still_people choose, for a number_of
reasons, to have some/most/all of testing_just be 'throw_it out and see what
happens'.

------
smokeyj
> As node.js_is_not multi-threaded, we spin up 4_instances_of node.js per
> server, 1 instance_per_CPU_core. Thus