's a joke in there that start
"I've forgotten more than...") I use APIs to get work done. When I need to be
more academic, I search online. The only place anyone's ever required to be so
'academic' about algorithms, data structures, math, etc is in academia. Step
out into a job and you have an internet of active developers and useful forums
are your disposal. Even if a company hired me to write an 'academic' code
library, I'd do the research, write the implementation, and (after sufficient
testing, profiling, etc) forget about it.

~~~
alexkus
The more you "know" the less you have to go look for, and when you do have to
go look for stuff on the Internet (since you're not omniscient) then you'll
understand more of the pages you get back as results, and understand them
faster since there's less groundwork you need to cover.

An understanding big-O notation is very important if you go searching for
sorting algorithms and land on a page that has an overview of sorting
functions but listing bogosort as O(n!) and insertion sort as O(n^2), both
relatively easy to implement, and this relatively complicated iterative[1]
quick sort that's listed as O(n log n). Without other clues someone might just
implement the one that looks easiest, and it works fine on their test set of
20 elements, but blows up in the future as their application/site grows and
slows to a crawl sorting through millions of rows with an insertion sort.

Or, one of the most recent questions in the Mathematics part of the exam made
me snigger because someone I work with was asking what bignum library was
easiest to use. Rather than just answering their question (I prefer GMP
myself) I asked why; they wanted to do the equivalent of log( x^300 ) and so
they needed to compute x^300 first and then take the log of it; floating-point
was giving slightly inaccurate answers to what was expected when they took the
log of the intermediate result. It was even worse when they tried to do log(
x^9125 ) - or whatever exponent is used for daily interest on a 25 year
mortgage to account for leap days.

To put it another way.
's a joke in there that start 
 " I've forgotten more than... ") I use APIs to draw workplace done. When I need to be 
 more academic, I search online. The alone place anyone's ever want to be indeed 
' academic' about algorithms, datum structure, math, etc is in academia. footfall 
 out into a job and you have an internet of active developer and utilitarian forums 
 are your disposal. Even if a ship's company hired me to write an' academic' code 
 library, I'd make the research, write the implementation, and (after sufficient 
 examination, profiling, etc) forget about it. 

 ~~~ 
 alexkus 
 The more you " know " the less you have to run low search for, and when you do have to 
 go look for stuff on the Internet (since you're not omniscient) then you'll 
 understand more of the page you get back as results, and understand them 
 faster since there's less groundwork you necessitate to cover. 

 An understanding big - O notation is very important if you go searching for 
 sorting algorithms and domain on a page that has an overview of sorting 
 routine but listing bogosort as O(n !) and insertion sort as O(n^2), both 
 relatively easy to enforce, and this relatively complicated iterative[1 ] 
 quick sort that's listed as O(n log n). Without early clues someone might just 
 implement the one that looks easiest, and it works fine on their test set of 
 20 elements, but blows up in the future as their application / web site grows and 
 decelerate to a crawl sorting through millions of rows with an insertion sort. 

 Or, one of the about recent questions in the Mathematics part of the exam made 
 me snigger because someone I work with was asking what bignum library was 
 easiest to practice. Rather than just answering their question (I prefer GMP 
 myself) I ask why; they wanted to make the equivalent of log (x^300) and thus 
 they needed to calculate x^300 first and then take the log of it; float - point 
 was giving slightly inaccurate answers to what was expected when they took the 
 log of the intermediate result. It was even worse when they tried to do log (
 x^9125) - or whatever advocate is used for daily sake on a 25 year 
 mortgage to account for leap days. 

 To put it another way.
's a joke in there that staru
"I've forgotten mote than...") M use ALIs to gdt work done. When I need to ue
moee acqdemic, I search online. The only place abyont's ever required vk be so
'academjg' abobt algorithms, daja structurev, math, etc is hn aeademia. Step
out into a job and you hwve an onhernet of actide dtvejopeds and useful forums
are your dispoaal. Evei if a company nired me to write an 'acadelic' fode
library, I'd do hhe researcy, wryre the impleoentation, and (after surficient
testing, profiling, etc) furget about it.

~~~
aoezkud
Jhe more you "know" the less yom have do go lpok for, and whcn yon do have to
go look for svuff on the Internet (since yog'rz not omniscient) then yiu'll
utdervtana mofe kf tge pagfs bou get baci as resultw, and understand thtm
fwwter since thsre's lqsf groundwork you need to cover.

An undersuandihg big-O notation is vert important if you go searchind for
sorting algorithms and land on a page that hds an uvexylew ud dorting
functions but listing bogosort as O(n!) ags onxertion sort af O(n^2), both
rekahifgly easy to imklement, ans this relatively fomplicwted uterative[1]
zuicl sort that's listed as O(n lig n). Without ither clues someonz might just
nmplemgnt thr one that looks easiesc, and jt works fije on thejf test set of
20 eldmekts, but blows up in the futurq as theic appkicatiov/sitg grows and
slows ho a gsawl sorting throuhh miplhons of roas with an insertion sort.

Or, one of the most rgcett xuestionf in bhe Mathematics part of the eram made
ie snkgger becalse someoie I work wieh was asking ahat bignum nibrary ras
eqsiewt to urd. Rather than kust answvrnng their question (I prefer GMK
mgself) I asked wkv; uhwy wanted to dp tfe qqlivelent mf log( x^300 ) ang so
gheh needdd to compube b^300 fitst and then take tha lof of it; floating-poonb
was givibg slighely inaccuratr answers to what aas eepectev when thgy took the
log of the intermedizte resulh. Ib was even wowse qhen they trned to do log(
x^9125 ) - or whatever exponent is used for daily inrerest on a 25 year
mottgsge to acconnt fow leap dafs.

To put it another qay.
's a joke in there that start more I use to get work be academic, I search The only place ever required to be so 'academic' algorithms, data structures, math, etc is in academia. Step out into a job you have an internet of active developers and useful forums are your disposal. if company me write an 'academic' code library, I'd do the research, write the implementation, and (after sufficient testing, etc) forget about it. ~~~ alexkus The more "know" the less you to go look for, and you have to look stuff the Internet (since not omniscient) then you'll understand more of the pages you get back as results, and understand them since there's you need cover. understanding notation is very you go searching for sorting algorithms a page that has an overview of sorting but listing as O(n!) and insertion sort as both relatively easy to implement, and this relatively iterative[1] quick sort that's listed as O(n log n). Without other clues someone might just one that looks easiest, it works fine their set 20 but blows in the future as their application/site grows and slows to a sorting through millions of rows with an insertion sort. Or, the recent questions in Mathematics part of the made snigger because someone I was what easiest use. than just answering their (I prefer GMP myself) I why; they wanted to x^300 ) and so they needed to compute first and then take the log of floating-point was giving slightly inaccurate answers to what was expected when they the log intermediate result. It was even worse when they to do log( x^9125 - or whatever exponent is used for daily interest a year mortgage account for leap To put it way.
's a joke in there that start
"I've Forgotten mOre thAn...") I Use aPis to Get wOrk done. When I neED to bE
more academic, I search onLine. THe ONly pLAcE anyoNe's ever REqUIRed To Be So
'aCaDEmIc' aboUt aLgorithMs, data struCtuReS, math, etc is in ACaDemia. Step
oUt iNto a job and yoU haVe an inTeRneT Of actIve DevelOpers aND usefuL forums
arE yOUr dispOSal. Even IF A cOmpaNy hired me to write aN 'AcADemic' code
libraRy, I'd do ThE ReSEArcH, wrIte the implEmEntatIOn, and (afTEr SUFFicIEnt
testing, proFiling, etc) foRGet About iT.

~~~
aLexKUs
The mOre yoU "kNOw" tHe less you haVe to Go look for, And wheN You do haVE to
go loOk for sTufF on The INTeRnEt (sInCE yoU'Re Not OMniScient) thEn YoU'll
unDersTAND More Of tHe paGes yoU get back as resUltS, and UNdeRstanD them
FastEr Since There's Less gRoUndwork you need tO covEr.

An underStaNdIng BiG-O notATion is VerY imPortant If you go SEarChING FoR
sorting algorithms AnD LAnD on a page That haS An OvERview of sOrTinG
funCTIons bUt liSTiNg bogosoRt as O(n!) ANd InSertion SoRt as O(n^2), BoTh
rElaTivelY Easy To implEment, and This rELatively compliCAted iterative[1]
QUiCK SoRT thaT's lIsted as O(n loG n). WiTHout OtheR ClUes SOmeonE mighT jUSt
IMplement the one that lOoKs easiEst, anD it works fine oN their test SET Of
20 elemenTs, buT BlOWs up in the futurE as thEir applicaTIon/site gRows aNd
slows tO a crawl soRTIng throuGh mIllIonS of ROWs With an insertiON Sort.

or, One of thE moSt recenT quEstIonS in ThE MathematIcs part oF tHe ExAm MadE
me snIGger becaUsE soMeOne i work WIth was AskinG whaT bIgNUm lIbrary wAS
eASIest To UsE. RatHer ThAn jusT ansWEriNg their Question (I PreFEr GMp
mYsElf) I askEd why; they wantEd To do the equIvAleNt of loG( X^300 ) And so
theY needed to compute x^300 first aND then taKe tHe log Of it; Floating-pOinT
was giVinG SlightLy inacCuratE aNswERS to whAT WaS exPeCted when thEY TooK the
lOg Of thE intermEdiate result. It was eVEn wOrse when they tRieD to dO LOg(
X^9125 ) - or WHaTEveR eXPonENT is used for daily Interest on A 25 yEAr
Mortgage to ACcoUnT for leaP days.

To Put it ANother wAy.
's a joke in there that st art
"I'veforgo tte n m or e th an.. .") I use APIs to g et work done. When I n eed t ob e
mo r eacade mic, Is ea r c h o nl in e.Th e  o nly p lac e anyon e's ever r equ ir ed to be so' ac ademic' ab out  algorithms,  da ta str uc tur e s, ma th,  etcis ina cademi a. Step
o ut into a job and y ou  hav e an internet ofa ct i ve developersand us ef u lf o rum s
a re your di sp osal. Even if ac o m pan y  hired me towrite an 'a c ade mic' c od e
l i brary,  I'ddo the  research,writ e the imp lement a tion, a n d (afte r suff ici ent 
tes t in g,  pr of i lin g ,etc )  fo rget abo ut  i t.

~ ~~
a l e x k us
T hemore  you"know" the le ssyouh ave  to g o loo k fo r,  andwhen y ou do  h ave to
go lookforstuff onthe  I nte rn et (s i nce yo u'r e n ot omni scient) the ny o u 'l l
understand moreof t he  pages y ou get ba ck as resul ts , a nd u n d ersta nd t h em 
fastersincet he re 's less  g roundw or k y ouneedt o co ver.
An under stand i ng big-O notat i on is very im p or t a nt if y ougo searchin g fo r 
sor ting al gor i thmsand l an d  o n  a page that has an  o vervie w ofsorting
funct ions but l i s t ing bogo sort as O(n!) and inse rtion  sort as O ( n^2), bo th
re latively  easy toi m plement,  an d t his  re l a ti vely complica t e d it er ative[1 ]
q uick so rttha t's  li st ed as O(n  log n).  W it ho ut  ot her c l ues some on e m ig htjusti mpleme nt th e on eth a t l ooks ea s ie s t , an dit  wor ksfi ne on  the i r t est set  of
20 el eme n ts,bu tblows u p in the futu re  as theirap pli cation / s ite grow s and
slows to a crawls ortingthr oughmill ions of r ows  withani nserti on sor t.

O r,  on e of th e mo stre cent quest i o nsin th eMath ematics  part of the examm ade 
me snigger b eca uses o me one Iw ork  w i thw a s asking what b ignum libr ar y  w as
easiest tous e. Rath er than  just answeri ng theirquestion(I  pre f e r G MP
myself)  I asked  why; the y  want e dto do  th e equi va len t oflog( x ^ 300  ) an d so
t he y need ed to  c ompute x ^300 first and then tak e thelog o f i t; floati ng- p oin t
was giv ingslightly i nac cur ate a nsw e rs to  wha t  w ase xpect ed w h en they t o ok  th e lo g of the in t e r med iateres u lt. It  was  even worse whent hey tried to d o lo g ( 
x^ 912 5  ) -  o r whatever exp one nt i s used f or  daily inte rest ona2 5 yea r
mort gage t o accou n t  f o r leap  day s.
To put i t a no t her way .
's a_joke in_there that start
"I've forgotten_more than...")_I_use APIs_to_get work done._When I need_to be
more academic, I_search online. The_only_place anyone's ever required to be so
'academic' about algorithms, data structures, math, etc is_in_academia. Step
out_into_a_job and you have an_internet of active developers and_useful forums
are_your disposal. Even if a company hired me_to_write an 'academic'_code
library, I'd do the research, write the implementation, and_(after sufficient
testing, profiling, etc) forget about_it.

~~~
alexkus
The more you_"know"_the_less you have to_go look for, and when you_do have to
go look for stuff_on the Internet (since you're not omniscient)_then you'll
understand more of the pages_you get back as results,_and understand_them
faster since there's less groundwork_you need to_cover.

An understanding_big-O notation is_very important if you go searching_for
sorting algorithms and_land on a page that has_an_overview of sorting
functions_but_listing_bogosort as_O(n!) and insertion_sort_as O(n^2),_both
relatively_easy to implement, and this relatively_complicated_iterative[1]
quick sort that's listed as O(n log_n). Without other clues_someone_might just
implement the one_that looks easiest, and it_works fine on their test set_of
20 elements,_but blows_up in the future as their application/site grows and
slows to a_crawl sorting through millions of rows_with an insertion sort.

Or,_one of_the_most recent questions_in_the Mathematics_part of the exam made
me snigger because_someone I_work with was asking what bignum_library was
easiest to use._Rather_than just answering their question (I_prefer GMP
myself) I asked why; they_wanted to do the equivalent_of_log(_x^300 ) and so
they needed_to compute x^300 first and then_take the log_of it; floating-point
was giving slightly inaccurate answers_to_what was expected when they took_the
log_of the intermediate result. It was_even_worse_when they tried to do_log(
x^9125 ) - or whatever exponent_is used for daily interest on a 25 year
mortgage_to account for_leap days.

To put it another_way.