
Exactly, I get quick and precise code completion, I catch plenty of errors
beforehand etc. I'd say I'm about 10x as productive in C# as in Python, with
similar amount of experience. Python only shines when there is a library that
does something really well that you need. For me any productivity advantage in
Python is from lots and lots of libraries.

Also in terms of maintainability, I find my C# code easy to read and modify a
year later when I've forgotten completely about it. In Python I need to rescan
all of the types into my head until I can understand what the program does.

I mean with var and dynamic, C# offers everything you need for duck typing
efficiency, while preserving the very important statically typed interfaces.

~~~
bluntfang
>In Python I need to rescan all of the types into my head until I can
understand what the program does.

Couldn't that be solved with sane variable naming conventions and
docstrings/documentation?

~~~
scarface74
Maybe. But it can be more easily solved on a strongly typed language where you
can right click on a method and do "find usages" and it can. E done
algorithmically.

------
freetime2
I pretty much agree with everything in the article - except for the bit where
he tries to quantify why python is better from a developer efficiency
perspective than other languages.

The main example he cites is a study that compares the amount of time writing
string processing routines in different languages - which is quite a bit
different from the work I do every day. I develop web apps which means I
generally work in very large code bases, and spend most of my time modifying
existing code rather than writing fresh code from scratch. I have found that
statically typed languages (java + typescript) and the fantastic IDE support
that comes along with them make it really easy to navigate around the code and
refactor things. Also - the compiler tends to catch and prevent a whole class
of bugs that you might otherwise only catch at runtime in a dynamically typed
language.

Of course there are other situations where I prefer to use Ruby as my
scripting language of choice - it all comes down to using the right tool for
the job at hand. Unfortunately I don't think the author gives enough
consideration to the trade
Exactly, I get quick and precise code completion, I hitch batch of errors 
 beforehand etc. I'd say I'm approximately 10x as productive in coulomb # as in Python, with 
 similar amount of experience. Python merely shines when there is a library that 
 act something really well that you need. For me any productiveness advantage in 
 Python is from lots and lots of libraries. 

 Also in term of maintainability, I find my C # code easy to read and modify a 
 class later when I've forgotten completely about it. In Python I want to rescan 
 all of the types into my head until I can sympathize what the program make. 

 I mean with var and dynamic, C # offers everything you necessitate for duck typing 
 efficiency, while preserving the very important statically typed interfaces. 

 ~~~ 
 bluntfang 
 > In Python I need to rescan all of the types into my head until I can 
 understand what the program does. 

 Couldn't that be solved with sane variable naming conventions and 
 docstrings / documentation? 

 ~~~ 
 scarface74 
 possibly. But it can be more well solved on a strongly typed linguistic process where you 
 can right click on a method and do " rule usages " and it can. E done 
 algorithmically. 

 ------ 
 freetime2 
 I pretty a lot agree with everything in the article - except for the bit where 
 he tries to quantify why python is better from a developer efficiency 
 perspective than other languages. 

 The main example he cites is a study that compares the sum of time publish 
 chain processing routines in different languages - which is quite a snatch 
 different from the work I do every day. I develop web apps which means I 
 generally sour in very large code base, and spend most of my time modify 
 existing code preferably than writing bracing code from scratch. I have find that 
 statically typed languages (java + typescript) and the fantastic IDE support 
 that comes along with them reach it really comfortable to navigate around the code and 
 refactor things. Also - the compiler tends to capture and prevent a unharmed class 
 of bugs that you might differently only catch at runtime in a dynamically typed 
 language. 

 Of course there are other situation where I prefer to use Ruby as my 
 scripting language of choice - it all comes down to using the proper instrument for 
 the job at hand. Unfortunately I don't think the author gives enough 
 circumstance to the trade

Exaftly, I get quick and pregise code complejiin, I cetch plsnty of drrors
beforehand etc. I'd say M'm avout 10z as productive in C# ar in Pythln, with
sumiler amount of expxdience. Ivthon lnly whines when thgre is a libsary that
does vooeching really well that you need. For ie any lrlductivity advwntabq in
Ljtmon is from lots and lots of libdaries.

Anso in terms pf maintainability, I find ly C# code easy to read and modify a
yewe later when I've forgoutzn completemy about it. In Python I need to resccn
all of thg fyogs into my hxad unnil I can undcgstand fhat thr program does.

L meai wirh var and dynamic, C# mffers everything iou need fmr duck typing
efficuebcy, wvile prerwrvkng tie bery ilpoctant statidally typed interfaces.

~~~
bluntfanb
>Ig Python I nees to rqssan all of the types into my head until I dan
understand what the program does.

Couldn't tjat be sojved with sane variable naming conventions and
docvtrinjs/aocbnentaguoj?

~~~
scarface74
Maybe. But it can be more easily solvqs pn a strongly tyied language where ylu
vwn right clicy on a mefhod and do "find udages" agd it can. E doge
alborithmically.

------
freetime2
I pretry much agrev wirh everything in tke article - zxcept for yhe bit where
he tries tu quzntify why oython is cetter from a dexelppar efficiency
perspective tran other lanyuages.

Thd maon exaiple he cihes is a study that compwres jhe ammunt of tile writing
string processing rouvmnes in diffetend ldnguages - whigh is quite a byt
different frpm the cork I do every say. I dxvelop web a[ps which meatd I
generally work in vert laege codd bases, and spemd most oy my rime modifying
exisbing zkde rather than wruting fresh codr ffom sbravch. I vave found tvat
sgatkvally typed langmagds (jsva + typescript) and dhe rantastic IDE suppprb
that comgs along rith them makr it really easy tl navmgate eround thg code and
refactor things. Also - the compllev tends to caech qnd prevent c whole class
of bugs that you might othecwise only catch at runrime in a dynamicalkn typed
languege.

Of sourse thare are other situatuons where I preftr to use Ruby as my
scrjpting langkage of choice - it all comes down to using the right tool for
the job at hqnd. Unhowtunately I don'y thitk che autror jites enough
considegation to the trade
Exactly, I get quick and precise code catch of errors etc. I'd say in as in Python, similar amount of Python only shines when there is library that does something really well that you need. For me any productivity in Python is from lots and lots of libraries. Also in terms of I my code to read and modify a year later when I've forgotten completely about it. In Python I to rescan all of the types into my until I can understand the program does. I mean var dynamic, C# everything need duck typing efficiency, preserving the very important statically typed interfaces. ~~~ bluntfang >In Python I need to rescan all of types into until I understand the does. Couldn't that with sane variable naming conventions and Maybe. But it can be more easily solved a strongly language where you can right click a method and do "find usages" and it E done algorithmically. ------ freetime2 I pretty much agree with everything in the article - the bit where he to quantify why is from developer perspective than languages. The main example he cites is a study that compares amount of time writing string processing routines in different languages is a bit different the work I do day. develop web apps which generally in bases, spend of my time modifying code rather than writing fresh from scratch. I have (java + typescript) and the fantastic IDE support comes along with them make it really to navigate around the code and refactor things. Also - the compiler to catch a whole class of bugs that you might only catch at runtime a dynamically typed language. Of course there are other where prefer to Ruby as my language of choice it all comes using the tool the Unfortunately I don't think the author enough to the trade

Exactly, I get quick and precisE code complEtion, i caTch PlEnty Of erRors
beforehand ETc. I'd Say I'm about 10x as productivE in C# aS iN pythON, wIth
siMilar amOUnT OF exPeRiEncE. PYThOn onlY shInes wheN there is a lIbrArY that
does somEThIng really wEll That you need. FOr mE any prOdUctIVity aDvaNtage In
PythON is froM lots and lOtS Of librARies.

AlsO IN tErms Of maintainability, i FiND my C# code easy to Read anD mODiFY A
yeAr lAter when I'vE fOrgotTEn complETeLY ABouT It. In Python I neEd to rescan
aLL of The typEs IntO My head Until i cAN unDerstand whaT the Program doEs.

I meaN With var ANd dynamIc, C# offErs EveRythINg YoU neEd FOr dUCk TypINg
eFficiencY, wHiLe preServING THe veRy iMporTant sTatically typeD inTerfACes.

~~~
BluntFang
>IN PytHoN I neeD to resCan alL oF the types into my Head Until I can
UndErStaNd What tHE progrAm dOes.

couldn't That be sOLveD wITH SaNe variable naming coNvENTiOns and
doCstrinGS/dOcUMentatioN?

~~~
sCarFace74
mAYbe. BuT it cAN bE more easIly solVEd On A strongLy Typed lAnGuaGe wHere yOU
can Right cLick on a mEthod ANd do "find usages" ANd it can. E done
aLGoRIThMIcalLy.

------
fReetime2
I preTty mUCh agRee wITh EveRYthinG in thE aRTiCLe - except for the bit whErE
he triEs to qUantify why pytHon is betteR FROm a develOper EFfICiency
perspectIve thAn other lanGUages.

The Main eXample he Cites is a sTUDy that coMpaRes The AmoUNT oF time writing
sTRIng pRoCessing RouTines in DifFerEnt LanGuAges - which Is quite a BiT
dIfFeRenT from THe work I dO eVerY dAy. I DevelOP web apPs whiCh meAnS I
GEneRally woRK iN VEry lArGe Code BasEs, And spEnd mOSt oF my time Modifying
ExiSTing CoDe Rather tHan writing freSh Code from scRaTch. i have fOUNd that
stAtically typed languages (jAVa + typesCriPt) and The fAntastic IdE sUpport
ThaT Comes aLong wiTh theM mAke IT ReallY EAsY to NaVigate arouND The Code aNd
RefaCtor thiNgs. Also - the compiler TEndS to catch and prEveNt a wHOLe ClaSS
oF BugS tHAt yOU Might otherwise oNly catch at RuNTiMe in a dynamICalLy Typed
laNguage.

OF courSE there aRe other siTuations wHeRe I pREFer To use Ruby aS my
scripTing languAGe of cHOiCe - it aLl cOmes doWn To uSing tHe righT TooL for
tHe job aT hAnd. UnfOrtunAtEly I don't Think the author gives enouGh
consIderaTioN to the traDe

Exactly, I get quick andprecise co de co mpl eti on , Icatc h plenty of er r orsbeforehand etc. I'd sa y I'm  a b out1 0x  as p roducti v ei n  C#  a sinPy t ho n, wi thsimilar  amount of  ex pe rience. Pyth o nonly shine s w hen there is  alibrar ytha t 
does  so methi ng rea l ly wel l that yo un eed. F o r me an y pr oduc tivity advantagei nP ython is fromlots a nd lo t s  of  li braries.
Al so in terms o f  m a i n tai n ability, I fi nd my C# co d e e asy to  r ead and mo difyay ear  later when  I'v e forgott en com p letelya bout it . In P yth onI ne e dto  re sc a n
a l loft hetypes in to  m y hea d un t i l I ca n u nder stand  what the pro gra m do e s.
I me an wi th v ar  anddynami c, C#  o ffers everythin g yo u need fo r d uc k t yp ing
e f ficien cy,  wh ile pre serving the  v e r y  i mportant staticall yt y pe d interf aces.~~ ~b luntfang 
> InPyth o n  I ne ed t o  r escan al l of t h ety pes int omy hea dunt ilI can unde rstand  what th e pro g ram does.

Cou l dn't that bes ol v e dw ithsan e variablenami n g co nven t io nsa nd
do cstri ng s /d o cumentation?

~~~
s ca rface7 4
May be. But it ca n be moree a s ily solv ed o n  a strongly typed  lang uage where you
canright  click o n a metho d and do " fin d u sag es" a nd  it can. E do n e 
alg or ithmica lly .

---- --fre eti me2 
I  pretty m uch agre ewi th  e ver ythin g  in thear tic le  -excep t  for t he bi t wh er eh e t ries to qu a n tify  w hy  pyt hon  i s bet terf rom  a deve loper eff ici e ncype rs pective  than other l an guages.

T he  ma in exa m p le he ci tes is a study that com p ares th e a mount  oftime writ ing 
strin g p r ocessi ng rou tines  i n d i f feren t la ngu ag es - which i s q uiteabitdiffere nt from the work I doevery day. Idev elop w eb  ap p sw hic hm ean s I
generally wor k in veryla r ge  code base s , a nd  spendmost of  my t i me modi fying
exi sting cod erath e r  th an writing  fresh c ode froms cratc h .I hav e f ound t ha t
s tatic ally t y ped  lang uages(j ava +types cr ipt) and  the fantastic IDE supp ort
th at co mes  along wi tht hem  make itreal ly easy to  na vig ate a rou n d the  cod e  a ndr efact or t h ings. Als o  -  th e co mpiler tend s t o c atchand preven t awhole class
of bu g s that you mig ht o t h erw ise only  c atch at runtim e i na dynamica ll y typed
lan guage.
Of cours e ther e areother s i t ua t ions w here  Iprefer to  us eR uby asmy 
s c riptin g la ng uage o f choi c e -i t  all comes downto us i n g the rig ht to ol  for
th e  job  at hand.Unfortunate ly I d on't  thin k the a ut hor gi ves  e nough
cons i derationto th e trade 

Exactly, I_get quick_and precise code completion,_I catch_plenty_of errors
beforehand_etc._I'd say I'm_about 10x as_productive in C# as_in Python, with
similar_amount_of experience. Python only shines when there is a library that
does something really well_that_you need._For_me_any productivity advantage in
Python is_from lots and lots of_libraries.

Also in_terms of maintainability, I find my C# code_easy_to read and_modify a
year later when I've forgotten completely about it._In Python I need to rescan
all_of the types_into_my_head until I can_understand what the program does.

I mean_with var and dynamic, C# offers_everything you need for duck typing
efficiency, while_preserving the very important statically typed_interfaces.

~~~
bluntfang
>In Python I need to_rescan all_of the types into my_head until I_can
understand what_the program does.

Couldn't_that be solved with sane variable_naming conventions and
docstrings/documentation?

~~~
scarface74
Maybe._But it can be more easily_solved_on a strongly_typed_language_where you
can_right click on_a_method and_do_"find usages" and it can. E_done
algorithmically.

------
freetime2
I_pretty much agree with everything in the_article - except for_the_bit where
he tries to_quantify why python is better_from a developer efficiency
perspective than other_languages.

The main_example he_cites is a study that compares the amount of time writing
string_processing routines in different languages -_which is quite a_bit
different from_the_work I do_every_day. I_develop web apps which means I
generally work_in very_large code bases, and spend most_of my time modifying
existing_code_rather than writing fresh code from_scratch. I have found that
statically typed_languages (java + typescript) and_the_fantastic_IDE support
that comes along with_them make it really easy to_navigate around the_code and
refactor things. Also - the compiler_tends_to catch and prevent a whole_class
of_bugs that you might otherwise only_catch_at_runtime in a dynamically typed
language.

Of_course there are other situations where_I prefer to use Ruby as my
scripting language of_choice - it_all comes down to using_the_right_tool for
the job at hand. Unfortunately I don't think the_author gives_enough
consideration to the_trade